gcc/d/dmd/semantic3.d

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