gcc/d/dmd/declaration.d

   1 /**
   2  * Miscellaneous declarations, including typedef, alias, variable declarations including the
   3  * implicit this declaration, type tuples, ClassInfo, ModuleInfo and various TypeInfos.
   4  *
   5  * Copyright:   Copyright (C) 1999-2022 by The D Language Foundation, All Rights Reserved
   6  * Authors:     $(LINK2 https://www.digitalmars.com, Walter Bright)
   7  * License:     $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
   8  * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/declaration.d, _declaration.d)
   9  * Documentation:  https://dlang.org/phobos/dmd_declaration.html
  10  * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/declaration.d
  11  */
  12
  13 module dmd.declaration;
  14
  15 import core.stdc.stdio;
  16 import dmd.aggregate;
  17 import dmd.arraytypes;
  18 import dmd.astenums;
  19 import dmd.attrib;
  20 import dmd.ctorflow;
  21 import dmd.dclass;
  22 import dmd.delegatize;
  23 import dmd.dscope;
  24 import dmd.dstruct;
  25 import dmd.dsymbol;
  26 import dmd.dsymbolsem;
  27 import dmd.dtemplate;
  28 import dmd.errors;
  29 import dmd.expression;
  30 import dmd.func;
  31 import dmd.globals;
  32 import dmd.gluelayer;
  33 import dmd.id;
  34 import dmd.identifier;
  35 import dmd.init;
  36 import dmd.initsem;
  37 import dmd.intrange;
  38 import dmd.mtype;
  39 import dmd.common.outbuffer;
  40 import dmd.root.rootobject;
  41 import dmd.target;
  42 import dmd.tokens;
  43 import dmd.typesem;
  44 import dmd.visitor;
  45
  46 /************************************
  47  * Check to see the aggregate type is nested and its context pointer is
  48  * accessible from the current scope.
  49  * Returns true if error occurs.
  50  */
  51 bool checkFrameAccess(Loc loc, Scope* sc, AggregateDeclaration ad, size_t iStart = 0)
  52 {
  53     Dsymbol sparent = ad.toParentLocal();
  54     Dsymbol sparent2 = ad.toParent2();
  55     Dsymbol s = sc.func;
  56     if (ad.isNested() && s)
  57     {
  58         //printf("ad = %p %s [%s], parent:%p\n", ad, ad.toChars(), ad.loc.toChars(), ad.parent);
  59         //printf("sparent = %p %s [%s], parent: %s\n", sparent, sparent.toChars(), sparent.loc.toChars(), sparent.parent,toChars());
  60         //printf("sparent2 = %p %s [%s], parent: %s\n", sparent2, sparent2.toChars(), sparent2.loc.toChars(), sparent2.parent,toChars());
  61         if (!ensureStaticLinkTo(s, sparent) || sparent != sparent2 && !ensureStaticLinkTo(s, sparent2))
  62         {
  63             error(loc, "cannot access frame pointer of `%s`", ad.toPrettyChars());
  64             return true;
  65         }
  66     }
  67
  68     bool result = false;
  69     for (size_t i = iStart; i < ad.fields.dim; i++)
  70     {
  71         VarDeclaration vd = ad.fields[i];
  72         Type tb = vd.type.baseElemOf();
  73         if (tb.ty == Tstruct)
  74         {
  75             result |= checkFrameAccess(loc, sc, (cast(TypeStruct)tb).sym);
  76         }
  77     }
  78     return result;
  79 }
  80
  81 /***********************************************
  82  * Mark variable v as modified if it is inside a constructor that var
  83  * is a field in.
  84  */
  85 bool modifyFieldVar(Loc loc, Scope* sc, VarDeclaration var, Expression e1)
  86 {
  87     //printf("modifyFieldVar(var = %s)\n", var.toChars());
  88     Dsymbol s = sc.func;
  89     while (1)
  90     {
  91         FuncDeclaration fd = null;
  92         if (s)
  93             fd = s.isFuncDeclaration();
  94         if (fd &&
  95             ((fd.isCtorDeclaration() && var.isField()) ||
  96              (fd.isStaticCtorDeclaration() && !var.isField())) &&
  97             fd.toParentDecl() == var.toParent2() &&
  98             (!e1 || e1.op == EXP.this_))
  99         {
 100             bool result = true;
 101
 102             var.ctorinit = true;
 103             //printf("setting ctorinit\n");
 104
 105             if (var.isField() && sc.ctorflow.fieldinit.length && !sc.intypeof)
 106             {
 107                 assert(e1);
 108                 auto mustInit = ((var.storage_class & STC.nodefaultctor) != 0 ||
 109                                  var.type.needsNested());
 110
 111                 const dim = sc.ctorflow.fieldinit.length;
 112                 auto ad = fd.isMemberDecl();
 113                 assert(ad);
 114                 size_t i;
 115                 for (i = 0; i < dim; i++) // same as findFieldIndexByName in ctfeexp.c ?
 116                 {
 117                     if (ad.fields[i] == var)
 118                         break;
 119                 }
 120                 assert(i < dim);
 121                 auto fieldInit = &sc.ctorflow.fieldinit[i];
 122                 const fi = fieldInit.csx;
 123
 124                 if (fi & CSX.this_ctor)
 125                 {
 126                     if (var.type.isMutable() && e1.type.isMutable())
 127                         result = false;
 128                     else
 129                     {
 130                         const(char)* modStr = !var.type.isMutable() ? MODtoChars(var.type.mod) : MODtoChars(e1.type.mod);
 131                         .error(loc, "%s field `%s` initialized multiple times", modStr, var.toChars());
 132                         .errorSupplemental(fieldInit.loc, "Previous initialization is here.");
 133                     }
 134                 }
 135                 else if (sc.inLoop || (fi & CSX.label))
 136                 {
 137                     if (!mustInit && var.type.isMutable() && e1.type.isMutable())
 138                         result = false;
 139                     else
 140                     {
 141                         const(char)* modStr = !var.type.isMutable() ? MODtoChars(var.type.mod) : MODtoChars(e1.type.mod);
 142                         .error(loc, "%s field `%s` initialization is not allowed in loops or after labels", modStr, var.toChars());
 143                     }
 144                 }
 145
 146                 fieldInit.csx |= CSX.this_ctor;
 147                 fieldInit.loc = e1.loc;
 148                 if (var.overlapped) // https://issues.dlang.org/show_bug.cgi?id=15258
 149                 {
 150                     foreach (j, v; ad.fields)
 151                     {
 152                         if (v is var || !var.isOverlappedWith(v))
 153                             continue;
 154                         v.ctorinit = true;
 155                         sc.ctorflow.fieldinit[j].csx = CSX.this_ctor;
 156                     }
 157                 }
 158             }
 159             else if (fd != sc.func)
 160             {
 161                 if (var.type.isMutable())
 162                     result = false;
 163                 else if (sc.func.fes)
 164                 {
 165                     const(char)* p = var.isField() ? "field" : var.kind();
 166                     .error(loc, "%s %s `%s` initialization is not allowed in foreach loop",
 167                         MODtoChars(var.type.mod), p, var.toChars());
 168                 }
 169                 else
 170                 {
 171                     const(char)* p = var.isField() ? "field" : var.kind();
 172                     .error(loc, "%s %s `%s` initialization is not allowed in nested function `%s`",
 173                         MODtoChars(var.type.mod), p, var.toChars(), sc.func.toChars());
 174                 }
 175             }
 176             else if (fd.isStaticCtorDeclaration() && !fd.isSharedStaticCtorDeclaration() &&
 177                      var.type.isImmutable())
 178             {
 179                 .error(loc, "%s %s `%s` initialization is not allowed in `static this`",
 180                     MODtoChars(var.type.mod), var.kind(), var.toChars());
 181                 errorSupplemental(loc, "Use `shared static this` instead.");
 182             }
 183             return result;
 184         }
 185         else
 186         {
 187             if (s)
 188             {
 189                 s = s.toParentP(var.toParent2());
 190                 continue;
 191             }
 192         }
 193         break;
 194     }
 195     return false;
 196 }
 197
 198 /******************************************
 199  */
 200 extern (C++) void ObjectNotFound(Identifier id)
 201 {
 202     error(Loc.initial, "`%s` not found. object.d may be incorrectly installed or corrupt.", id.toChars());
 203     fatal();
 204 }
 205
 206 /* Accumulator for successive matches.
 207  */
 208 struct MatchAccumulator
 209 {
 210     int count;              // number of matches found so far
 211     MATCH last = MATCH.nomatch; // match level of lastf
 212     FuncDeclaration lastf;  // last matching function we found
 213     FuncDeclaration nextf;  // if ambiguous match, this is the "other" function
 214 }
 215
 216 /***********************************************************
 217  */
 218 extern (C++) abstract class Declaration : Dsymbol
 219 {
 220     Type type;
 221     Type originalType;  // before semantic analysis
 222     StorageClass storage_class = STC.undefined_;
 223     Visibility visibility;
 224     LINK linkage = LINK.default_;
 225     short inuse;          // used to detect cycles
 226
 227     ubyte adFlags;         // control re-assignment of AliasDeclaration (put here for packing reasons)
 228       enum wasRead    = 1; // set if AliasDeclaration was read
 229       enum ignoreRead = 2; // ignore any reads of AliasDeclaration
 230
 231     Symbol* isym;           // import version of csym
 232
 233     // overridden symbol with pragma(mangle, "...")
 234     const(char)[] mangleOverride;
 235
 236     final extern (D) this(Identifier ident)
 237     {
 238         super(ident);
 239         visibility = Visibility(Visibility.Kind.undefined);
 240     }
 241
 242     final extern (D) this(const ref Loc loc, Identifier ident)
 243     {
 244         super(loc, ident);
 245         visibility = Visibility(Visibility.Kind.undefined);
 246     }
 247
 248     override const(char)* kind() const
 249     {
 250         return "declaration";
 251     }
 252
 253     override final uinteger_t size(const ref Loc loc)
 254     {
 255         assert(type);
 256         const sz = type.size();
 257         if (sz == SIZE_INVALID)
 258             errors = true;
 259         return sz;
 260     }
 261
 262     /**
 263      * Issue an error if an attempt to call a disabled method is made
 264      *
 265      * If the declaration is disabled but inside a disabled function,
 266      * returns `true` but do not issue an error message.
 267      *
 268      * Params:
 269      *   loc = Location information of the call
 270      *   sc  = Scope in which the call occurs
 271      *   isAliasedDeclaration = if `true` searches overload set
 272      *
 273      * Returns:
 274      *   `true` if this `Declaration` is `@disable`d, `false` otherwise.
 275      */
 276     extern (D) final bool checkDisabled(Loc loc, Scope* sc, bool isAliasedDeclaration = false)
 277     {
 278         if (!(storage_class & STC.disable))
 279             return false;
 280
 281         if (sc.func && sc.func.storage_class & STC.disable)
 282             return true;
 283
 284         if (auto p = toParent())
 285         {
 286             if (auto postblit = isPostBlitDeclaration())
 287             {
 288                 /* https://issues.dlang.org/show_bug.cgi?id=21885
 289                  *
 290                  * If the generated postblit is disabled, it
 291                  * means that one of the fields has a disabled
 292                  * postblit. Print the first field that has
 293                  * a disabled postblit.
 294                  */
 295                 if (postblit.isGenerated())
 296                 {
 297                     auto sd = p.isStructDeclaration();
 298                     assert(sd);
 299                     for (size_t i = 0; i < sd.fields.dim; i++)
 300                     {
 301                         auto structField = sd.fields[i];
 302                         if (structField.overlapped)
 303                             continue;
 304                         Type tv = structField.type.baseElemOf();
 305                         if (tv.ty != Tstruct)
 306                             continue;
 307                         auto sdv = (cast(TypeStruct)tv).sym;
 308                         if (!sdv.postblit)
 309                             continue;
 310                         if (sdv.postblit.isDisabled())
 311                         {
 312                             p.error(loc, "is not copyable because field `%s` is not copyable", structField.toChars());
 313                             return true;
 314                         }
 315                     }
 316                 }
 317                 p.error(loc, "is not copyable because it has a disabled postblit");
 318                 return true;
 319             }
 320         }
 321
 322         // if the function is @disabled, maybe there
 323         // is an overload in the overload set that isn't
 324         if (isAliasedDeclaration)
 325         {
 326             FuncDeclaration fd = isFuncDeclaration();
 327             if (fd)
 328             {
 329                 for (FuncDeclaration ovl = fd; ovl; ovl = cast(FuncDeclaration)ovl.overnext)
 330                     if (!(ovl.storage_class & STC.disable))
 331                         return false;
 332             }
 333         }
 334
 335         if (auto ctor = isCtorDeclaration())
 336         {
 337             if (ctor.isCpCtor && ctor.isGenerated())
 338             {
 339                 .error(loc, "Generating an `inout` copy constructor for `struct %s` failed, therefore instances of it are uncopyable", parent.toPrettyChars());
 340                 return true;
 341             }
 342         }
 343         error(loc, "cannot be used because it is annotated with `@disable`");
 344         return true;
 345     }
 346
 347     /*************************************
 348      * Check to see if declaration can be modified in this context (sc).
 349      * Issue error if not.
 350      * Params:
 351      *  loc  = location for error messages
 352      *  e1   = `null` or `this` expression when this declaration is a field
 353      *  sc   = context
 354      *  flag = if the first bit is set it means do not issue error message for
 355      *         invalid modification; if the second bit is set, it means that
 356                this declaration is a field and a subfield of it is modified.
 357      * Returns:
 358      *  Modifiable.yes or Modifiable.initialization
 359      */
 360     extern (D) final Modifiable checkModify(Loc loc, Scope* sc, Expression e1, ModifyFlags flag)
 361     {
 362         VarDeclaration v = isVarDeclaration();
 363         if (v && v.canassign)
 364             return Modifiable.initialization;
 365
 366         if (isParameter() || isResult())
 367         {
 368             for (Scope* scx = sc; scx; scx = scx.enclosing)
 369             {
 370                 if (scx.func == parent && (scx.flags & SCOPE.contract))
 371                 {
 372                     const(char)* s = isParameter() && parent.ident != Id.ensure ? "parameter" : "result";
 373                     if (!(flag & ModifyFlags.noError))
 374                         error(loc, "cannot modify %s `%s` in contract", s, toChars());
 375                     return Modifiable.initialization; // do not report type related errors
 376                 }
 377             }
 378         }
 379
 380         if (e1 && e1.op == EXP.this_ && isField())
 381         {
 382             VarDeclaration vthis = (cast(ThisExp)e1).var;
 383             for (Scope* scx = sc; scx; scx = scx.enclosing)
 384             {
 385                 if (scx.func == vthis.parent && (scx.flags & SCOPE.contract))
 386                 {
 387                     if (!(flag & ModifyFlags.noError))
 388                         error(loc, "cannot modify parameter `this` in contract");
 389                     return Modifiable.initialization; // do not report type related errors
 390                 }
 391             }
 392         }
 393
 394         if (v && (v.isCtorinit() || isField()))
 395         {
 396             // It's only modifiable if inside the right constructor
 397             if ((storage_class & (STC.foreach_ | STC.ref_)) == (STC.foreach_ | STC.ref_))
 398                 return Modifiable.initialization;
 399             if (flag & ModifyFlags.fieldAssign)
 400                 return Modifiable.yes;
 401             return modifyFieldVar(loc, sc, v, e1) ? Modifiable.initialization : Modifiable.yes;
 402         }
 403         return Modifiable.yes;
 404     }
 405
 406     override final Dsymbol search(const ref Loc loc, Identifier ident, int flags = SearchLocalsOnly)
 407     {
 408         Dsymbol s = Dsymbol.search(loc, ident, flags);
 409         if (!s && type)
 410         {
 411             s = type.toDsymbol(_scope);
 412             if (s)
 413                 s = s.search(loc, ident, flags);
 414         }
 415         return s;
 416     }
 417
 418     final bool isStatic() const pure nothrow @nogc @safe
 419     {
 420         return (storage_class & STC.static_) != 0;
 421     }
 422
 423     bool isDelete()
 424     {
 425         return false;
 426     }
 427
 428     bool isDataseg()
 429     {
 430         return false;
 431     }
 432
 433     bool isThreadlocal()
 434     {
 435         return false;
 436     }
 437
 438     bool isCodeseg() const pure nothrow @nogc @safe
 439     {
 440         return false;
 441     }
 442
 443     final bool isFinal() const pure nothrow @nogc @safe
 444     {
 445         return (storage_class & STC.final_) != 0;
 446     }
 447
 448     bool isAbstract()
 449     {
 450         return (storage_class & STC.abstract_) != 0;
 451     }
 452
 453     final bool isConst() const pure nothrow @nogc @safe
 454     {
 455         return (storage_class & STC.const_) != 0;
 456     }
 457
 458     final bool isImmutable() const pure nothrow @nogc @safe
 459     {
 460         return (storage_class & STC.immutable_) != 0;
 461     }
 462
 463     final bool isWild() const pure nothrow @nogc @safe
 464     {
 465         return (storage_class & STC.wild) != 0;
 466     }
 467
 468     final bool isAuto() const pure nothrow @nogc @safe
 469     {
 470         return (storage_class & STC.auto_) != 0;
 471     }
 472
 473     final bool isScope() const pure nothrow @nogc @safe
 474     {
 475         return (storage_class & STC.scope_) != 0;
 476     }
 477
 478     final bool isSynchronized() const pure nothrow @nogc @safe
 479     {
 480         return (storage_class & STC.synchronized_) != 0;
 481     }
 482
 483     final bool isParameter() const pure nothrow @nogc @safe
 484     {
 485         return (storage_class & STC.parameter) != 0;
 486     }
 487
 488     override final bool isDeprecated() const pure nothrow @nogc @safe
 489     {
 490         return (storage_class & STC.deprecated_) != 0;
 491     }
 492
 493     final bool isDisabled() const pure nothrow @nogc @safe
 494     {
 495         return (storage_class & STC.disable) != 0;
 496     }
 497
 498     final bool isOverride() const pure nothrow @nogc @safe
 499     {
 500         return (storage_class & STC.override_) != 0;
 501     }
 502
 503     final bool isResult() const pure nothrow @nogc @safe
 504     {
 505         return (storage_class & STC.result) != 0;
 506     }
 507
 508     final bool isField() const pure nothrow @nogc @safe
 509     {
 510         return (storage_class & STC.field) != 0;
 511     }
 512
 513     final bool isIn() const pure nothrow @nogc @safe
 514     {
 515         return (storage_class & STC.in_) != 0;
 516     }
 517
 518     final bool isOut() const pure nothrow @nogc @safe
 519     {
 520         return (storage_class & STC.out_) != 0;
 521     }
 522
 523     final bool isRef() const pure nothrow @nogc @safe
 524     {
 525         return (storage_class & STC.ref_) != 0;
 526     }
 527
 528     /// Returns: Whether the variable is a reference, annotated with `out` or `ref`
 529     final bool isReference() const pure nothrow @nogc @safe
 530     {
 531         return (storage_class & (STC.ref_ | STC.out_)) != 0;
 532     }
 533
 534     final bool isFuture() const pure nothrow @nogc @safe
 535     {
 536         return (storage_class & STC.future) != 0;
 537     }
 538
 539     override final Visibility visible() pure nothrow @nogc @safe
 540     {
 541         return visibility;
 542     }
 543
 544     override final inout(Declaration) isDeclaration() inout pure nothrow @nogc @safe
 545     {
 546         return this;
 547     }
 548
 549     override void accept(Visitor v)
 550     {
 551         v.visit(this);
 552     }
 553 }
 554
 555 /***********************************************************
 556  */
 557 extern (C++) final class TupleDeclaration : Declaration
 558 {
 559     Objects* objects;
 560     bool isexp;             // true: expression tuple
 561     TypeTuple tupletype;    // !=null if this is a type tuple
 562
 563     extern (D) this(const ref Loc loc, Identifier ident, Objects* objects)
 564     {
 565         super(loc, ident);
 566         this.objects = objects;
 567     }
 568
 569     override TupleDeclaration syntaxCopy(Dsymbol s)
 570     {
 571         assert(0);
 572     }
 573
 574     override const(char)* kind() const
 575     {
 576         return "tuple";
 577     }
 578
 579     override Type getType()
 580     {
 581         /* If this tuple represents a type, return that type
 582          */
 583
 584         //printf("TupleDeclaration::getType() %s\n", toChars());
 585         if (isexp)
 586             return null;
 587         if (!tupletype)
 588         {
 589             /* It's only a type tuple if all the Object's are types
 590              */
 591             for (size_t i = 0; i < objects.dim; i++)
 592             {
 593                 RootObject o = (*objects)[i];
 594                 if (o.dyncast() != DYNCAST.type)
 595                 {
 596                     //printf("\tnot[%d], %p, %d\n", i, o, o.dyncast());
 597                     return null;
 598                 }
 599             }
 600
 601             /* We know it's a type tuple, so build the TypeTuple
 602              */
 603             Types* types = cast(Types*)objects;
 604             auto args = new Parameters(objects.dim);
 605             OutBuffer buf;
 606             int hasdeco = 1;
 607             for (size_t i = 0; i < types.dim; i++)
 608             {
 609                 Type t = (*types)[i];
 610                 //printf("type = %s\n", t.toChars());
 611                 version (none)
 612                 {
 613                     buf.printf("_%s_%d", ident.toChars(), i);
 614                     const len = buf.offset;
 615                     const name = buf.extractSlice().ptr;
 616                     auto id = Identifier.idPool(name, len);
 617                     auto arg = new Parameter(STC.in_, t, id, null);
 618                 }
 619                 else
 620                 {
 621                     auto arg = new Parameter(0, t, null, null, null);
 622                 }
 623                 (*args)[i] = arg;
 624                 if (!t.deco)
 625                     hasdeco = 0;
 626             }
 627
 628             tupletype = new TypeTuple(args);
 629             if (hasdeco)
 630                 return tupletype.typeSemantic(Loc.initial, null);
 631         }
 632         return tupletype;
 633     }
 634
 635     override Dsymbol toAlias2()
 636     {
 637         //printf("TupleDeclaration::toAlias2() '%s' objects = %s\n", toChars(), objects.toChars());
 638         for (size_t i = 0; i < objects.dim; i++)
 639         {
 640             RootObject o = (*objects)[i];
 641             if (Dsymbol s = isDsymbol(o))
 642             {
 643                 s = s.toAlias2();
 644                 (*objects)[i] = s;
 645             }
 646         }
 647         return this;
 648     }
 649
 650     override bool needThis()
 651     {
 652         //printf("TupleDeclaration::needThis(%s)\n", toChars());
 653         for (size_t i = 0; i < objects.dim; i++)
 654         {
 655             RootObject o = (*objects)[i];
 656             if (o.dyncast() == DYNCAST.expression)
 657             {
 658                 Expression e = cast(Expression)o;
 659                 if (e.op == EXP.dSymbol)
 660                 {
 661                     DsymbolExp ve = cast(DsymbolExp)e;
 662                     Declaration d = ve.s.isDeclaration();
 663                     if (d && d.needThis())
 664                     {
 665                         return true;
 666                     }
 667                 }
 668             }
 669         }
 670         return false;
 671     }
 672
 673     override inout(TupleDeclaration) isTupleDeclaration() inout
 674     {
 675         return this;
 676     }
 677
 678     override void accept(Visitor v)
 679     {
 680         v.visit(this);
 681     }
 682 }
 683
 684 /***********************************************************
 685  * https://dlang.org/spec/declaration.html#AliasDeclaration
 686  */
 687 extern (C++) final class AliasDeclaration : Declaration
 688 {
 689     Dsymbol aliassym;   // alias ident = aliassym;
 690
 691     Dsymbol overnext;   // next in overload list
 692     Dsymbol _import;    // !=null if unresolved internal alias for selective import
 693
 694     extern (D) this(const ref Loc loc, Identifier ident, Type type)
 695     {
 696         super(loc, ident);
 697         //printf("AliasDeclaration(id = '%s', type = %p)\n", id.toChars(), type);
 698         //printf("type = '%s'\n", type.toChars());
 699         this.type = type;
 700         assert(type);
 701     }
 702
 703     extern (D) this(const ref Loc loc, Identifier ident, Dsymbol s)
 704     {
 705         super(loc, ident);
 706         //printf("AliasDeclaration(id = '%s', s = %p)\n", id.toChars(), s);
 707         assert(s != this);
 708         this.aliassym = s;
 709         assert(s);
 710     }
 711
 712     static AliasDeclaration create(const ref Loc loc, Identifier id, Type type)
 713     {
 714         return new AliasDeclaration(loc, id, type);
 715     }
 716
 717     override AliasDeclaration syntaxCopy(Dsymbol s)
 718     {
 719         //printf("AliasDeclaration::syntaxCopy()\n");
 720         assert(!s);
 721         AliasDeclaration sa = type ? new AliasDeclaration(loc, ident, type.syntaxCopy()) : new AliasDeclaration(loc, ident, aliassym.syntaxCopy(null));
 722         sa.comment = comment;
 723         sa.storage_class = storage_class;
 724         return sa;
 725     }
 726
 727     override bool overloadInsert(Dsymbol s)
 728     {
 729         //printf("[%s] AliasDeclaration::overloadInsert('%s') s = %s %s @ [%s]\n",
 730         //       loc.toChars(), toChars(), s.kind(), s.toChars(), s.loc.toChars());
 731
 732         /** Aliases aren't overloadable themselves, but if their Aliasee is
 733          *  overloadable they are converted to an overloadable Alias (either
 734          *  FuncAliasDeclaration or OverDeclaration).
 735          *
 736          *  This is done by moving the Aliasee into such an overloadable alias
 737          *  which is then used to replace the existing Aliasee. The original
 738          *  Alias (_this_) remains a useless shell.
 739          *
 740          *  This is a horrible mess. It was probably done to avoid replacing
 741          *  existing AST nodes and references, but it needs a major
 742          *  simplification b/c it's too complex to maintain.
 743          *
 744          *  A simpler approach might be to merge any colliding symbols into a
 745          *  simple Overload class (an array) and then later have that resolve
 746          *  all collisions.
 747          */
 748         if (semanticRun >= PASS.semanticdone)
 749         {
 750             /* Semantic analysis is already finished, and the aliased entity
 751              * is not overloadable.
 752              */
 753             if (type)
 754                 return false;
 755
 756             /* When s is added in member scope by static if, mixin("code") or others,
 757              * aliassym is determined already. See the case in: test/compilable/test61.d
 758              */
 759             auto sa = aliassym.toAlias();
 760
 761             if (auto td = s.toAlias().isTemplateDeclaration())
 762                 s = td.funcroot ? td.funcroot : td;
 763
 764             if (auto fd = sa.isFuncDeclaration())
 765             {
 766                 auto fa = new FuncAliasDeclaration(ident, fd);
 767                 fa.visibility = visibility;
 768                 fa.parent = parent;
 769                 aliassym = fa;
 770                 return aliassym.overloadInsert(s);
 771             }
 772             if (auto td = sa.isTemplateDeclaration())
 773             {
 774                 auto od = new OverDeclaration(ident, td.funcroot ? td.funcroot : td);
 775                 od.visibility = visibility;
 776                 od.parent = parent;
 777                 aliassym = od;
 778                 return aliassym.overloadInsert(s);
 779             }
 780             if (auto od = sa.isOverDeclaration())
 781             {
 782                 if (sa.ident != ident || sa.parent != parent)
 783                 {
 784                     od = new OverDeclaration(ident, od);
 785                     od.visibility = visibility;
 786                     od.parent = parent;
 787                     aliassym = od;
 788                 }
 789                 return od.overloadInsert(s);
 790             }
 791             if (auto os = sa.isOverloadSet())
 792             {
 793                 if (sa.ident != ident || sa.parent != parent)
 794                 {
 795                     os = new OverloadSet(ident, os);
 796                     // TODO: visibility is lost here b/c OverloadSets have no visibility attribute
 797                     // Might no be a practical issue, b/c the code below fails to resolve the overload anyhow.
 798                     // ----
 799                     // module os1;
 800                     // import a, b;
 801                     // private alias merged = foo; // private alias to overload set of a.foo and b.foo
 802                     // ----
 803                     // module os2;
 804                     // import a, b;
 805                     // public alias merged = bar; // public alias to overload set of a.bar and b.bar
 806                     // ----
 807                     // module bug;
 808                     // import os1, os2;
 809                     // void test() { merged(123); } // should only look at os2.merged
 810                     //
 811                     // os.visibility = visibility;
 812                     os.parent = parent;
 813                     aliassym = os;
 814                 }
 815                 os.push(s);
 816                 return true;
 817             }
 818             return false;
 819         }
 820
 821         /* Don't know yet what the aliased symbol is, so assume it can
 822          * be overloaded and check later for correctness.
 823          */
 824         if (overnext)
 825             return overnext.overloadInsert(s);
 826         if (s is this)
 827             return true;
 828         overnext = s;
 829         return true;
 830     }
 831
 832     override const(char)* kind() const
 833     {
 834         return "alias";
 835     }
 836
 837     override Type getType()
 838     {
 839         if (type)
 840             return type;
 841         return toAlias().getType();
 842     }
 843
 844     override Dsymbol toAlias()
 845     {
 846         //printf("[%s] AliasDeclaration::toAlias('%s', this = %p, aliassym = %p, kind = '%s', inuse = %d)\n",
 847         //    loc.toChars(), toChars(), this, aliassym, aliassym ? aliassym.kind() : "", inuse);
 848         assert(this != aliassym);
 849         //static int count; if (++count == 10) *(char*)0=0;
 850
 851         // Reading the AliasDeclaration
 852         if (!(adFlags & ignoreRead))
 853             adFlags |= wasRead;                 // can never assign to this AliasDeclaration again
 854
 855         if (inuse == 1 && type && _scope)
 856         {
 857             inuse = 2;
 858             uint olderrors = global.errors;
 859             Dsymbol s = type.toDsymbol(_scope);
 860             //printf("[%s] type = %s, s = %p, this = %p\n", loc.toChars(), type.toChars(), s, this);
 861             if (global.errors != olderrors)
 862                 goto Lerr;
 863             if (s)
 864             {
 865                 s = s.toAlias();
 866                 if (global.errors != olderrors)
 867                     goto Lerr;
 868                 aliassym = s;
 869                 inuse = 0;
 870             }
 871             else
 872             {
 873                 Type t = type.typeSemantic(loc, _scope);
 874                 if (t.ty == Terror)
 875                     goto Lerr;
 876                 if (global.errors != olderrors)
 877                     goto Lerr;
 878                 //printf("t = %s\n", t.toChars());
 879                 inuse = 0;
 880             }
 881         }
 882         if (inuse)
 883         {
 884             error("recursive alias declaration");
 885
 886         Lerr:
 887             // Avoid breaking "recursive alias" state during errors gagged
 888             if (global.gag)
 889                 return this;
 890             aliassym = new AliasDeclaration(loc, ident, Type.terror);
 891             type = Type.terror;
 892             return aliassym;
 893         }
 894
 895         if (semanticRun >= PASS.semanticdone)
 896         {
 897             // semantic is already done.
 898
 899             // Do not see aliassym !is null, because of lambda aliases.
 900
 901             // Do not see type.deco !is null, even so "alias T = const int;` needs
 902             // semantic analysis to take the storage class `const` as type qualifier.
 903         }
 904         else
 905         {
 906             if (_import && _import._scope)
 907             {
 908                 /* If this is an internal alias for selective/renamed import,
 909                  * load the module first.
 910                  */
 911                 _import.dsymbolSemantic(null);
 912             }
 913             if (_scope)
 914             {
 915                 aliasSemantic(this, _scope);
 916             }
 917         }
 918
 919         inuse = 1;
 920         Dsymbol s = aliassym ? aliassym.toAlias() : this;
 921         inuse = 0;
 922         return s;
 923     }
 924
 925     override Dsymbol toAlias2()
 926     {
 927         if (inuse)
 928         {
 929             error("recursive alias declaration");
 930             return this;
 931         }
 932         inuse = 1;
 933         Dsymbol s = aliassym ? aliassym.toAlias2() : this;
 934         inuse = 0;
 935         return s;
 936     }
 937
 938     override bool isOverloadable() const
 939     {
 940         // assume overloadable until alias is resolved
 941         return semanticRun < PASS.semanticdone ||
 942             aliassym && aliassym.isOverloadable();
 943     }
 944
 945     override inout(AliasDeclaration) isAliasDeclaration() inout
 946     {
 947         return this;
 948     }
 949
 950     /** Returns: `true` if this instance was created to make a template parameter
 951     visible in the scope of a template body, `false` otherwise */
 952     extern (D) bool isAliasedTemplateParameter() const
 953     {
 954         return !!(storage_class & STC.templateparameter);
 955     }
 956
 957     override void accept(Visitor v)
 958     {
 959         v.visit(this);
 960     }
 961 }
 962
 963 /***********************************************************
 964  */
 965 extern (C++) final class OverDeclaration : Declaration
 966 {
 967     Dsymbol overnext;   // next in overload list
 968     Dsymbol aliassym;
 969
 970     extern (D) this(Identifier ident, Dsymbol s)
 971     {
 972         super(ident);
 973         this.aliassym = s;
 974     }
 975
 976     override const(char)* kind() const
 977     {
 978         return "overload alias"; // todo
 979     }
 980
 981     override bool equals(const RootObject o) const
 982     {
 983         if (this == o)
 984             return true;
 985
 986         auto s = isDsymbol(o);
 987         if (!s)
 988             return false;
 989
 990         if (auto od2 = s.isOverDeclaration())
 991             return this.aliassym.equals(od2.aliassym);
 992         return this.aliassym == s;
 993     }
 994
 995     override bool overloadInsert(Dsymbol s)
 996     {
 997         //printf("OverDeclaration::overloadInsert('%s') aliassym = %p, overnext = %p\n", s.toChars(), aliassym, overnext);
 998         if (overnext)
 999             return overnext.overloadInsert(s);
1000         if (s == this)
1001             return true;
1002         overnext = s;
1003         return true;
1004     }
1005
1006     override bool isOverloadable() const
1007     {
1008         return true;
1009     }
1010
1011     Dsymbol isUnique()
1012     {
1013         Dsymbol result = null;
1014         overloadApply(aliassym, (Dsymbol s)
1015         {
1016             if (result)
1017             {
1018                 result = null;
1019                 return 1; // ambiguous, done
1020             }
1021             else
1022             {
1023                 result = s;
1024                 return 0;
1025             }
1026         });
1027         return result;
1028     }
1029
1030     override inout(OverDeclaration) isOverDeclaration() inout
1031     {
1032         return this;
1033     }
1034
1035     override void accept(Visitor v)
1036     {
1037         v.visit(this);
1038     }
1039 }
1040
1041 /***********************************************************
1042  */
1043 extern (C++) class VarDeclaration : Declaration
1044 {
1045     Initializer _init;
1046     FuncDeclarations nestedrefs;    // referenced by these lexically nested functions
1047     Dsymbol aliassym;               // if redone as alias to another symbol
1048     VarDeclaration lastVar;         // Linked list of variables for goto-skips-init detection
1049     Expression edtor;               // if !=null, does the destruction of the variable
1050     IntRange* range;                // if !=null, the variable is known to be within the range
1051     VarDeclarations* maybes;        // STC.maybescope variables that are assigned to this STC.maybescope variable
1052
1053     uint endlinnum;                 // line number of end of scope that this var lives in
1054     uint offset;
1055     uint sequenceNumber;            // order the variables are declared
1056     structalign_t alignment;
1057
1058     // When interpreting, these point to the value (NULL if value not determinable)
1059     // The index of this variable on the CTFE stack, AdrOnStackNone if not allocated
1060     enum AdrOnStackNone = ~0u;
1061     uint ctfeAdrOnStack;
1062
1063     // `bool` fields that are compacted into bit fields in a string mixin
1064     private extern (D) static struct BitFields
1065     {
1066         bool isargptr;          /// if parameter that _argptr points to
1067         bool ctorinit;          /// it has been initialized in a ctor
1068         bool iscatchvar;        /// this is the exception object variable in catch() clause
1069         bool isowner;           /// this is an Owner, despite it being `scope`
1070         bool setInCtorOnly;     /// field can only be set in a constructor, as it is const or immutable
1071
1072         /// It is a class that was allocated on the stack
1073         ///
1074         /// This means the var is not rebindable once assigned,
1075         /// and the destructor gets run when it goes out of scope
1076         bool onstack;
1077
1078         bool overlapped;        /// if it is a field and has overlapping
1079         bool overlapUnsafe;     /// if it is an overlapping field and the overlaps are unsafe
1080         bool doNotInferScope;   /// do not infer 'scope' for this variable
1081         bool doNotInferReturn;  /// do not infer 'return' for this variable
1082
1083         bool isArgDtorVar;      /// temporary created to handle scope destruction of a function argument
1084     }
1085
1086     import dmd.common.bitfields : generateBitFields;
1087     mixin(generateBitFields!(BitFields, ushort));
1088
1089     byte canassign;                 // it can be assigned to
1090     ubyte isdataseg;                // private data for isDataseg 0 unset, 1 true, 2 false
1091
1092     final extern (D) this(const ref Loc loc, Type type, Identifier ident, Initializer _init, StorageClass storage_class = STC.undefined_)
1093     in
1094     {
1095         assert(ident);
1096     }
1097     do
1098     {
1099         //printf("VarDeclaration('%s')\n", ident.toChars());
1100         super(loc, ident);
1101         debug
1102         {
1103             if (!type && !_init)
1104             {
1105                 //printf("VarDeclaration('%s')\n", ident.toChars());
1106                 //*(char*)0=0;
1107             }
1108         }
1109
1110         assert(type || _init);
1111         this.type = type;
1112         this._init = _init;
1113         ctfeAdrOnStack = AdrOnStackNone;
1114         this.storage_class = storage_class;
1115     }
1116
1117     static VarDeclaration create(const ref Loc loc, Type type, Identifier ident, Initializer _init, StorageClass storage_class = STC.undefined_)
1118     {
1119         return new VarDeclaration(loc, type, ident, _init, storage_class);
1120     }
1121
1122     override VarDeclaration syntaxCopy(Dsymbol s)
1123     {
1124         //printf("VarDeclaration::syntaxCopy(%s)\n", toChars());
1125         assert(!s);
1126         auto v = new VarDeclaration(loc, type ? type.syntaxCopy() : null, ident, _init ? _init.syntaxCopy() : null, storage_class);
1127         v.comment = comment;
1128         return v;
1129     }
1130
1131     override void setFieldOffset(AggregateDeclaration ad, ref FieldState fieldState, bool isunion)
1132     {
1133         //printf("VarDeclaration::setFieldOffset(ad = %s) %s\n", ad.toChars(), toChars());
1134
1135         if (aliassym)
1136         {
1137             // If this variable was really a tuple, set the offsets for the tuple fields
1138             TupleDeclaration v2 = aliassym.isTupleDeclaration();
1139             assert(v2);
1140             for (size_t i = 0; i < v2.objects.dim; i++)
1141             {
1142                 RootObject o = (*v2.objects)[i];
1143                 assert(o.dyncast() == DYNCAST.expression);
1144                 Expression e = cast(Expression)o;
1145                 assert(e.op == EXP.dSymbol);
1146                 DsymbolExp se = cast(DsymbolExp)e;
1147                 se.s.setFieldOffset(ad, fieldState, isunion);
1148             }
1149             return;
1150         }
1151
1152         if (!isField())
1153             return;
1154         assert(!(storage_class & (STC.static_ | STC.extern_ | STC.parameter)));
1155
1156         //printf("+VarDeclaration::setFieldOffset(ad = %s) %s\n", ad.toChars(), toChars());
1157
1158         /* Fields that are tuples appear both as part of TupleDeclarations and
1159          * as members. That means ignore them if they are already a field.
1160          */
1161         if (offset)
1162         {
1163             // already a field
1164             fieldState.offset = ad.structsize; // https://issues.dlang.org/show_bug.cgi?id=13613
1165             return;
1166         }
1167         for (size_t i = 0; i < ad.fields.dim; i++)
1168         {
1169             if (ad.fields[i] == this)
1170             {
1171                 // already a field
1172                 fieldState.offset = ad.structsize; // https://issues.dlang.org/show_bug.cgi?id=13613
1173                 return;
1174             }
1175         }
1176
1177         // Check for forward referenced types which will fail the size() call
1178         Type t = type.toBasetype();
1179         if (storage_class & STC.ref_)
1180         {
1181             // References are the size of a pointer
1182             t = Type.tvoidptr;
1183         }
1184         Type tv = t.baseElemOf();
1185         if (tv.ty == Tstruct)
1186         {
1187             auto ts = cast(TypeStruct)tv;
1188             assert(ts.sym != ad);   // already checked in ad.determineFields()
1189             if (!ts.sym.determineSize(loc))
1190             {
1191                 type = Type.terror;
1192                 errors = true;
1193                 return;
1194             }
1195         }
1196
1197         // List in ad.fields. Even if the type is error, it's necessary to avoid
1198         // pointless error diagnostic "more initializers than fields" on struct literal.
1199         ad.fields.push(this);
1200
1201         if (t.ty == Terror)
1202             return;
1203
1204         /* If coming after a bit field in progress,
1205          * advance past the field
1206          */
1207         fieldState.inFlight = false;
1208
1209         const sz = t.size(loc);
1210         assert(sz != SIZE_INVALID && sz < uint.max);
1211         uint memsize = cast(uint)sz;                // size of member
1212         uint memalignsize = target.fieldalign(t);   // size of member for alignment purposes
1213         offset = AggregateDeclaration.placeField(
1214             &fieldState.offset,
1215             memsize, memalignsize, alignment,
1216             &ad.structsize, &ad.alignsize,
1217             isunion);
1218
1219         //printf("\t%s: memalignsize = %d\n", toChars(), memalignsize);
1220         //printf(" addField '%s' to '%s' at offset %d, size = %d\n", toChars(), ad.toChars(), offset, memsize);
1221     }
1222
1223     override const(char)* kind() const
1224     {
1225         return "variable";
1226     }
1227
1228     override final inout(AggregateDeclaration) isThis() inout
1229     {
1230         if (!(storage_class & (STC.static_ | STC.extern_ | STC.manifest | STC.templateparameter | STC.gshared | STC.ctfe)))
1231         {
1232             /* The casting is necessary because `s = s.parent` is otherwise rejected
1233              */
1234             for (auto s = cast(Dsymbol)this; s; s = s.parent)
1235             {
1236                 auto ad = (cast(inout)s).isMember();
1237                 if (ad)
1238                     return ad;
1239                 if (!s.parent || !s.parent.isTemplateMixin())
1240                     break;
1241             }
1242         }
1243         return null;
1244     }
1245
1246     override final bool needThis()
1247     {
1248         //printf("VarDeclaration::needThis(%s, x%x)\n", toChars(), storage_class);
1249         return isField();
1250     }
1251
1252     override final bool isExport() const
1253     {
1254         return visibility.kind == Visibility.Kind.export_;
1255     }
1256
1257     override final bool isImportedSymbol() const
1258     {
1259         if (visibility.kind == Visibility.Kind.export_ && !_init && (storage_class & STC.static_ || parent.isModule()))
1260             return true;
1261         return false;
1262     }
1263
1264     final bool isCtorinit() const pure nothrow @nogc @safe
1265     {
1266         return setInCtorOnly;
1267     }
1268
1269     /*******************************
1270      * Does symbol go into data segment?
1271      * Includes extern variables.
1272      */
1273     override final bool isDataseg()
1274     {
1275         version (none)
1276         {
1277             printf("VarDeclaration::isDataseg(%p, '%s')\n", this, toChars());
1278             printf("%llx, isModule: %p, isTemplateInstance: %p, isNspace: %p\n",
1279                    storage_class & (STC.static_ | STC.const_), parent.isModule(), parent.isTemplateInstance(), parent.isNspace());
1280             printf("parent = '%s'\n", parent.toChars());
1281         }
1282
1283         if (isdataseg == 0) // the value is not cached
1284         {
1285             isdataseg = 2; // The Variables does not go into the datasegment
1286
1287             if (!canTakeAddressOf())
1288             {
1289                 return false;
1290             }
1291
1292             Dsymbol parent = toParent();
1293             if (!parent && !(storage_class & STC.static_))
1294             {
1295                 error("forward referenced");
1296                 type = Type.terror;
1297             }
1298             else if (storage_class & (STC.static_ | STC.extern_ | STC.gshared) ||
1299                 parent.isModule() || parent.isTemplateInstance() || parent.isNspace())
1300             {
1301                 assert(!isParameter() && !isResult());
1302                 isdataseg = 1; // It is in the DataSegment
1303             }
1304         }
1305
1306         return (isdataseg == 1);
1307     }
1308     /************************************
1309      * Does symbol go into thread local storage?
1310      */
1311     override final bool isThreadlocal()
1312     {
1313         //printf("VarDeclaration::isThreadlocal(%p, '%s')\n", this, toChars());
1314         /* Data defaults to being thread-local. It is not thread-local
1315          * if it is immutable, const or shared.
1316          */
1317         bool i = isDataseg() && !(storage_class & (STC.immutable_ | STC.const_ | STC.shared_ | STC.gshared));
1318         //printf("\treturn %d\n", i);
1319         return i;
1320     }
1321
1322     /********************************************
1323      * Can variable be read and written by CTFE?
1324      */
1325     final bool isCTFE()
1326     {
1327         return (storage_class & STC.ctfe) != 0; // || !isDataseg();
1328     }
1329
1330     final bool isOverlappedWith(VarDeclaration v)
1331     {
1332         const vsz = v.type.size();
1333         const tsz = type.size();
1334         assert(vsz != SIZE_INVALID && tsz != SIZE_INVALID);
1335
1336         // Overlap is checked by comparing bit offsets
1337         auto bitoffset  =   offset * 8;
1338         auto vbitoffset = v.offset * 8;
1339
1340         // Bitsize of types are overridden by any bit-field widths.
1341         ulong tbitsize = void;
1342         if (auto bf = isBitFieldDeclaration())
1343         {
1344             bitoffset += bf.bitOffset;
1345             tbitsize = bf.fieldWidth;
1346         }
1347         else
1348             tbitsize = tsz * 8;
1349
1350         ulong vbitsize = void;
1351         if (auto vbf = v.isBitFieldDeclaration())
1352         {
1353             vbitoffset += vbf.bitOffset;
1354             vbitsize = vbf.fieldWidth;
1355         }
1356         else
1357             vbitsize = vsz * 8;
1358
1359         return   bitoffset < vbitoffset + vbitsize &&
1360                 vbitoffset <  bitoffset + tbitsize;
1361     }
1362
1363     override final bool hasPointers()
1364     {
1365         //printf("VarDeclaration::hasPointers() %s, ty = %d\n", toChars(), type.ty);
1366         return (!isDataseg() && type.hasPointers());
1367     }
1368
1369     /*************************************
1370      * Return true if we can take the address of this variable.
1371      */
1372     final bool canTakeAddressOf()
1373     {
1374         return !(storage_class & STC.manifest);
1375     }
1376
1377     /******************************************
1378      * Return true if variable needs to call the destructor.
1379      */
1380     final bool needsScopeDtor()
1381     {
1382         //printf("VarDeclaration::needsScopeDtor() %s\n", toChars());
1383         return edtor && !(storage_class & STC.nodtor);
1384     }
1385
1386     /******************************************
1387      * If a variable has a scope destructor call, return call for it.
1388      * Otherwise, return NULL.
1389      */
1390     extern (D) final Expression callScopeDtor(Scope* sc)
1391     {
1392         //printf("VarDeclaration::callScopeDtor() %s\n", toChars());
1393
1394         // Destruction of STC.field's is handled by buildDtor()
1395         if (storage_class & (STC.nodtor | STC.ref_ | STC.out_ | STC.field))
1396         {
1397             return null;
1398         }
1399
1400         if (iscatchvar)
1401             return null;    // destructor is built by `void semantic(Catch c, Scope* sc)`, not here
1402
1403         Expression e = null;
1404         // Destructors for structs and arrays of structs
1405         Type tv = type.baseElemOf();
1406         if (tv.ty == Tstruct)
1407         {
1408             StructDeclaration sd = (cast(TypeStruct)tv).sym;
1409             if (!sd.dtor || sd.errors)
1410                 return null;
1411
1412             const sz = type.size();
1413             assert(sz != SIZE_INVALID);
1414             if (!sz)
1415                 return null;
1416
1417             if (type.toBasetype().ty == Tstruct)
1418             {
1419                 // v.__xdtor()
1420                 e = new VarExp(loc, this);
1421
1422                 /* This is a hack so we can call destructors on const/immutable objects.
1423                  * Need to add things like "const ~this()" and "immutable ~this()" to
1424                  * fix properly.
1425                  */
1426                 e.type = e.type.mutableOf();
1427
1428                 // Enable calling destructors on shared objects.
1429                 // The destructor is always a single, non-overloaded function,
1430                 // and must serve both shared and non-shared objects.
1431                 e.type = e.type.unSharedOf;
1432
1433                 e = new DotVarExp(loc, e, sd.dtor, false);
1434                 e = new CallExp(loc, e);
1435             }
1436             else
1437             {
1438                 // __ArrayDtor(v[0 .. n])
1439                 e = new VarExp(loc, this);
1440
1441                 const sdsz = sd.type.size();
1442                 assert(sdsz != SIZE_INVALID && sdsz != 0);
1443                 const n = sz / sdsz;
1444                 e = new SliceExp(loc, e, new IntegerExp(loc, 0, Type.tsize_t), new IntegerExp(loc, n, Type.tsize_t));
1445
1446                 // Prevent redundant bounds check
1447                 (cast(SliceExp)e).upperIsInBounds = true;
1448                 (cast(SliceExp)e).lowerIsLessThanUpper = true;
1449
1450                 // This is a hack so we can call destructors on const/immutable objects.
1451                 e.type = sd.type.arrayOf();
1452
1453                 e = new CallExp(loc, new IdentifierExp(loc, Id.__ArrayDtor), e);
1454             }
1455             return e;
1456         }
1457         // Destructors for classes
1458         if (storage_class & (STC.auto_ | STC.scope_) && !(storage_class & STC.parameter))
1459         {
1460             for (ClassDeclaration cd = type.isClassHandle(); cd; cd = cd.baseClass)
1461             {
1462                 /* We can do better if there's a way with onstack
1463                  * classes to determine if there's no way the monitor
1464                  * could be set.
1465                  */
1466                 //if (cd.isInterfaceDeclaration())
1467                 //    error("interface `%s` cannot be scope", cd.toChars());
1468
1469                 if (onstack) // if any destructors
1470                 {
1471                     // delete'ing C++ classes crashes (and delete is deprecated anyway)
1472                     if (cd.classKind == ClassKind.cpp)
1473                     {
1474                         // Don't call non-existant dtor
1475                         if (!cd.dtor)
1476                             break;
1477
1478                         e = new VarExp(loc, this);
1479                         e.type = e.type.mutableOf().unSharedOf(); // Hack for mutable ctor on immutable instances
1480                         e = new DotVarExp(loc, e, cd.dtor, false);
1481                         e = new CallExp(loc, e);
1482                         break;
1483                     }
1484
1485                     // delete this;
1486                     Expression ec;
1487                     ec = new VarExp(loc, this);
1488                     e = new DeleteExp(loc, ec, true);
1489                     e.type = Type.tvoid;
1490                     break;
1491                 }
1492             }
1493         }
1494         return e;
1495     }
1496
1497     /*******************************************
1498      * If variable has a constant expression initializer, get it.
1499      * Otherwise, return null.
1500      */
1501     extern (D) final Expression getConstInitializer(bool needFullType = true)
1502     {
1503         assert(type && _init);
1504
1505         // Ungag errors when not speculative
1506         uint oldgag = global.gag;
1507         if (global.gag)
1508         {
1509             Dsymbol sym = toParent().isAggregateDeclaration();
1510             if (sym && !sym.isSpeculative())
1511                 global.gag = 0;
1512         }
1513
1514         if (_scope)
1515         {
1516             inuse++;
1517             _init = _init.initializerSemantic(_scope, type, INITinterpret);
1518             _scope = null;
1519             inuse--;
1520         }
1521
1522         Expression e = _init.initializerToExpression(needFullType ? type : null);
1523         global.gag = oldgag;
1524         return e;
1525     }
1526
1527     /*******************************************
1528      * Helper function for the expansion of manifest constant.
1529      */
1530     extern (D) final Expression expandInitializer(Loc loc)
1531     {
1532         assert((storage_class & STC.manifest) && _init);
1533
1534         auto e = getConstInitializer();
1535         if (!e)
1536         {
1537             .error(loc, "cannot make expression out of initializer for `%s`", toChars());
1538             return ErrorExp.get();
1539         }
1540
1541         e = e.copy();
1542         e.loc = loc;    // for better error message
1543         return e;
1544     }
1545
1546     override final void checkCtorConstInit()
1547     {
1548         version (none)
1549         {
1550             /* doesn't work if more than one static ctor */
1551             if (ctorinit == 0 && isCtorinit() && !isField())
1552                 error("missing initializer in static constructor for const variable");
1553         }
1554     }
1555
1556     /************************************
1557      * Check to see if this variable is actually in an enclosing function
1558      * rather than the current one.
1559      * Update nestedrefs[], closureVars[] and outerVars[].
1560      * Returns: true if error occurs.
1561      */
1562     extern (D) final bool checkNestedReference(Scope* sc, Loc loc)
1563     {
1564         //printf("VarDeclaration::checkNestedReference() %s\n", toChars());
1565         if (sc.intypeof == 1 || (sc.flags & SCOPE.ctfe))
1566             return false;
1567         if (!parent || parent == sc.parent)
1568             return false;
1569         if (isDataseg() || (storage_class & STC.manifest))
1570             return false;
1571
1572         // The current function
1573         FuncDeclaration fdthis = sc.parent.isFuncDeclaration();
1574         if (!fdthis)
1575             return false; // out of function scope
1576
1577         Dsymbol p = toParent2();
1578
1579         // Function literals from fdthis to p must be delegates
1580         ensureStaticLinkTo(fdthis, p);
1581
1582         // The function that this variable is in
1583         FuncDeclaration fdv = p.isFuncDeclaration();
1584         if (!fdv || fdv == fdthis)
1585             return false;
1586
1587         // Add fdthis to nestedrefs[] if not already there
1588         if (!nestedrefs.contains(fdthis))
1589             nestedrefs.push(fdthis);
1590
1591         //printf("\tfdv = %s\n", fdv.toChars());
1592         //printf("\tfdthis = %s\n", fdthis.toChars());
1593         if (loc.isValid())
1594         {
1595             if (fdthis.getLevelAndCheck(loc, sc, fdv, this) == fdthis.LevelError)
1596                 return true;
1597         }
1598
1599         // Add this VarDeclaration to fdv.closureVars[] if not already there
1600         if (!sc.intypeof && !(sc.flags & SCOPE.compile) &&
1601             // https://issues.dlang.org/show_bug.cgi?id=17605
1602             (fdv.flags & FUNCFLAG.compileTimeOnly || !(fdthis.flags & FUNCFLAG.compileTimeOnly))
1603            )
1604         {
1605             if (!fdv.closureVars.contains(this))
1606                 fdv.closureVars.push(this);
1607         }
1608
1609         if (!fdthis.outerVars.contains(this))
1610             fdthis.outerVars.push(this);
1611
1612         //printf("fdthis is %s\n", fdthis.toChars());
1613         //printf("var %s in function %s is nested ref\n", toChars(), fdv.toChars());
1614         // __dollar creates problems because it isn't a real variable
1615         // https://issues.dlang.org/show_bug.cgi?id=3326
1616         if (ident == Id.dollar)
1617         {
1618             .error(loc, "cannnot use `$` inside a function literal");
1619             return true;
1620         }
1621         if (ident == Id.withSym) // https://issues.dlang.org/show_bug.cgi?id=1759
1622         {
1623             ExpInitializer ez = _init.isExpInitializer();
1624             assert(ez);
1625             Expression e = ez.exp;
1626             if (e.op == EXP.construct || e.op == EXP.blit)
1627                 e = (cast(AssignExp)e).e2;
1628             return lambdaCheckForNestedRef(e, sc);
1629         }
1630
1631         return false;
1632     }
1633
1634     override final Dsymbol toAlias()
1635     {
1636         //printf("VarDeclaration::toAlias('%s', this = %p, aliassym = %p)\n", toChars(), this, aliassym);
1637         if ((!type || !type.deco) && _scope)
1638             dsymbolSemantic(this, _scope);
1639
1640         assert(this != aliassym);
1641         Dsymbol s = aliassym ? aliassym.toAlias() : this;
1642         return s;
1643     }
1644
1645     // Eliminate need for dynamic_cast
1646     override final inout(VarDeclaration) isVarDeclaration() inout
1647     {
1648         return this;
1649     }
1650
1651     override void accept(Visitor v)
1652     {
1653         v.visit(this);
1654     }
1655 }
1656
1657 /*******************************************************
1658  * C11 6.7.2.1-4 bit fields
1659  */
1660 extern (C++) class BitFieldDeclaration : VarDeclaration
1661 {
1662     Expression width;
1663
1664     uint fieldWidth;
1665     uint bitOffset;
1666
1667     final extern (D) this(const ref Loc loc, Type type, Identifier ident, Expression width)
1668     {
1669         super(loc, type, ident, null);
1670
1671         this.width = width;
1672         this.storage_class |= STC.field;
1673     }
1674
1675     override BitFieldDeclaration syntaxCopy(Dsymbol s)
1676     {
1677         //printf("BitFieldDeclaration::syntaxCopy(%s)\n", toChars());
1678         assert(!s);
1679         auto bf = new BitFieldDeclaration(loc, type ? type.syntaxCopy() : null, ident, width.syntaxCopy());
1680         bf.comment = comment;
1681         return bf;
1682     }
1683
1684     override final inout(BitFieldDeclaration) isBitFieldDeclaration() inout
1685     {
1686         return this;
1687     }
1688
1689     override void accept(Visitor v)
1690     {
1691         v.visit(this);
1692     }
1693
1694     override final void setFieldOffset(AggregateDeclaration ad, ref FieldState fieldState, bool isunion)
1695     {
1696         //printf("BitFieldDeclaration::setFieldOffset(ad: %s, field: %s)\n", ad.toChars(), toChars());
1697         static void print(const ref FieldState fieldState)
1698         {
1699             printf("FieldState.offset      = %d bytes\n",   fieldState.offset);
1700             printf("          .fieldOffset = %d bytes\n",   fieldState.fieldOffset);
1701             printf("          .bitOffset   = %d bits\n",    fieldState.bitOffset);
1702             printf("          .fieldSize   = %d bytes\n",   fieldState.fieldSize);
1703             printf("          .inFlight    = %d\n\n", fieldState.inFlight);
1704         }
1705         //print(fieldState);
1706
1707         Type t = type.toBasetype();
1708         const bool anon = isAnonymous();
1709
1710         // List in ad.fields. Even if the type is error, it's necessary to avoid
1711         // pointless error diagnostic "more initializers than fields" on struct literal.
1712         if (!anon)
1713             ad.fields.push(this);
1714
1715         if (t.ty == Terror)
1716             return;
1717
1718         const sz = t.size(loc);
1719         assert(sz != SIZE_INVALID && sz < uint.max);
1720         uint memsize = cast(uint)sz;                // size of member
1721         uint memalignsize = target.fieldalign(t);   // size of member for alignment purposes
1722
1723         if (fieldWidth == 0 && !anon)
1724             error(loc, "named bit fields cannot have 0 width");
1725         if (fieldWidth > memsize * 8)
1726             error(loc, "bit field width %d is larger than type", fieldWidth);
1727
1728         const style = target.c.bitFieldStyle;
1729
1730         void startNewField()
1731         {
1732             uint alignsize;
1733             if (style == TargetC.BitFieldStyle.Gcc_Clang)
1734             {
1735                 if (fieldWidth > 32)
1736                     alignsize = memalignsize;
1737                 else if (fieldWidth > 16)
1738                     alignsize = 4;
1739                 else if (fieldWidth > 8)
1740                     alignsize = 2;
1741                 else
1742                     alignsize = 1;
1743             }
1744             else
1745                 alignsize = memsize; // not memalignsize
1746
1747             uint dummy;
1748             offset = AggregateDeclaration.placeField(
1749                 &fieldState.offset,
1750                 memsize, alignsize, alignment,
1751                 &ad.structsize,
1752                 (anon && style == TargetC.BitFieldStyle.Gcc_Clang) ? &dummy : &ad.alignsize,
1753                 isunion);
1754
1755             fieldState.inFlight = true;
1756             fieldState.fieldOffset = offset;
1757             fieldState.bitOffset = 0;
1758             fieldState.fieldSize = memsize;
1759         }
1760
1761         if (style == TargetC.BitFieldStyle.Gcc_Clang)
1762         {
1763             if (fieldWidth == 0)
1764             {
1765                 if (!isunion)
1766                 {
1767                     // Use type of zero width field to align to next field
1768                     fieldState.offset = (fieldState.offset + memalignsize - 1) & ~(memalignsize - 1);
1769                     ad.structsize = fieldState.offset;
1770                 }
1771
1772                 fieldState.inFlight = false;
1773                 return;
1774             }
1775
1776             if (ad.alignsize == 0)
1777                 ad.alignsize = 1;
1778             if (!anon &&
1779                   ad.alignsize < memalignsize)
1780                 ad.alignsize = memalignsize;
1781         }
1782         else if (style == TargetC.BitFieldStyle.MS)
1783         {
1784             if (ad.alignsize == 0)
1785                 ad.alignsize = 1;
1786             if (fieldWidth == 0)
1787             {
1788                 if (fieldState.inFlight && !isunion)
1789                 {
1790                     // documentation says align to next int
1791                     //const alsz = cast(uint)Type.tint32.size();
1792                     const alsz = memsize; // but it really does this
1793                     fieldState.offset = (fieldState.offset + alsz - 1) & ~(alsz - 1);
1794                     ad.structsize = fieldState.offset;
1795                 }
1796
1797                 fieldState.inFlight = false;
1798                 return;
1799             }
1800         }
1801         else if (style == TargetC.BitFieldStyle.DM)
1802         {
1803             if (anon && fieldWidth && (!fieldState.inFlight || fieldState.bitOffset == 0))
1804                 return;  // this probably should be a bug in DMC
1805             if (ad.alignsize == 0)
1806                 ad.alignsize = 1;
1807             if (fieldWidth == 0)
1808             {
1809                 if (fieldState.inFlight && !isunion)
1810                 {
1811                     const alsz = memsize;
1812                     fieldState.offset = (fieldState.offset + alsz - 1) & ~(alsz - 1);
1813                     ad.structsize = fieldState.offset;
1814                 }
1815
1816                 fieldState.inFlight = false;
1817                 return;
1818             }
1819         }
1820
1821         if (!fieldState.inFlight)
1822         {
1823             startNewField();
1824         }
1825         else if (style == TargetC.BitFieldStyle.Gcc_Clang)
1826         {
1827             if (fieldState.bitOffset + fieldWidth > memsize * 8)
1828             {
1829                 //printf("start1 fieldState.bitOffset:%u fieldWidth:%u memsize:%u\n", fieldState.bitOffset, fieldWidth, memsize);
1830                 startNewField();
1831             }
1832             else
1833             {
1834                 // if alignment boundary is crossed
1835                 uint start = fieldState.fieldOffset * 8 + fieldState.bitOffset;
1836                 uint end   = start + fieldWidth;
1837                 //printf("%s start: %d end: %d memalignsize: %d\n", ad.toChars(), start, end, memalignsize);
1838                 if (start / (memalignsize * 8) != (end - 1) / (memalignsize * 8))
1839                 {
1840                     //printf("alignment is crossed\n");
1841                     startNewField();
1842                 }
1843             }
1844         }
1845         else if (style == TargetC.BitFieldStyle.DM ||
1846                  style == TargetC.BitFieldStyle.MS)
1847         {
1848             if (memsize != fieldState.fieldSize ||
1849                 fieldState.bitOffset + fieldWidth > fieldState.fieldSize * 8)
1850             {
1851                 startNewField();
1852             }
1853         }
1854         else
1855             assert(0);
1856
1857         offset = fieldState.fieldOffset;
1858         bitOffset = fieldState.bitOffset;
1859
1860         const pastField = bitOffset + fieldWidth;
1861         if (style == TargetC.BitFieldStyle.Gcc_Clang)
1862         {
1863             auto size = (pastField + 7) / 8;
1864             fieldState.fieldSize = size;
1865             //printf(" offset: %d, size: %d\n", offset, size);
1866             ad.structsize = offset + size;
1867         }
1868         else
1869             fieldState.fieldSize = memsize;
1870         //printf("at end: ad.structsize = %d\n", cast(int)ad.structsize);
1871         //print(fieldState);
1872
1873         if (!isunion)
1874         {
1875             fieldState.offset = offset + fieldState.fieldSize;
1876             fieldState.bitOffset = pastField;
1877         }
1878
1879         //printf("\t%s: memalignsize = %d\n", toChars(), memalignsize);
1880         //printf(" addField '%s' to '%s' at offset %d, size = %d\n", toChars(), ad.toChars(), offset, memsize);
1881     }
1882 }
1883
1884 /***********************************************************
1885  * This is a shell around a back end symbol
1886  */
1887 extern (C++) final class SymbolDeclaration : Declaration
1888 {
1889     AggregateDeclaration dsym;
1890
1891     extern (D) this(const ref Loc loc, AggregateDeclaration dsym)
1892     {
1893         super(loc, dsym.ident);
1894         this.dsym = dsym;
1895         storage_class |= STC.const_;
1896     }
1897
1898     // Eliminate need for dynamic_cast
1899     override inout(SymbolDeclaration) isSymbolDeclaration() inout
1900     {
1901         return this;
1902     }
1903
1904     override void accept(Visitor v)
1905     {
1906         v.visit(this);
1907     }
1908 }
1909
1910 /***********************************************************
1911  */
1912 extern (C++) class TypeInfoDeclaration : VarDeclaration
1913 {
1914     Type tinfo;
1915
1916     final extern (D) this(Type tinfo)
1917     {
1918         super(Loc.initial, Type.dtypeinfo.type, tinfo.getTypeInfoIdent(), null);
1919         this.tinfo = tinfo;
1920         storage_class = STC.static_ | STC.gshared;
1921         visibility = Visibility(Visibility.Kind.public_);
1922         linkage = LINK.c;
1923         alignment.set(target.ptrsize);
1924     }
1925
1926     static TypeInfoDeclaration create(Type tinfo)
1927     {
1928         return new TypeInfoDeclaration(tinfo);
1929     }
1930
1931     override final TypeInfoDeclaration syntaxCopy(Dsymbol s)
1932     {
1933         assert(0); // should never be produced by syntax
1934     }
1935
1936     override final const(char)* toChars() const
1937     {
1938         //printf("TypeInfoDeclaration::toChars() tinfo = %s\n", tinfo.toChars());
1939         OutBuffer buf;
1940         buf.writestring("typeid(");
1941         buf.writestring(tinfo.toChars());
1942         buf.writeByte(')');
1943         return buf.extractChars();
1944     }
1945
1946     override final inout(TypeInfoDeclaration) isTypeInfoDeclaration() inout @nogc nothrow pure @safe
1947     {
1948         return this;
1949     }
1950
1951     override void accept(Visitor v)
1952     {
1953         v.visit(this);
1954     }
1955 }
1956
1957 /***********************************************************
1958  */
1959 extern (C++) final class TypeInfoStructDeclaration : TypeInfoDeclaration
1960 {
1961     extern (D) this(Type tinfo)
1962     {
1963         super(tinfo);
1964         if (!Type.typeinfostruct)
1965         {
1966             ObjectNotFound(Id.TypeInfo_Struct);
1967         }
1968         type = Type.typeinfostruct.type;
1969     }
1970
1971     static TypeInfoStructDeclaration create(Type tinfo)
1972     {
1973         return new TypeInfoStructDeclaration(tinfo);
1974     }
1975
1976     override void accept(Visitor v)
1977     {
1978         v.visit(this);
1979     }
1980 }
1981
1982 /***********************************************************
1983  */
1984 extern (C++) final class TypeInfoClassDeclaration : TypeInfoDeclaration
1985 {
1986     extern (D) this(Type tinfo)
1987     {
1988         super(tinfo);
1989         if (!Type.typeinfoclass)
1990         {
1991             ObjectNotFound(Id.TypeInfo_Class);
1992         }
1993         type = Type.typeinfoclass.type;
1994     }
1995
1996     static TypeInfoClassDeclaration create(Type tinfo)
1997     {
1998         return new TypeInfoClassDeclaration(tinfo);
1999     }
2000
2001     override void accept(Visitor v)
2002     {
2003         v.visit(this);
2004     }
2005 }
2006
2007 /***********************************************************
2008  */
2009 extern (C++) final class TypeInfoInterfaceDeclaration : TypeInfoDeclaration
2010 {
2011     extern (D) this(Type tinfo)
2012     {
2013         super(tinfo);
2014         if (!Type.typeinfointerface)
2015         {
2016             ObjectNotFound(Id.TypeInfo_Interface);
2017         }
2018         type = Type.typeinfointerface.type;
2019     }
2020
2021     static TypeInfoInterfaceDeclaration create(Type tinfo)
2022     {
2023         return new TypeInfoInterfaceDeclaration(tinfo);
2024     }
2025
2026     override void accept(Visitor v)
2027     {
2028         v.visit(this);
2029     }
2030 }
2031
2032 /***********************************************************
2033  */
2034 extern (C++) final class TypeInfoPointerDeclaration : TypeInfoDeclaration
2035 {
2036     extern (D) this(Type tinfo)
2037     {
2038         super(tinfo);
2039         if (!Type.typeinfopointer)
2040         {
2041             ObjectNotFound(Id.TypeInfo_Pointer);
2042         }
2043         type = Type.typeinfopointer.type;
2044     }
2045
2046     static TypeInfoPointerDeclaration create(Type tinfo)
2047     {
2048         return new TypeInfoPointerDeclaration(tinfo);
2049     }
2050
2051     override void accept(Visitor v)
2052     {
2053         v.visit(this);
2054     }
2055 }
2056
2057 /***********************************************************
2058  */
2059 extern (C++) final class TypeInfoArrayDeclaration : TypeInfoDeclaration
2060 {
2061     extern (D) this(Type tinfo)
2062     {
2063         super(tinfo);
2064         if (!Type.typeinfoarray)
2065         {
2066             ObjectNotFound(Id.TypeInfo_Array);
2067         }
2068         type = Type.typeinfoarray.type;
2069     }
2070
2071     static TypeInfoArrayDeclaration create(Type tinfo)
2072     {
2073         return new TypeInfoArrayDeclaration(tinfo);
2074     }
2075
2076     override void accept(Visitor v)
2077     {
2078         v.visit(this);
2079     }
2080 }
2081
2082 /***********************************************************
2083  */
2084 extern (C++) final class TypeInfoStaticArrayDeclaration : TypeInfoDeclaration
2085 {
2086     extern (D) this(Type tinfo)
2087     {
2088         super(tinfo);
2089         if (!Type.typeinfostaticarray)
2090         {
2091             ObjectNotFound(Id.TypeInfo_StaticArray);
2092         }
2093         type = Type.typeinfostaticarray.type;
2094     }
2095
2096     static TypeInfoStaticArrayDeclaration create(Type tinfo)
2097     {
2098         return new TypeInfoStaticArrayDeclaration(tinfo);
2099     }
2100
2101     override void accept(Visitor v)
2102     {
2103         v.visit(this);
2104     }
2105 }
2106
2107 /***********************************************************
2108  */
2109 extern (C++) final class TypeInfoAssociativeArrayDeclaration : TypeInfoDeclaration
2110 {
2111     extern (D) this(Type tinfo)
2112     {
2113         super(tinfo);
2114         if (!Type.typeinfoassociativearray)
2115         {
2116             ObjectNotFound(Id.TypeInfo_AssociativeArray);
2117         }
2118         type = Type.typeinfoassociativearray.type;
2119     }
2120
2121     static TypeInfoAssociativeArrayDeclaration create(Type tinfo)
2122     {
2123         return new TypeInfoAssociativeArrayDeclaration(tinfo);
2124     }
2125
2126     override void accept(Visitor v)
2127     {
2128         v.visit(this);
2129     }
2130 }
2131
2132 /***********************************************************
2133  */
2134 extern (C++) final class TypeInfoEnumDeclaration : TypeInfoDeclaration
2135 {
2136     extern (D) this(Type tinfo)
2137     {
2138         super(tinfo);
2139         if (!Type.typeinfoenum)
2140         {
2141             ObjectNotFound(Id.TypeInfo_Enum);
2142         }
2143         type = Type.typeinfoenum.type;
2144     }
2145
2146     static TypeInfoEnumDeclaration create(Type tinfo)
2147     {
2148         return new TypeInfoEnumDeclaration(tinfo);
2149     }
2150
2151     override void accept(Visitor v)
2152     {
2153         v.visit(this);
2154     }
2155 }
2156
2157 /***********************************************************
2158  */
2159 extern (C++) final class TypeInfoFunctionDeclaration : TypeInfoDeclaration
2160 {
2161     extern (D) this(Type tinfo)
2162     {
2163         super(tinfo);
2164         if (!Type.typeinfofunction)
2165         {
2166             ObjectNotFound(Id.TypeInfo_Function);
2167         }
2168         type = Type.typeinfofunction.type;
2169     }
2170
2171     static TypeInfoFunctionDeclaration create(Type tinfo)
2172     {
2173         return new TypeInfoFunctionDeclaration(tinfo);
2174     }
2175
2176     override void accept(Visitor v)
2177     {
2178         v.visit(this);
2179     }
2180 }
2181
2182 /***********************************************************
2183  */
2184 extern (C++) final class TypeInfoDelegateDeclaration : TypeInfoDeclaration
2185 {
2186     extern (D) this(Type tinfo)
2187     {
2188         super(tinfo);
2189         if (!Type.typeinfodelegate)
2190         {
2191             ObjectNotFound(Id.TypeInfo_Delegate);
2192         }
2193         type = Type.typeinfodelegate.type;
2194     }
2195
2196     static TypeInfoDelegateDeclaration create(Type tinfo)
2197     {
2198         return new TypeInfoDelegateDeclaration(tinfo);
2199     }
2200
2201     override void accept(Visitor v)
2202     {
2203         v.visit(this);
2204     }
2205 }
2206
2207 /***********************************************************
2208  */
2209 extern (C++) final class TypeInfoTupleDeclaration : TypeInfoDeclaration
2210 {
2211     extern (D) this(Type tinfo)
2212     {
2213         super(tinfo);
2214         if (!Type.typeinfotypelist)
2215         {
2216             ObjectNotFound(Id.TypeInfo_Tuple);
2217         }
2218         type = Type.typeinfotypelist.type;
2219     }
2220
2221     static TypeInfoTupleDeclaration create(Type tinfo)
2222     {
2223         return new TypeInfoTupleDeclaration(tinfo);
2224     }
2225
2226     override void accept(Visitor v)
2227     {
2228         v.visit(this);
2229     }
2230 }
2231
2232 /***********************************************************
2233  */
2234 extern (C++) final class TypeInfoConstDeclaration : TypeInfoDeclaration
2235 {
2236     extern (D) this(Type tinfo)
2237     {
2238         super(tinfo);
2239         if (!Type.typeinfoconst)
2240         {
2241             ObjectNotFound(Id.TypeInfo_Const);
2242         }
2243         type = Type.typeinfoconst.type;
2244     }
2245
2246     static TypeInfoConstDeclaration create(Type tinfo)
2247     {
2248         return new TypeInfoConstDeclaration(tinfo);
2249     }
2250
2251     override void accept(Visitor v)
2252     {
2253         v.visit(this);
2254     }
2255 }
2256
2257 /***********************************************************
2258  */
2259 extern (C++) final class TypeInfoInvariantDeclaration : TypeInfoDeclaration
2260 {
2261     extern (D) this(Type tinfo)
2262     {
2263         super(tinfo);
2264         if (!Type.typeinfoinvariant)
2265         {
2266             ObjectNotFound(Id.TypeInfo_Invariant);
2267         }
2268         type = Type.typeinfoinvariant.type;
2269     }
2270
2271     static TypeInfoInvariantDeclaration create(Type tinfo)
2272     {
2273         return new TypeInfoInvariantDeclaration(tinfo);
2274     }
2275
2276     override void accept(Visitor v)
2277     {
2278         v.visit(this);
2279     }
2280 }
2281
2282 /***********************************************************
2283  */
2284 extern (C++) final class TypeInfoSharedDeclaration : TypeInfoDeclaration
2285 {
2286     extern (D) this(Type tinfo)
2287     {
2288         super(tinfo);
2289         if (!Type.typeinfoshared)
2290         {
2291             ObjectNotFound(Id.TypeInfo_Shared);
2292         }
2293         type = Type.typeinfoshared.type;
2294     }
2295
2296     static TypeInfoSharedDeclaration create(Type tinfo)
2297     {
2298         return new TypeInfoSharedDeclaration(tinfo);
2299     }
2300
2301     override void accept(Visitor v)
2302     {
2303         v.visit(this);
2304     }
2305 }
2306
2307 /***********************************************************
2308  */
2309 extern (C++) final class TypeInfoWildDeclaration : TypeInfoDeclaration
2310 {
2311     extern (D) this(Type tinfo)
2312     {
2313         super(tinfo);
2314         if (!Type.typeinfowild)
2315         {
2316             ObjectNotFound(Id.TypeInfo_Wild);
2317         }
2318         type = Type.typeinfowild.type;
2319     }
2320
2321     static TypeInfoWildDeclaration create(Type tinfo)
2322     {
2323         return new TypeInfoWildDeclaration(tinfo);
2324     }
2325
2326     override void accept(Visitor v)
2327     {
2328         v.visit(this);
2329     }
2330 }
2331
2332 /***********************************************************
2333  */
2334 extern (C++) final class TypeInfoVectorDeclaration : TypeInfoDeclaration
2335 {
2336     extern (D) this(Type tinfo)
2337     {
2338         super(tinfo);
2339         if (!Type.typeinfovector)
2340         {
2341             ObjectNotFound(Id.TypeInfo_Vector);
2342         }
2343         type = Type.typeinfovector.type;
2344     }
2345
2346     static TypeInfoVectorDeclaration create(Type tinfo)
2347     {
2348         return new TypeInfoVectorDeclaration(tinfo);
2349     }
2350
2351     override void accept(Visitor v)
2352     {
2353         v.visit(this);
2354     }
2355 }
2356
2357 /***********************************************************
2358  * For the "this" parameter to member functions
2359  */
2360 extern (C++) final class ThisDeclaration : VarDeclaration
2361 {
2362     extern (D) this(const ref Loc loc, Type t)
2363     {
2364         super(loc, t, Id.This, null);
2365         storage_class |= STC.nodtor;
2366     }
2367
2368     override ThisDeclaration syntaxCopy(Dsymbol s)
2369     {
2370         assert(0); // should never be produced by syntax
2371     }
2372
2373     override inout(ThisDeclaration) isThisDeclaration() inout
2374     {
2375         return this;
2376     }
2377
2378     override void accept(Visitor v)
2379     {
2380         v.visit(this);
2381     }
2382 }