gcc/d/dmd/semantic3.d

   1 /**
   2  * Performs the semantic3 stage, which deals with function bodies.
   3  *
   4  * Copyright:   Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved
   5  * Authors:     $(LINK2 https://www.digitalmars.com, Walter Bright)
   6  * License:     $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
   7  * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/semantic3.d, _semantic3.d)
   8  * Documentation:  https://dlang.org/phobos/dmd_semantic3.html
   9  * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/semantic3.d
  10  */
  11
  12 module dmd.semantic3;
  13
  14 import core.stdc.stdio;
  15 import core.stdc.string;
  16
  17 import dmd.aggregate;
  18 import dmd.aliasthis;
  19 import dmd.arraytypes;
  20 import dmd.astcodegen;
  21 import dmd.astenums;
  22 import dmd.attrib;
  23 import dmd.blockexit;
  24 import dmd.clone;
  25 import dmd.ctorflow;
  26 import dmd.dcast;
  27 import dmd.dclass;
  28 import dmd.declaration;
  29 import dmd.denum;
  30 import dmd.dimport;
  31 import dmd.dinterpret;
  32 import dmd.dmodule;
  33 import dmd.dscope;
  34 import dmd.dstruct;
  35 import dmd.dsymbol;
  36 import dmd.dsymbolsem;
  37 import dmd.dtemplate;
  38 import dmd.dversion;
  39 import dmd.errors;
  40 import dmd.escape;
  41 import dmd.expression;
  42 import dmd.expressionsem;
  43 import dmd.func;
  44 import dmd.globals;
  45 import dmd.id;
  46 import dmd.identifier;
  47 import dmd.init;
  48 import dmd.initsem;
  49 import dmd.hdrgen;
  50 import dmd.location;
  51 import dmd.mtype;
  52 import dmd.nogc;
  53 import dmd.nspace;
  54 import dmd.ob;
  55 import dmd.objc;
  56 import dmd.opover;
  57 import dmd.parse;
  58 import dmd.root.filename;
  59 import dmd.common.outbuffer;
  60 import dmd.root.rmem;
  61 import dmd.root.rootobject;
  62 import dmd.root.utf;
  63 import dmd.sideeffect;
  64 import dmd.statementsem;
  65 import dmd.staticassert;
  66 import dmd.tokens;
  67 import dmd.semantic2;
  68 import dmd.statement;
  69 import dmd.target;
  70 import dmd.templateparamsem;
  71 import dmd.typesem;
  72 import dmd.visitor;
  73
  74 enum LOG = false;
  75
  76
  77 /*************************************
  78  * Does semantic analysis on function bodies.
  79  */
  80 extern(C++) void semantic3(Dsymbol dsym, Scope* sc)
  81 {
  82     scope v = new Semantic3Visitor(sc);
  83     dsym.accept(v);
  84 }
  85
  86 private extern(C++) final class Semantic3Visitor : Visitor
  87 {
  88     alias visit = Visitor.visit;
  89
  90     Scope* sc;
  91     this(Scope* sc) scope
  92     {
  93         this.sc = sc;
  94     }
  95
  96     override void visit(Dsymbol) {}
  97
  98     override void visit(TemplateInstance tempinst)
  99     {
 100         static if (LOG)
 101         {
 102             printf("TemplateInstance.semantic3('%s'), semanticRun = %d\n", tempinst.toChars(), tempinst.semanticRun);
 103         }
 104         //if (toChars()[0] == 'D') *(char*)0=0;
 105         if (tempinst.semanticRun >= PASS.semantic3)
 106             return;
 107         tempinst.semanticRun = PASS.semantic3;
 108         if (tempinst.errors || !tempinst.members)
 109             return;
 110
 111         TemplateDeclaration tempdecl = tempinst.tempdecl.isTemplateDeclaration();
 112         assert(tempdecl);
 113
 114         sc = tempdecl._scope;
 115         sc = sc.push(tempinst.argsym);
 116         sc = sc.push(tempinst);
 117         sc.tinst = tempinst;
 118         sc.minst = tempinst.minst;
 119
 120         int needGagging = (tempinst.gagged && !global.gag);
 121         uint olderrors = global.errors;
 122         int oldGaggedErrors = -1; // dead-store to prevent spurious warning
 123         /* If this is a gagged instantiation, gag errors.
 124          * Future optimisation: If the results are actually needed, errors
 125          * would already be gagged, so we don't really need to run semantic
 126          * on the members.
 127          */
 128         if (needGagging)
 129             oldGaggedErrors = global.startGagging();
 130
 131         for (size_t i = 0; i < tempinst.members.length; i++)
 132         {
 133             Dsymbol s = (*tempinst.members)[i];
 134             s.semantic3(sc);
 135             if (tempinst.gagged && global.errors != olderrors)
 136                 break;
 137         }
 138
 139         if (global.errors != olderrors)
 140         {
 141             if (!tempinst.errors)
 142             {
 143                 if (!tempdecl.literal)
 144                     tempinst.error(tempinst.loc, "error instantiating");
 145                 if (tempinst.tinst)
 146                     tempinst.tinst.printInstantiationTrace();
 147             }
 148             tempinst.errors = true;
 149         }
 150         if (needGagging)
 151             global.endGagging(oldGaggedErrors);
 152
 153         sc = sc.pop();
 154         sc.pop();
 155     }
 156
 157     override void visit(TemplateMixin tmix)
 158     {
 159         if (tmix.semanticRun >= PASS.semantic3)
 160             return;
 161         tmix.semanticRun = PASS.semantic3;
 162         static if (LOG)
 163         {
 164             printf("TemplateMixin.semantic3('%s')\n", tmix.toChars());
 165         }
 166         if (!tmix.members)
 167             return;
 168
 169         sc = sc.push(tmix.argsym);
 170         sc = sc.push(tmix);
 171
 172         uint olderrors = global.errors;
 173
 174         for (size_t i = 0; i < tmix.members.length; i++)
 175         {
 176             Dsymbol s = (*tmix.members)[i];
 177             s.semantic3(sc);
 178         }
 179
 180         if (global.errors != olderrors)
 181             errorSupplemental(tmix.loc, "parent scope from here: `mixin %s`", tmix.toChars());
 182
 183         sc = sc.pop();
 184         sc.pop();
 185     }
 186
 187     override void visit(Module mod)
 188     {
 189         //printf("Module::semantic3('%s'): parent = %p\n", toChars(), parent);
 190         if (mod.semanticRun != PASS.semantic2done)
 191             return;
 192         mod.semanticRun = PASS.semantic3;
 193         // Note that modules get their own scope, from scratch.
 194         // This is so regardless of where in the syntax a module
 195         // gets imported, it is unaffected by context.
 196         Scope* sc = Scope.createGlobal(mod); // create root scope
 197         //printf("Module = %p\n", sc.scopesym);
 198         if (mod.members)
 199         {
 200             // Pass 3 semantic routines: do initializers and function bodies
 201             for (size_t i = 0; i < mod.members.length; i++)
 202             {
 203                 Dsymbol s = (*mod.members)[i];
 204                 //printf("Module %s: %s.semantic3()\n", toChars(), s.toChars());
 205                 s.semantic3(sc);
 206
 207                 mod.runDeferredSemantic2();
 208             }
 209         }
 210         if (mod.userAttribDecl)
 211         {
 212             mod.userAttribDecl.semantic3(sc);
 213         }
 214         sc = sc.pop();
 215         sc.pop();
 216         mod.semanticRun = PASS.semantic3done;
 217     }
 218
 219     override void visit(FuncDeclaration funcdecl)
 220     {
 221         //printf("FuncDeclaration::semantic3(%s '%s', sc = %p)\n", funcdecl.kind(), funcdecl.toChars(), sc);
 222         /* Determine if function should add `return 0;`
 223          */
 224         bool addReturn0()
 225         {
 226             //printf("addReturn0()\n");
 227             auto f = funcdecl.type.isTypeFunction();
 228
 229             // C11 5.1.2.2.3
 230             if (sc.flags & SCOPE.Cfile && funcdecl.isCMain() && f.next.ty == Tint32)
 231                 return true;
 232
 233             return f.next.ty == Tvoid &&
 234                 (funcdecl.isMain() || global.params.betterC && funcdecl.isCMain());
 235         }
 236
 237         VarDeclaration _arguments = null;
 238
 239         if (!funcdecl.parent)
 240         {
 241             if (global.errors)
 242                 return;
 243             //printf("FuncDeclaration::semantic3(%s '%s', sc = %p)\n", kind(), toChars(), sc);
 244             assert(0);
 245         }
 246         if (funcdecl.errors || isError(funcdecl.parent))
 247         {
 248             funcdecl.errors = true;
 249
 250             // Mark that the return type could not be inferred
 251             if (funcdecl.inferRetType)
 252             {
 253                 assert(funcdecl.type);
 254                 auto tf = funcdecl.type.isTypeFunction();
 255
 256                 // Only change the return type s.t. other analysis is
 257                 // still possible e.g. missmatched parameter types
 258                 if (tf && !tf.next)
 259                     tf.next = Type.terror;
 260             }
 261             return;
 262         }
 263         //printf("FuncDeclaration::semantic3('%s.%s', %p, sc = %p, loc = %s)\n", funcdecl.parent.toChars(), funcdecl.toChars(), funcdecl, sc, funcdecl.loc.toChars());
 264         //fflush(stdout);
 265         //printf("storage class = x%x %x\n", sc.stc, storage_class);
 266         //{ static int x; if (++x == 2) *(char*)0=0; }
 267         //printf("\tlinkage = %d\n", sc.linkage);
 268
 269         if (funcdecl.ident == Id.assign && !funcdecl.inuse)
 270         {
 271             if (funcdecl.storage_class & STC.inference)
 272             {
 273                 /* https://issues.dlang.org/show_bug.cgi?id=15044
 274                  * For generated opAssign function, any errors
 275                  * from its body need to be gagged.
 276                  */
 277                 uint oldErrors = global.startGagging();
 278                 ++funcdecl.inuse;
 279                 funcdecl.semantic3(sc);
 280                 --funcdecl.inuse;
 281                 if (global.endGagging(oldErrors))   // if errors happened
 282                 {
 283                     // Disable generated opAssign, because some members forbid identity assignment.
 284                     funcdecl.storage_class |= STC.disable;
 285                     funcdecl.fbody = null;   // remove fbody which contains the error
 286                     funcdecl.hasSemantic3Errors = false;
 287                 }
 288                 return;
 289             }
 290         }
 291
 292         //printf(" sc.incontract = %d\n", (sc.flags & SCOPE.contract));
 293         if (funcdecl.semanticRun >= PASS.semantic3)
 294             return;
 295         funcdecl.semanticRun = PASS.semantic3;
 296         funcdecl.hasSemantic3Errors = false;
 297
 298         if (!funcdecl.type || funcdecl.type.ty != Tfunction)
 299             return;
 300         TypeFunction f = cast(TypeFunction)funcdecl.type;
 301         if (!funcdecl.inferRetType && f.next.ty == Terror)
 302             return;
 303
 304         if (!funcdecl.fbody && funcdecl.inferRetType && !f.next)
 305         {
 306             funcdecl.error("has no function body with return type inference");
 307             return;
 308         }
 309
 310         uint oldErrors = global.errors;
 311         auto fds = FuncDeclSem3(funcdecl,sc);
 312
 313         fds.checkInContractOverrides();
 314
 315         // Remember whether we need to generate an 'out' contract.
 316         immutable bool needEnsure = FuncDeclaration.needsFensure(funcdecl);
 317
 318         if (funcdecl.fbody || funcdecl.frequires || needEnsure)
 319         {
 320             /* Symbol table into which we place parameters and nested functions,
 321              * solely to diagnose name collisions.
 322              */
 323             funcdecl.localsymtab = new DsymbolTable();
 324
 325             // Establish function scope
 326             auto ss = new ScopeDsymbol(funcdecl.loc, null);
 327             // find enclosing scope symbol, might skip symbol-less CTFE and/or FuncExp scopes
 328             ss.parent = sc.inner().scopesym;
 329             ss.endlinnum = funcdecl.endloc.linnum;
 330             Scope* sc2 = sc.push(ss);
 331             sc2.func = funcdecl;
 332             sc2.parent = funcdecl;
 333             sc2.ctorflow.callSuper = CSX.none;
 334             sc2.sbreak = null;
 335             sc2.scontinue = null;
 336             sc2.sw = null;
 337             sc2.fes = funcdecl.fes;
 338             sc2.linkage = funcdecl.isCsymbol() ? LINK.c : LINK.d;
 339             sc2.stc &= STC.flowThruFunction;
 340             sc2.visibility = Visibility(Visibility.Kind.public_);
 341             sc2.explicitVisibility = 0;
 342             sc2.aligndecl = null;
 343             if (funcdecl.ident != Id.require && funcdecl.ident != Id.ensure)
 344                 sc2.flags = sc.flags & ~SCOPE.contract;
 345             sc2.tf = null;
 346             sc2.os = null;
 347             sc2.inLoop = false;
 348             sc2.userAttribDecl = null;
 349             if (sc2.intypeof == 1)
 350                 sc2.intypeof = 2;
 351             sc2.ctorflow.fieldinit = null;
 352
 353             /* Note: When a lambda is defined immediately under aggregate member
 354              * scope, it should be contextless due to prevent interior pointers.
 355              * e.g.
 356              *      // dg points 'this' - its interior pointer
 357              *      class C { int x; void delegate() dg = (){ this.x = 1; }; }
 358              *
 359              * However, lambdas could be used inside typeof, in order to check
 360              * some expressions validity at compile time. For such case the lambda
 361              * body can access aggregate instance members.
 362              * e.g.
 363              *      class C { int x; static assert(is(typeof({ this.x = 1; }))); }
 364              *
 365              * To properly accept it, mark these lambdas as member functions.
 366              */
 367             if (auto fld = funcdecl.isFuncLiteralDeclaration())
 368             {
 369                 if (auto ad = funcdecl.isMember2())
 370                 {
 371                     if (!sc.intypeof)
 372                     {
 373                         if (fld.tok == TOK.delegate_)
 374                             funcdecl.error("cannot be %s members", ad.kind());
 375                         else
 376                             fld.tok = TOK.function_;
 377                     }
 378                     else
 379                     {
 380                         if (fld.tok != TOK.function_)
 381                             fld.tok = TOK.delegate_;
 382                     }
 383                 }
 384             }
 385
 386             funcdecl.declareThis(sc2);
 387
 388             // Reverts: https://issues.dlang.org/show_bug.cgi?id=5710
 389             // No compiler supports this, and there was never any spec for it.
 390             // @@@DEPRECATED_2.116@@@
 391             // Deprecated in 2.096, can be made an error in 2.116.
 392             // The deprecation period is longer than usual as dual-context
 393             // functions may be widely used by dmd-compiled projects.
 394             // It also gives more time for the implementation of dual-context
 395             // functions to be reworked as a frontend-only feature.
 396             if (funcdecl.hasDualContext())
 397             {
 398                 funcdecl.deprecation("function requires a dual-context, which is deprecated");
 399                 if (auto ti = sc2.parent ? sc2.parent.isInstantiated() : null)
 400                     ti.printInstantiationTrace(Classification.deprecation);
 401             }
 402
 403             //printf("[%s] ad = %p vthis = %p\n", loc.toChars(), ad, vthis);
 404             //if (vthis) printf("\tvthis.type = %s\n", vthis.type.toChars());
 405
 406             // Declare hidden variable _arguments[] and _argptr
 407             if (f.parameterList.varargs == VarArg.variadic)
 408             {
 409                 if (f.linkage == LINK.d)
 410                 {
 411                     // Variadic arguments depend on Typeinfo being defined.
 412                     if (!global.params.useTypeInfo || !Type.dtypeinfo || !Type.typeinfotypelist)
 413                     {
 414                         if (!global.params.useTypeInfo)
 415                             funcdecl.error("D-style variadic functions cannot be used with -betterC");
 416                         else if (!Type.typeinfotypelist)
 417                             funcdecl.error("`object.TypeInfo_Tuple` could not be found, but is implicitly used in D-style variadic functions");
 418                         else
 419                             funcdecl.error("`object.TypeInfo` could not be found, but is implicitly used in D-style variadic functions");
 420                         fatal();
 421                     }
 422
 423                     // Declare _arguments[]
 424                     funcdecl.v_arguments = new VarDeclaration(funcdecl.loc, Type.typeinfotypelist.type, Id._arguments_typeinfo, null);
 425                     funcdecl.v_arguments.storage_class |= STC.temp | STC.parameter;
 426                     funcdecl.v_arguments.dsymbolSemantic(sc2);
 427                     sc2.insert(funcdecl.v_arguments);
 428                     funcdecl.v_arguments.parent = funcdecl;
 429
 430                     //Type t = Type.dtypeinfo.type.constOf().arrayOf();
 431                     Type t = Type.dtypeinfo.type.arrayOf();
 432                     _arguments = new VarDeclaration(funcdecl.loc, t, Id._arguments, null);
 433                     _arguments.storage_class |= STC.temp;
 434                     _arguments.dsymbolSemantic(sc2);
 435                     sc2.insert(_arguments);
 436                     _arguments.parent = funcdecl;
 437                 }
 438                 if (f.linkage == LINK.d || f.parameterList.length)
 439                 {
 440                     // Declare _argptr
 441                     Type t = target.va_listType(funcdecl.loc, sc);
 442                     // Init is handled in FuncDeclaration_toObjFile
 443                     funcdecl.v_argptr = new VarDeclaration(funcdecl.loc, t, Id._argptr, new VoidInitializer(funcdecl.loc));
 444                     funcdecl.v_argptr.storage_class |= STC.temp;
 445                     funcdecl.v_argptr.dsymbolSemantic(sc2);
 446                     sc2.insert(funcdecl.v_argptr);
 447                     funcdecl.v_argptr.parent = funcdecl;
 448                 }
 449             }
 450
 451             /* Declare all the function parameters as variables
 452              * and install them in parameters[]
 453              */
 454             if (const nparams = f.parameterList.length)
 455             {
 456                 /* parameters[] has all the tuples removed, as the back end
 457                  * doesn't know about tuples
 458                  */
 459                 funcdecl.parameters = new VarDeclarations();
 460                 funcdecl.parameters.reserve(nparams);
 461                 foreach (i, fparam; f.parameterList)
 462                 {
 463                     Identifier id = fparam.ident;
 464                     StorageClass stc = 0;
 465                     if (!id)
 466                     {
 467                         /* Generate identifier for un-named parameter,
 468                          * because we need it later on.
 469                          */
 470                         fparam.ident = id = Identifier.generateId("_param_", i);
 471                         stc |= STC.temp;
 472                     }
 473                     Type vtype = fparam.type;
 474                     auto v = new VarDeclaration(funcdecl.loc, vtype, id, null);
 475                     //printf("declaring parameter %s of type %s\n", v.toChars(), v.type.toChars());
 476                     stc |= STC.parameter;
 477                     if (f.parameterList.varargs == VarArg.typesafe && i + 1 == nparams)
 478                     {
 479                         stc |= STC.variadic;
 480                     }
 481
 482                     stc |= fparam.storageClass & (STC.IOR | STC.return_ | STC.scope_ | STC.lazy_ | STC.final_ | STC.TYPECTOR | STC.nodtor | STC.returnScope | STC.register);
 483                     v.storage_class = stc;
 484                     v.dsymbolSemantic(sc2);
 485                     if (!sc2.insert(v))
 486                     {
 487                         funcdecl.error("parameter `%s.%s` is already defined", funcdecl.toChars(), v.toChars());
 488                         funcdecl.errors = true;
 489                     }
 490                     else
 491                         funcdecl.parameters.push(v);
 492                     funcdecl.localsymtab.insert(v);
 493                     v.parent = funcdecl;
 494                     if (fparam.userAttribDecl)
 495                         v.userAttribDecl = fparam.userAttribDecl;
 496                 }
 497             }
 498
 499             // Declare the tuple symbols and put them in the symbol table,
 500             // but not in parameters[].
 501             if (f.parameterList.parameters)
 502             foreach (fparam; *f.parameterList.parameters)
 503             {
 504                 if (!fparam.ident)
 505                     continue; // never used, so ignore
 506                 // expand any tuples
 507                 if (fparam.type.ty != Ttuple)
 508                     continue;
 509
 510                 TypeTuple t = cast(TypeTuple)fparam.type;
 511                 size_t dim = Parameter.dim(t.arguments);
 512                 auto exps = new Objects(dim);
 513                 foreach (j; 0 .. dim)
 514                 {
 515                     Parameter narg = Parameter.getNth(t.arguments, j);
 516                     assert(narg.ident);
 517                     VarDeclaration v = sc2.search(Loc.initial, narg.ident, null).isVarDeclaration();
 518                     assert(v);
 519                     (*exps)[j] = new VarExp(v.loc, v);
 520                 }
 521                 assert(fparam.ident);
 522                 auto v = new TupleDeclaration(funcdecl.loc, fparam.ident, exps);
 523                 //printf("declaring tuple %s\n", v.toChars());
 524                 v.isexp = true;
 525                 if (!sc2.insert(v))
 526                     funcdecl.error("parameter `%s.%s` is already defined", funcdecl.toChars(), v.toChars());
 527                 funcdecl.localsymtab.insert(v);
 528                 v.parent = funcdecl;
 529             }
 530
 531             // Precondition invariant
 532             Statement fpreinv = null;
 533             if (funcdecl.addPreInvariant())
 534             {
 535                 Expression e = addInvariant(funcdecl.isThis(), funcdecl.vthis);
 536                 if (e)
 537                     fpreinv = new ExpStatement(Loc.initial, e);
 538             }
 539
 540             // Postcondition invariant
 541             Statement fpostinv = null;
 542             if (funcdecl.addPostInvariant())
 543             {
 544                 Expression e = addInvariant(funcdecl.isThis(), funcdecl.vthis);
 545                 if (e)
 546                     fpostinv = new ExpStatement(Loc.initial, e);
 547             }
 548
 549             // Pre/Postcondition contract
 550             if (!funcdecl.fbody)
 551                 funcdecl.buildEnsureRequire();
 552
 553             Scope* scout = null;
 554             if (needEnsure || funcdecl.addPostInvariant())
 555             {
 556                 /* https://issues.dlang.org/show_bug.cgi?id=3657
 557                  * Set the correct end line number for fensure scope.
 558                  */
 559                 uint fensure_endlin = funcdecl.endloc.linnum;
 560                 if (funcdecl.fensure)
 561                     if (auto s = funcdecl.fensure.isScopeStatement())
 562                         fensure_endlin = s.endloc.linnum;
 563
 564                 if ((needEnsure && global.params.useOut == CHECKENABLE.on) || fpostinv)
 565                 {
 566                     funcdecl.returnLabel = funcdecl.searchLabel(Id.returnLabel);
 567                 }
 568
 569                 // scope of out contract (need for vresult.semantic)
 570                 auto sym = new ScopeDsymbol(funcdecl.loc, null);
 571                 sym.parent = sc2.scopesym;
 572                 sym.endlinnum = fensure_endlin;
 573                 scout = sc2.push(sym);
 574             }
 575
 576             if (funcdecl.fbody)
 577             {
 578                 auto sym = new ScopeDsymbol(funcdecl.loc, null);
 579                 sym.parent = sc2.scopesym;
 580                 sym.endlinnum = funcdecl.endloc.linnum;
 581                 sc2 = sc2.push(sym);
 582
 583                 auto ad2 = funcdecl.isMemberLocal();
 584
 585                 /* If this is a class constructor
 586                  */
 587                 if (ad2 && funcdecl.isCtorDeclaration())
 588                 {
 589                     sc2.ctorflow.allocFieldinit(ad2.fields.length);
 590                     foreach (v; ad2.fields)
 591                     {
 592                         v.ctorinit = 0;
 593                     }
 594                 }
 595
 596                 bool inferRef = (f.isref && (funcdecl.storage_class & STC.auto_));
 597
 598                 funcdecl.fbody = funcdecl.fbody.statementSemantic(sc2);
 599                 if (!funcdecl.fbody)
 600                     funcdecl.fbody = new CompoundStatement(Loc.initial, new Statements());
 601
 602                 if (funcdecl.isNaked())
 603                 {
 604                     fpreinv = null;         // can't accommodate with no stack frame
 605                     fpostinv = null;
 606                 }
 607
 608                 assert(funcdecl.type == f || (funcdecl.type.ty == Tfunction && f.purity == PURE.impure && (cast(TypeFunction)funcdecl.type).purity >= PURE.fwdref));
 609                 f = cast(TypeFunction)funcdecl.type;
 610
 611                 if (funcdecl.inferRetType)
 612                 {
 613                     // If no return type inferred yet, then infer a void
 614                     if (!f.next)
 615                         f.next = Type.tvoid;
 616                     if (f.checkRetType(funcdecl.loc))
 617                         funcdecl.fbody = new ErrorStatement();
 618                     else
 619                         funcdecl.checkMain(); // Check main() parameters and return type
 620                 }
 621
 622                 if (f.next !is null)
 623                     f.next.checkComplexTransition(funcdecl.loc, sc);
 624
 625                 if (funcdecl.returns && !funcdecl.fbody.isErrorStatement())
 626                 {
 627                     for (size_t i = 0; i < funcdecl.returns.length;)
 628                     {
 629                         Expression exp = (*funcdecl.returns)[i].exp;
 630                         if (exp.op == EXP.variable && (cast(VarExp)exp).var == funcdecl.vresult)
 631                         {
 632                             if (addReturn0())
 633                                 exp.type = Type.tint32;
 634                             else
 635                                 exp.type = f.next;
 636                             // Remove `return vresult;` from returns
 637                             funcdecl.returns.remove(i);
 638                             continue;
 639                         }
 640                         if (inferRef && f.isref && !exp.type.constConv(f.next)) // https://issues.dlang.org/show_bug.cgi?id=13336
 641                             f.isref = false;
 642                         i++;
 643                     }
 644                 }
 645                 if (f.isref) // Function returns a reference
 646                 {
 647                     if (funcdecl.storage_class & STC.auto_)
 648                         funcdecl.storage_class &= ~STC.auto_;
 649                 }
 650
 651                 // handle NRVO
 652                 if (!target.isReturnOnStack(f, funcdecl.needThis()) || !funcdecl.checkNRVO())
 653                     funcdecl.isNRVO = false;
 654
 655                 if (funcdecl.fbody.isErrorStatement())
 656                 {
 657                 }
 658                 else if (funcdecl.isStaticCtorDeclaration())
 659                 {
 660                     /* It's a static constructor. Ensure that all
 661                      * ctor consts were initialized.
 662                      */
 663                     ScopeDsymbol pd = funcdecl.toParent().isScopeDsymbol();
 664                     for (size_t i = 0; i < pd.members.length; i++)
 665                     {
 666                         Dsymbol s = (*pd.members)[i];
 667                         s.checkCtorConstInit();
 668                     }
 669                 }
 670                 else if (ad2 && funcdecl.isCtorDeclaration())
 671                 {
 672                     ClassDeclaration cd = ad2.isClassDeclaration();
 673
 674                     // Verify that all the ctorinit fields got initialized
 675                     if (!(sc2.ctorflow.callSuper & CSX.this_ctor))
 676                     {
 677                         foreach (i, v; ad2.fields)
 678                         {
 679                             if (v.isThisDeclaration())
 680                                 continue;
 681                             if (v.ctorinit == 0)
 682                             {
 683                                 /* Current bugs in the flow analysis:
 684                                  * 1. union members should not produce error messages even if
 685                                  *    not assigned to
 686                                  * 2. structs should recognize delegating opAssign calls as well
 687                                  *    as delegating calls to other constructors
 688                                  */
 689                                 if (v.isCtorinit() && !v.type.isMutable() && cd)
 690                                     funcdecl.error("missing initializer for %s field `%s`", MODtoChars(v.type.mod), v.toChars());
 691                                 else if (v.storage_class & STC.nodefaultctor)
 692                                     error(funcdecl.loc, "field `%s` must be initialized in constructor", v.toChars());
 693                                 else if (v.type.needsNested())
 694                                     error(funcdecl.loc, "field `%s` must be initialized in constructor, because it is nested struct", v.toChars());
 695                             }
 696                             else
 697                             {
 698                                 bool mustInit = (v.storage_class & STC.nodefaultctor || v.type.needsNested());
 699                                 if (mustInit && !(sc2.ctorflow.fieldinit[i].csx & CSX.this_ctor))
 700                                 {
 701                                     funcdecl.error("field `%s` must be initialized but skipped", v.toChars());
 702                                 }
 703                             }
 704                         }
 705                     }
 706                     sc2.ctorflow.freeFieldinit();
 707
 708                     if (cd && !(sc2.ctorflow.callSuper & CSX.any_ctor) && cd.baseClass && cd.baseClass.ctor)
 709                     {
 710                         sc2.ctorflow.callSuper = CSX.none;
 711
 712                         // Insert implicit super() at start of fbody
 713                         Type tthis = ad2.type.addMod(funcdecl.vthis.type.mod);
 714                         FuncDeclaration fd = resolveFuncCall(Loc.initial, sc2, cd.baseClass.ctor, null, tthis, ArgumentList(), FuncResolveFlag.quiet);
 715                         if (!fd)
 716                         {
 717                             funcdecl.error("no match for implicit `super()` call in constructor");
 718                         }
 719                         else if (fd.storage_class & STC.disable)
 720                         {
 721                             funcdecl.error("cannot call `super()` implicitly because it is annotated with `@disable`");
 722                         }
 723                         else
 724                         {
 725                             Expression e1 = new SuperExp(Loc.initial);
 726                             Expression e = new CallExp(Loc.initial, e1);
 727                             e = e.expressionSemantic(sc2);
 728                             Statement s = new ExpStatement(Loc.initial, e);
 729                             funcdecl.fbody = new CompoundStatement(Loc.initial, s, funcdecl.fbody);
 730                         }
 731                     }
 732                     //printf("ctorflow.callSuper = x%x\n", sc2.ctorflow.callSuper);
 733                 }
 734
 735                 /* https://issues.dlang.org/show_bug.cgi?id=17502
 736                  * Wait until after the return type has been inferred before
 737                  * generating the contracts for this function, and merging contracts
 738                  * from overrides.
 739                  *
 740                  * https://issues.dlang.org/show_bug.cgi?id=17893
 741                  * However should take care to generate this before inferered
 742                  * function attributes are applied, such as 'nothrow'.
 743                  *
 744                  * This was originally at the end of the first semantic pass, but
 745                  * required a fix-up to be done here for the '__result' variable
 746                  * type of __ensure() inside auto functions, but this didn't work
 747                  * if the out parameter was implicit.
 748                  */
 749                 funcdecl.buildEnsureRequire();
 750
 751                 // Check for errors related to 'nothrow'.
 752                 const blockexit = funcdecl.fbody.blockExit(funcdecl, f.isnothrow);
 753                 if (f.isnothrow && blockexit & BE.throw_)
 754                     error(funcdecl.loc, "%s `%s` may throw but is marked as `nothrow`", funcdecl.kind(), funcdecl.toPrettyChars());
 755
 756                 if (!(blockexit & (BE.throw_ | BE.halt) || funcdecl.hasCatches))
 757                 {
 758                     /* Don't generate unwind tables for this function
 759                      * https://issues.dlang.org/show_bug.cgi?id=17997
 760                      */
 761                     funcdecl.hasNoEH = true;
 762                 }
 763
 764                 if (funcdecl.nothrowInprocess)
 765                 {
 766                     if (funcdecl.type == f)
 767                         f = cast(TypeFunction)f.copy();
 768                     f.isnothrow = !(blockexit & BE.throw_);
 769                 }
 770
 771                 if (funcdecl.fbody.isErrorStatement())
 772                 {
 773                 }
 774                 else if (ad2 && funcdecl.isCtorDeclaration())
 775                 {
 776                     /* Append:
 777                      *  return this;
 778                      * to function body
 779                      */
 780                     if (blockexit & BE.fallthru)
 781                     {
 782                         Statement s = new ReturnStatement(funcdecl.loc, null);
 783                         s = s.statementSemantic(sc2);
 784                         funcdecl.fbody = new CompoundStatement(funcdecl.loc, funcdecl.fbody, s);
 785                         funcdecl.hasReturnExp |= (funcdecl.hasReturnExp & 1 ? 16 : 1);
 786                     }
 787                 }
 788                 else if (funcdecl.fes)
 789                 {
 790                     // For foreach(){} body, append a return 0;
 791                     if (blockexit & BE.fallthru)
 792                     {
 793                         Expression e = IntegerExp.literal!0;
 794                         Statement s = new ReturnStatement(Loc.initial, e);
 795                         funcdecl.fbody = new CompoundStatement(Loc.initial, funcdecl.fbody, s);
 796                         funcdecl.hasReturnExp |= (funcdecl.hasReturnExp & 1 ? 16 : 1);
 797                     }
 798                     assert(!funcdecl.returnLabel);
 799                 }
 800                 else if (f.next.toBasetype().ty == Tnoreturn)
 801                 {
 802                     // Fallthrough despite being declared as noreturn? return is already rejected when evaluating the ReturnStatement
 803                     if (blockexit & BE.fallthru)
 804                     {
 805                         funcdecl.error("is typed as `%s` but does return", f.next.toChars());
 806                         funcdecl.loc.errorSupplemental("`noreturn` functions must either throw, abort or loop indefinitely");
 807                     }
 808                 }
 809                 else
 810                 {
 811                     const(bool) inlineAsm = (funcdecl.hasReturnExp & 8) != 0;
 812                     if ((blockexit & BE.fallthru) && f.next.ty != Tvoid && !inlineAsm && !(sc.flags & SCOPE.Cfile))
 813                     {
 814                         if (!funcdecl.hasReturnExp)
 815                             funcdecl.error("has no `return` statement, but is expected to return a value of type `%s`", f.next.toChars());
 816                         else
 817                             funcdecl.error("no `return exp;` or `assert(0);` at end of function");
 818                     }
 819                 }
 820
 821                 if (funcdecl.returns)
 822                 {
 823                     bool implicit0 = addReturn0();
 824                     Type tret = implicit0 ? Type.tint32 : f.next;
 825                     assert(tret.ty != Tvoid);
 826                     if (funcdecl.vresult || funcdecl.returnLabel)
 827                         funcdecl.buildResultVar(scout ? scout : sc2, tret);
 828
 829                     /* Cannot move this loop into NrvoWalker, because
 830                      * returns[i] may be in the nested delegate for foreach-body.
 831                      */
 832                     for (size_t i = 0; i < funcdecl.returns.length; i++)
 833                     {
 834                         ReturnStatement rs = (*funcdecl.returns)[i];
 835                         Expression exp = rs.exp;
 836                         if (exp.op == EXP.error)
 837                             continue;
 838                         if (tret.ty == Terror)
 839                         {
 840                             // https://issues.dlang.org/show_bug.cgi?id=13702
 841                             exp = checkGC(sc2, exp);
 842                             continue;
 843                         }
 844
 845                         /* If the expression in the return statement (exp) cannot be implicitly
 846                          * converted to the return type (tret) of the function and if the
 847                          * type of the expression is type isolated, then it may be possible
 848                          * that a promotion to `immutable` or `inout` (through a cast) will
 849                          * match the return type.
 850                          */
 851                         if (!exp.implicitConvTo(tret) && funcdecl.isTypeIsolated(exp.type))
 852                         {
 853                             /* https://issues.dlang.org/show_bug.cgi?id=20073
 854                              *
 855                              * The problem is that if the type of the returned expression (exp.type)
 856                              * is an aggregated declaration with an alias this, the alias this may be
 857                              * used for the conversion testing without it being an isolated type.
 858                              *
 859                              * To make sure this does not happen, we can test here the implicit conversion
 860                              * only for the aggregated declaration type by using `implicitConvToWithoutAliasThis`.
 861                              * The implicit conversion with alias this is taken care of later.
 862                              */
 863                             AggregateDeclaration aggDecl = isAggregate(exp.type);
 864                             TypeStruct tstruct;
 865                             TypeClass tclass;
 866                             bool hasAliasThis;
 867                             if (aggDecl && aggDecl.aliasthis)
 868                             {
 869                                 hasAliasThis = true;
 870                                 tclass = exp.type.isTypeClass();
 871                                 if (!tclass)
 872                                     tstruct = exp.type.isTypeStruct();
 873                                 assert(tclass || tstruct);
 874                             }
 875                             if (hasAliasThis)
 876                             {
 877                                 if (tclass)
 878                                 {
 879                                     if ((cast(TypeClass)(exp.type.immutableOf())).implicitConvToWithoutAliasThis(tret))
 880                                         exp = exp.castTo(sc2, exp.type.immutableOf());
 881                                     else if ((cast(TypeClass)(exp.type.wildOf())).implicitConvToWithoutAliasThis(tret))
 882                                         exp = exp.castTo(sc2, exp.type.wildOf());
 883                                 }
 884                                 else
 885                                 {
 886                                     if ((cast(TypeStruct)exp.type.immutableOf()).implicitConvToWithoutAliasThis(tret))
 887                                         exp = exp.castTo(sc2, exp.type.immutableOf());
 888                                     else if ((cast(TypeStruct)exp.type.immutableOf()).implicitConvToWithoutAliasThis(tret))
 889                                         exp = exp.castTo(sc2, exp.type.wildOf());
 890                                 }
 891                             }
 892                             else
 893                             {
 894                                 if (exp.type.immutableOf().implicitConvTo(tret))
 895                                     exp = exp.castTo(sc2, exp.type.immutableOf());
 896                                 else if (exp.type.wildOf().implicitConvTo(tret))
 897                                     exp = exp.castTo(sc2, exp.type.wildOf());
 898                             }
 899                         }
 900
 901                         const hasCopyCtor = exp.type.ty == Tstruct && (cast(TypeStruct)exp.type).sym.hasCopyCtor;
 902                         // if a copy constructor is present, the return type conversion will be handled by it
 903                         if (!(hasCopyCtor && exp.isLvalue()))
 904                         {
 905                             if (f.isref && !MODimplicitConv(exp.type.mod, tret.mod) && !tret.isTypeSArray())
 906                                 error(exp.loc, "expression `%s` of type `%s` is not implicitly convertible to return type `ref %s`",
 907                                       exp.toChars(), exp.type.toChars(), tret.toChars());
 908                             else
 909                                 exp = exp.implicitCastTo(sc2, tret);
 910                         }
 911
 912                         if (f.isref)
 913                         {
 914                             // Function returns a reference
 915                             exp = exp.toLvalue(sc2, exp);
 916                             checkReturnEscapeRef(sc2, exp, false);
 917                             exp = exp.optimize(WANTvalue, /*keepLvalue*/ true);
 918                         }
 919                         else
 920                         {
 921                             exp = exp.optimize(WANTvalue);
 922
 923                             /* https://issues.dlang.org/show_bug.cgi?id=10789
 924                              * If NRVO is not possible, all returned lvalues should call their postblits.
 925                              */
 926                             if (!funcdecl.isNRVO())
 927                                 exp = doCopyOrMove(sc2, exp, f.next);
 928
 929                             if (tret.hasPointers())
 930                                 checkReturnEscape(sc2, exp, false);
 931                         }
 932
 933                         exp = checkGC(sc2, exp);
 934
 935                         if (funcdecl.vresult)
 936                         {
 937                             // Create: return vresult = exp;
 938                             exp = new BlitExp(rs.loc, funcdecl.vresult, exp);
 939                             exp.type = funcdecl.vresult.type;
 940
 941                             if (rs.caseDim)
 942                                 exp = Expression.combine(exp, new IntegerExp(rs.caseDim));
 943                         }
 944                         else if (funcdecl.tintro && !tret.equals(funcdecl.tintro.nextOf()))
 945                         {
 946                             exp = exp.implicitCastTo(sc2, funcdecl.tintro.nextOf());
 947                         }
 948                         rs.exp = exp;
 949                     }
 950                 }
 951                 if (funcdecl.nrvo_var || funcdecl.returnLabel)
 952                 {
 953                     scope NrvoWalker nw = new NrvoWalker();
 954                     nw.fd = funcdecl;
 955                     nw.sc = sc2;
 956                     nw.visitStmt(funcdecl.fbody);
 957                 }
 958
 959                 sc2 = sc2.pop();
 960             }
 961
 962             if (global.params.inclusiveInContracts)
 963             {
 964                 funcdecl.frequire = funcdecl.mergeFrequireInclusivePreview(
 965                     funcdecl.frequire, funcdecl.fdrequireParams);
 966             }
 967             else
 968             {
 969                 funcdecl.frequire = funcdecl.mergeFrequire(funcdecl.frequire, funcdecl.fdrequireParams);
 970             }
 971             funcdecl.fensure = funcdecl.mergeFensure(funcdecl.fensure, Id.result, funcdecl.fdensureParams);
 972
 973             Statement freq = funcdecl.frequire;
 974             Statement fens = funcdecl.fensure;
 975
 976             /* Do the semantic analysis on the [in] preconditions and
 977              * [out] postconditions.
 978              */
 979             immutable bool isnothrow = f.isnothrow && !funcdecl.nothrowInprocess;
 980             if (freq)
 981             {
 982                 /* frequire is composed of the [in] contracts
 983                  */
 984                 auto sym = new ScopeDsymbol(funcdecl.loc, null);
 985                 sym.parent = sc2.scopesym;
 986                 sym.endlinnum = funcdecl.endloc.linnum;
 987                 sc2 = sc2.push(sym);
 988                 sc2.flags = (sc2.flags & ~SCOPE.contract) | SCOPE.require;
 989
 990                 // BUG: need to error if accessing out parameters
 991                 // BUG: need to disallow returns
 992                 // BUG: verify that all in and ref parameters are read
 993                 freq = freq.statementSemantic(sc2);
 994
 995                 // @@@DEPRECATED_2.111@@@ - pass `isnothrow` instead of `false` to print a more detailed error msg`
 996                 const blockExit = freq.blockExit(funcdecl, false);
 997                 if (blockExit & BE.throw_)
 998                 {
 999                     if (isnothrow)
1000                         // @@@DEPRECATED_2.111@@@
1001                         // Deprecated in 2.101, can be made an error in 2.111
1002                         deprecation(funcdecl.loc, "`%s`: `in` contract may throw but function is marked as `nothrow`",
1003                             funcdecl.toPrettyChars());
1004                     else if (funcdecl.nothrowInprocess)
1005                         f.isnothrow = false;
1006                 }
1007
1008                 funcdecl.hasNoEH = false;
1009
1010                 sc2 = sc2.pop();
1011
1012                 if (global.params.useIn == CHECKENABLE.off)
1013                     freq = null;
1014             }
1015
1016             if (fens)
1017             {
1018                 /* fensure is composed of the [out] contracts
1019                  */
1020                 if (f.next.ty == Tvoid && funcdecl.fensures)
1021                 {
1022                     foreach (e; *funcdecl.fensures)
1023                     {
1024                         if (e.id)
1025                         {
1026                             funcdecl.error(e.ensure.loc, "`void` functions have no result");
1027                             //fens = null;
1028                         }
1029                     }
1030                 }
1031
1032                 sc2 = scout; //push
1033                 sc2.flags = (sc2.flags & ~SCOPE.contract) | SCOPE.ensure;
1034
1035                 // BUG: need to disallow returns and throws
1036
1037                 if (funcdecl.fensure && f.next.ty != Tvoid)
1038                     funcdecl.buildResultVar(scout, f.next);
1039
1040                 fens = fens.statementSemantic(sc2);
1041
1042                 // @@@DEPRECATED_2.111@@@ - pass `isnothrow` instead of `false` to print a more detailed error msg`
1043                 const blockExit = fens.blockExit(funcdecl, false);
1044                 if (blockExit & BE.throw_)
1045                 {
1046                     if (isnothrow)
1047                         // @@@DEPRECATED_2.111@@@
1048                         // Deprecated in 2.101, can be made an error in 2.111
1049                         deprecation(funcdecl.loc, "`%s`: `out` contract may throw but function is marked as `nothrow`",
1050                             funcdecl.toPrettyChars());
1051                     else if (funcdecl.nothrowInprocess)
1052                         f.isnothrow = false;
1053                 }
1054
1055                 funcdecl.hasNoEH = false;
1056
1057                 sc2 = sc2.pop();
1058
1059                 if (global.params.useOut == CHECKENABLE.off)
1060                     fens = null;
1061             }
1062             if (funcdecl.fbody && funcdecl.fbody.isErrorStatement())
1063             {
1064             }
1065             else
1066             {
1067                 auto a = new Statements();
1068                 // Merge in initialization of 'out' parameters
1069                 if (funcdecl.parameters)
1070                 {
1071                     for (size_t i = 0; i < funcdecl.parameters.length; i++)
1072                     {
1073                         VarDeclaration v = (*funcdecl.parameters)[i];
1074                         if (v.storage_class & STC.out_)
1075                         {
1076                             if (!v._init)
1077                             {
1078                                 v.error("zero-length `out` parameters are not allowed.");
1079                                 return;
1080                             }
1081                             ExpInitializer ie = v._init.isExpInitializer();
1082                             assert(ie);
1083                             if (auto iec = ie.exp.isConstructExp())
1084                             {
1085                                 // construction occurred in parameter processing
1086                                 auto ec = new AssignExp(iec.loc, iec.e1, iec.e2);
1087                                 ec.type = iec.type;
1088                                 ie.exp = ec;
1089                             }
1090                             a.push(new ExpStatement(Loc.initial, ie.exp));
1091                         }
1092                     }
1093                 }
1094
1095                 if (_arguments)
1096                 {
1097                     /* Advance to elements[] member of TypeInfo_Tuple with:
1098                      *  _arguments = v_arguments.elements;
1099                      */
1100                     Expression e = new VarExp(Loc.initial, funcdecl.v_arguments);
1101                     e = new DotIdExp(Loc.initial, e, Id.elements);
1102                     e = new ConstructExp(Loc.initial, _arguments, e);
1103                     e = e.expressionSemantic(sc2);
1104
1105                     _arguments._init = new ExpInitializer(Loc.initial, e);
1106                     auto de = new DeclarationExp(Loc.initial, _arguments);
1107                     a.push(new ExpStatement(Loc.initial, de));
1108                 }
1109
1110                 // Merge contracts together with body into one compound statement
1111
1112                 if (freq || fpreinv)
1113                 {
1114                     if (!freq)
1115                         freq = fpreinv;
1116                     else if (fpreinv)
1117                         freq = new CompoundStatement(Loc.initial, freq, fpreinv);
1118
1119                     a.push(freq);
1120                 }
1121
1122                 if (funcdecl.fbody)
1123                     a.push(funcdecl.fbody);
1124
1125                 if (fens || fpostinv)
1126                 {
1127                     if (!fens)
1128                         fens = fpostinv;
1129                     else if (fpostinv)
1130                         fens = new CompoundStatement(Loc.initial, fpostinv, fens);
1131
1132                     auto ls = new LabelStatement(Loc.initial, Id.returnLabel, fens);
1133                     funcdecl.returnLabel.statement = ls;
1134                     a.push(funcdecl.returnLabel.statement);
1135
1136                     if (f.next.ty != Tvoid && funcdecl.vresult)
1137                     {
1138                         // Create: return vresult;
1139                         Expression e = new VarExp(Loc.initial, funcdecl.vresult);
1140                         if (funcdecl.tintro)
1141                         {
1142                             e = e.implicitCastTo(sc, funcdecl.tintro.nextOf());
1143                             e = e.expressionSemantic(sc);
1144                         }
1145                         auto s = new ReturnStatement(Loc.initial, e);
1146                         a.push(s);
1147                     }
1148                 }
1149                 if (addReturn0())
1150                 {
1151                     // Add a return 0; statement
1152                     Statement s = new ReturnStatement(Loc.initial, IntegerExp.literal!0);
1153                     a.push(s);
1154                 }
1155
1156                 Statement sbody = new CompoundStatement(Loc.initial, a);
1157
1158                 /* Append destructor calls for parameters as finally blocks.
1159                  */
1160                 if (funcdecl.parameters)
1161                 {
1162                     // check if callee destroys arguments
1163                     const bool paramsNeedDtor = target.isCalleeDestroyingArgs(f);
1164
1165                     foreach (v; *funcdecl.parameters)
1166                     {
1167                         if (v.isReference() || (v.storage_class & STC.lazy_))
1168                             continue;
1169                         if (v.needsScopeDtor())
1170                         {
1171                             v.storage_class |= STC.nodtor;
1172                             if (!paramsNeedDtor)
1173                                 continue;
1174
1175                             // same with ExpStatement.scopeCode()
1176                             Statement s = new DtorExpStatement(Loc.initial, v.edtor, v);
1177
1178                             s = s.statementSemantic(sc2);
1179
1180                             const blockexit = s.blockExit(funcdecl, isnothrow);
1181                             if (blockexit & BE.throw_)
1182                             {
1183                                 funcdecl.hasNoEH = false;
1184                                 if (isnothrow)
1185                                     error(funcdecl.loc, "%s `%s` may throw but is marked as `nothrow`", funcdecl.kind(), funcdecl.toPrettyChars());
1186                                 else if (funcdecl.nothrowInprocess)
1187                                     f.isnothrow = false;
1188                             }
1189
1190                             if (sbody.blockExit(funcdecl, f.isnothrow) == BE.fallthru)
1191                                 sbody = new CompoundStatement(Loc.initial, sbody, s);
1192                             else
1193                                 sbody = new TryFinallyStatement(Loc.initial, sbody, s);
1194                         }
1195                     }
1196                 }
1197                 // from this point on all possible 'throwers' are checked
1198                 funcdecl.nothrowInprocess = false;
1199
1200                 if (funcdecl.isSynchronized())
1201                 {
1202                     /* Wrap the entire function body in a synchronized statement
1203                      */
1204                     ClassDeclaration cd = funcdecl.toParentDecl().isClassDeclaration();
1205                     if (cd)
1206                     {
1207                         if (target.libraryObjectMonitors(funcdecl, sbody))
1208                         {
1209                             Expression vsync;
1210                             if (funcdecl.isStatic())
1211                             {
1212                                 // The monitor is in the ClassInfo
1213                                 vsync = new DotIdExp(funcdecl.loc, symbolToExp(cd, funcdecl.loc, sc2, false), Id.classinfo);
1214                             }
1215                             else
1216                             {
1217                                 // 'this' is the monitor
1218                                 vsync = new VarExp(funcdecl.loc, funcdecl.vthis);
1219                                 if (funcdecl.hasDualContext())
1220                                 {
1221                                     vsync = new PtrExp(funcdecl.loc, vsync);
1222                                     vsync = new IndexExp(funcdecl.loc, vsync, IntegerExp.literal!0);
1223                                 }
1224                             }
1225                             sbody = new PeelStatement(sbody); // don't redo semantic()
1226                             sbody = new SynchronizedStatement(funcdecl.loc, vsync, sbody);
1227                             sbody = sbody.statementSemantic(sc2);
1228                         }
1229                     }
1230                     else
1231                     {
1232                         funcdecl.error("synchronized function `%s` must be a member of a class", funcdecl.toChars());
1233                     }
1234                 }
1235
1236                 // If declaration has no body, don't set sbody to prevent incorrect codegen.
1237                 if (funcdecl.fbody || funcdecl.allowsContractWithoutBody())
1238                     funcdecl.fbody = sbody;
1239             }
1240
1241             // Check for undefined labels
1242             if (funcdecl.labtab)
1243                 foreach (keyValue; funcdecl.labtab.tab.asRange)
1244                 {
1245                     //printf("  KV: %s = %s\n", keyValue.key.toChars(), keyValue.value.toChars());
1246                     LabelDsymbol label = cast(LabelDsymbol)keyValue.value;
1247                     if (!label.statement && (!label.deleted || label.iasm))
1248                     {
1249                         funcdecl.error(label.loc, "label `%s` is undefined", label.toChars());
1250                     }
1251                 }
1252
1253             // Fix up forward-referenced gotos
1254             if (funcdecl.gotos && !funcdecl.isCsymbol())
1255             {
1256                 for (size_t i = 0; i < funcdecl.gotos.length; ++i)
1257                 {
1258                     (*funcdecl.gotos)[i].checkLabel();
1259                 }
1260             }
1261
1262             if (funcdecl.isNaked() && (funcdecl.fensures || funcdecl.frequires))
1263                 funcdecl.error("naked assembly functions with contracts are not supported");
1264
1265             sc2.ctorflow.callSuper = CSX.none;
1266             sc2.pop();
1267         }
1268
1269         if (funcdecl.checkClosure())
1270         {
1271             // We should be setting errors here instead of relying on the global error count.
1272             //errors = true;
1273         }
1274
1275         /* If function survived being marked as impure, then it is pure
1276          */
1277         if (funcdecl.purityInprocess)
1278         {
1279             funcdecl.purityInprocess = false;
1280             if (funcdecl.type == f)
1281                 f = cast(TypeFunction)f.copy();
1282             f.purity = PURE.fwdref;
1283         }
1284
1285         if (funcdecl.safetyInprocess)
1286         {
1287             funcdecl.safetyInprocess = false;
1288             if (funcdecl.type == f)
1289                 f = cast(TypeFunction)f.copy();
1290             f.trust = TRUST.safe;
1291         }
1292
1293         if (funcdecl.nogcInprocess)
1294         {
1295             funcdecl.nogcInprocess = false;
1296             if (funcdecl.type == f)
1297                 f = cast(TypeFunction)f.copy();
1298             f.isnogc = true;
1299         }
1300
1301         finishScopeParamInference(funcdecl, f);
1302
1303         // reset deco to apply inference result to mangled name
1304         if (f != funcdecl.type)
1305             f.deco = null;
1306
1307         // Do semantic type AFTER pure/nothrow inference.
1308         if (!f.deco && funcdecl.ident != Id.xopEquals && funcdecl.ident != Id.xopCmp)
1309         {
1310             sc = sc.push();
1311             if (funcdecl.isCtorDeclaration()) // https://issues.dlang.org/show_bug.cgi?id=#15665
1312                 f.isctor = true;
1313             sc.stc = 0;
1314             sc.linkage = funcdecl._linkage; // https://issues.dlang.org/show_bug.cgi?id=8496
1315             funcdecl.type = f.typeSemantic(funcdecl.loc, sc);
1316             sc = sc.pop();
1317         }
1318
1319         // Check `extern(C++)` functions for invalid the return/parameter types
1320         if (funcdecl._linkage == LINK.cpp)
1321         {
1322             static bool isCppNonMappableType(Type type, Parameter param = null, Type origType = null)
1323             {
1324                 // Don't allow D `immutable` and `shared` types to be interfaced with C++
1325                 if (type.isImmutable() || type.isShared())
1326                     return true;
1327                 else if (Type cpptype = target.cpp.parameterType(type))
1328                     type = cpptype;
1329
1330                 if (origType is null)
1331                     origType = type;
1332
1333                 // Permit types that are handled by toCppMangle. This list should be kept in sync with
1334                 // each visit method in dmd.cppmangle and dmd.cppmanglewin.
1335                 switch (type.ty)
1336                 {
1337                     case Tnull:
1338                     case Tnoreturn:
1339                     case Tvector:
1340                     case Tpointer:
1341                     case Treference:
1342                     case Tfunction:
1343                     case Tstruct:
1344                     case Tenum:
1345                     case Tclass:
1346                     case Tident:
1347                     case Tinstance:
1348                         break;
1349
1350                     case Tsarray:
1351                         if (!origType.isTypePointer())
1352                             return true;
1353                         break;
1354
1355                     default:
1356                         if (!type.isTypeBasic())
1357                             return true;
1358                         break;
1359                 }
1360
1361                 // Descend to the enclosing type
1362                 if (auto tnext = type.nextOf())
1363                     return isCppNonMappableType(tnext, param, origType);
1364
1365                 return false;
1366             }
1367             if (isCppNonMappableType(f.next.toBasetype()))
1368             {
1369                 funcdecl.error("cannot return type `%s` because its linkage is `extern(C++)`", f.next.toChars());
1370                 funcdecl.errors = true;
1371             }
1372             foreach (i, param; f.parameterList)
1373             {
1374                 if (isCppNonMappableType(param.type.toBasetype(), param))
1375                 {
1376                     funcdecl.error("cannot have parameter of type `%s` because its linkage is `extern(C++)`", param.type.toChars());
1377                     if (param.type.toBasetype().isTypeSArray())
1378                         errorSupplemental(funcdecl.loc, "perhaps use a `%s*` type instead",
1379                                           param.type.nextOf().mutableOf().unSharedOf().toChars());
1380                     funcdecl.errors = true;
1381                 }
1382             }
1383         }
1384
1385         // Do live analysis
1386         if (global.params.useDIP1021 && funcdecl.fbody && funcdecl.type.ty != Terror &&
1387             funcdecl.type.isTypeFunction().islive)
1388         {
1389             oblive(funcdecl);
1390         }
1391
1392         /* If this function had instantiated with gagging, error reproduction will be
1393          * done by TemplateInstance::semantic.
1394          * Otherwise, error gagging should be temporarily ungagged by functionSemantic3.
1395          */
1396         funcdecl.semanticRun = PASS.semantic3done;
1397         if ((global.errors != oldErrors) || (funcdecl.fbody && funcdecl.fbody.isErrorStatement()))
1398             funcdecl.hasSemantic3Errors = true;
1399         else
1400             funcdecl.hasSemantic3Errors = false;
1401         if (funcdecl.type.ty == Terror)
1402             funcdecl.errors = true;
1403         //printf("-FuncDeclaration::semantic3('%s.%s', sc = %p, loc = %s)\n", funcdecl.parent.toChars(), funcdecl.toChars(), sc, funcdecl.loc.toChars());
1404         //fflush(stdout);
1405     }
1406
1407     override void visit(CtorDeclaration ctor)
1408     {
1409         //printf("CtorDeclaration()\n%s\n", ctor.fbody.toChars());
1410         if (ctor.semanticRun >= PASS.semantic3)
1411             return;
1412
1413         /* If any of the fields of the aggregate have a destructor, add
1414          *   scope (failure) { this.fieldDtor(); }
1415          * as the first statement of the constructor (unless the constructor
1416          * doesn't define a body - @disable, extern)
1417          *.It is not necessary to add it after
1418          * each initialization of a field, because destruction of .init constructed
1419          * structs should be benign.
1420          * https://issues.dlang.org/show_bug.cgi?id=14246
1421          */
1422         AggregateDeclaration ad = ctor.isMemberDecl();
1423         if (!ctor.fbody || !ad || !ad.fieldDtor || !global.params.dtorFields || global.params.betterC || ctor.type.toTypeFunction.isnothrow)
1424             return visit(cast(FuncDeclaration)ctor);
1425
1426         /* Generate:
1427          *   this.fieldDtor()
1428          */
1429         Expression e = new ThisExp(ctor.loc);
1430         e.type = ad.type.mutableOf();
1431         e = new DotVarExp(ctor.loc, e, ad.fieldDtor, false);
1432         auto ce = new CallExp(ctor.loc, e);
1433         auto sexp = new ExpStatement(ctor.loc, ce);
1434         auto ss = new ScopeStatement(ctor.loc, sexp, ctor.loc);
1435
1436         // @@@DEPRECATED_2.106@@@
1437         // Allow negligible attribute violations to allow for a smooth
1438         // transition. Remove this after the usual deprecation period
1439         // after 2.106.
1440         if (global.params.dtorFields == FeatureState.default_)
1441         {
1442             auto ctf = cast(TypeFunction) ctor.type;
1443             auto dtf = cast(TypeFunction) ad.fieldDtor.type;
1444
1445             const ngErr = ctf.isnogc && !dtf.isnogc;
1446             const puErr = ctf.purity && !dtf.purity;
1447             const saErr = ctf.trust == TRUST.safe && dtf.trust <= TRUST.system;
1448
1449             if (ngErr || puErr || saErr)
1450             {
1451                 // storage_class is apparently not set for dtor & ctor
1452                 OutBuffer ob;
1453                 stcToBuffer(&ob,
1454                     (ngErr ? STC.nogc : 0) |
1455                     (puErr ? STC.pure_ : 0) |
1456                     (saErr ? STC.system : 0)
1457                 );
1458                 ctor.loc.deprecation("`%s` has stricter attributes than its destructor (`%s`)", ctor.toPrettyChars(), ob.peekChars());
1459                 ctor.loc.deprecationSupplemental("The destructor will be called if an exception is thrown");
1460                 ctor.loc.deprecationSupplemental("Either make the constructor `nothrow` or adjust the field destructors");
1461
1462                 ce.ignoreAttributes = true;
1463             }
1464         }
1465
1466         version (all)
1467         {
1468             /* Generate:
1469              *   try { ctor.fbody; }
1470              *   catch (Exception __o)
1471              *   { this.fieldDtor(); throw __o; }
1472              * This differs from the alternate scope(failure) version in that an Exception
1473              * is caught rather than a Throwable. This enables the optimization whereby
1474              * the try-catch can be removed if ctor.fbody is nothrow. (nothrow only
1475              * applies to Exception.)
1476              */
1477             Identifier id = Identifier.generateId("__o");
1478             auto ts = new ThrowStatement(ctor.loc, new IdentifierExp(ctor.loc, id));
1479             auto handler = new CompoundStatement(ctor.loc, ss, ts);
1480
1481             auto catches = new Catches();
1482             auto ctch = new Catch(ctor.loc, getException(), id, handler);
1483             catches.push(ctch);
1484
1485             ctor.fbody = new TryCatchStatement(ctor.loc, ctor.fbody, catches);
1486         }
1487         else
1488         {
1489             /* Generate:
1490              *   scope (failure) { this.fieldDtor(); }
1491              * Hopefully we can use this version someday when scope(failure) catches
1492              * Exception instead of Throwable.
1493              */
1494             auto s = new ScopeGuardStatement(ctor.loc, TOK.onScopeFailure, ss);
1495             ctor.fbody = new CompoundStatement(ctor.loc, s, ctor.fbody);
1496         }
1497         visit(cast(FuncDeclaration)ctor);
1498     }
1499
1500
1501     override void visit(Nspace ns)
1502     {
1503         if (ns.semanticRun >= PASS.semantic3)
1504             return;
1505         ns.semanticRun = PASS.semantic3;
1506         static if (LOG)
1507         {
1508             printf("Nspace::semantic3('%s')\n", ns.toChars());
1509         }
1510         if (!ns.members)
1511             return;
1512
1513         sc = sc.push(ns);
1514         sc.linkage = LINK.cpp;
1515         foreach (s; *ns.members)
1516         {
1517             s.semantic3(sc);
1518         }
1519         sc.pop();
1520     }
1521
1522     override void visit(AttribDeclaration ad)
1523     {
1524         Dsymbols* d = ad.include(sc);
1525         if (!d)
1526             return;
1527
1528         Scope* sc2 = ad.newScope(sc);
1529         for (size_t i = 0; i < d.length; i++)
1530         {
1531             Dsymbol s = (*d)[i];
1532             s.semantic3(sc2);
1533         }
1534         if (sc2 != sc)
1535             sc2.pop();
1536     }
1537
1538     override void visit(AggregateDeclaration ad)
1539     {
1540         //printf("AggregateDeclaration::semantic3(sc=%p, %s) type = %s, errors = %d\n", sc, toChars(), type.toChars(), errors);
1541         if (!ad.members)
1542             return;
1543
1544         StructDeclaration sd = ad.isStructDeclaration();
1545         if (!sc) // from runDeferredSemantic3 for TypeInfo generation
1546         {
1547             assert(sd);
1548             sd.semanticTypeInfoMembers();
1549             return;
1550         }
1551
1552         auto sc2 = ad.newScope(sc);
1553
1554         for (size_t i = 0; i < ad.members.length; i++)
1555         {
1556             Dsymbol s = (*ad.members)[i];
1557             s.semantic3(sc2);
1558         }
1559
1560         sc2.pop();
1561
1562         // Instantiate RTInfo!S to provide a pointer bitmap for the GC
1563         // Don't do it in -betterC or on unused deprecated / error types
1564         if (!ad.getRTInfo && global.params.useTypeInfo && Type.rtinfo &&
1565             (!ad.isDeprecated() || global.params.useDeprecated != DiagnosticReporting.error) &&
1566             (ad.type && ad.type.ty != Terror))
1567         {
1568             // Evaluate: RTinfo!type
1569             auto tiargs = new Objects();
1570             tiargs.push(ad.type);
1571             auto ti = new TemplateInstance(ad.loc, Type.rtinfo, tiargs);
1572
1573             Scope* sc3 = ti.tempdecl._scope.startCTFE();
1574             sc3.tinst = sc.tinst;
1575             sc3.minst = sc.minst;
1576             if (ad.isDeprecated())
1577                 sc3.stc |= STC.deprecated_;
1578
1579             ti.dsymbolSemantic(sc3);
1580             ti.semantic2(sc3);
1581             ti.semantic3(sc3);
1582             auto e = symbolToExp(ti.toAlias(), Loc.initial, sc3, false);
1583
1584             sc3.endCTFE();
1585
1586             e = e.ctfeInterpret();
1587             ad.getRTInfo = e;
1588         }
1589         if (sd)
1590             sd.semanticTypeInfoMembers();
1591         ad.semanticRun = PASS.semantic3done;
1592     }
1593 }
1594
1595 private struct FuncDeclSem3
1596 {
1597     // The FuncDeclaration subject to Semantic analysis
1598     FuncDeclaration funcdecl;
1599
1600     // Scope of analysis
1601     Scope* sc;
1602     this(FuncDeclaration fd,Scope* s) scope
1603     {
1604         funcdecl = fd;
1605         sc = s;
1606     }
1607
1608     /* Checks that the overriden functions (if any) have in contracts if
1609      * funcdecl has an in contract.
1610      */
1611     void checkInContractOverrides()
1612     {
1613         if (funcdecl.frequires)
1614         {
1615             for (size_t i = 0; i < funcdecl.foverrides.length; i++)
1616             {
1617                 FuncDeclaration fdv = funcdecl.foverrides[i];
1618                 if (fdv.fbody && !fdv.frequires)
1619                 {
1620                     funcdecl.error("cannot have an in contract when overridden function `%s` does not have an in contract", fdv.toPrettyChars());
1621                     break;
1622                 }
1623             }
1624         }
1625     }
1626 }
1627
1628 extern (C++) void semanticTypeInfoMembers(StructDeclaration sd)
1629 {
1630     if (sd.xeq &&
1631         sd.xeq._scope &&
1632         sd.xeq.semanticRun < PASS.semantic3done)
1633     {
1634         uint errors = global.startGagging();
1635         sd.xeq.semantic3(sd.xeq._scope);
1636         if (global.endGagging(errors))
1637             sd.xeq = sd.xerreq;
1638     }
1639
1640     if (sd.xcmp &&
1641         sd.xcmp._scope &&
1642         sd.xcmp.semanticRun < PASS.semantic3done)
1643     {
1644         uint errors = global.startGagging();
1645         sd.xcmp.semantic3(sd.xcmp._scope);
1646         if (global.endGagging(errors))
1647             sd.xcmp = sd.xerrcmp;
1648     }
1649
1650     FuncDeclaration ftostr = search_toString(sd);
1651     if (ftostr &&
1652         ftostr._scope &&
1653         ftostr.semanticRun < PASS.semantic3done)
1654     {
1655         ftostr.semantic3(ftostr._scope);
1656     }
1657
1658     if (sd.xhash &&
1659         sd.xhash._scope &&
1660         sd.xhash.semanticRun < PASS.semantic3done)
1661     {
1662         sd.xhash.semantic3(sd.xhash._scope);
1663     }
1664
1665     if (sd.postblit &&
1666         sd.postblit._scope &&
1667         sd.postblit.semanticRun < PASS.semantic3done)
1668     {
1669         sd.postblit.semantic3(sd.postblit._scope);
1670     }
1671
1672     if (sd.dtor &&
1673         sd.dtor._scope &&
1674         sd.dtor.semanticRun < PASS.semantic3done)
1675     {
1676         sd.dtor.semantic3(sd.dtor._scope);
1677     }
1678 }