gcc/d/dmd/initsem.d

   1 /**
   2  * Semantic analysis of initializers.
   3  *
   4  * Copyright:   Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved
   5  * Authors:     $(LINK2 https://www.digitalmars.com, Walter Bright)
   6  * License:     $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
   7  * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/initsem.d, _initsem.d)
   8  * Documentation:  https://dlang.org/phobos/dmd_initsem.html
   9  * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/initsem.d
  10  */
  11
  12 module dmd.initsem;
  13
  14 import core.stdc.stdio;
  15 import core.checkedint;
  16
  17 import dmd.aggregate;
  18 import dmd.aliasthis;
  19 import dmd.arraytypes;
  20 import dmd.astenums;
  21 import dmd.dcast;
  22 import dmd.declaration;
  23 import dmd.dscope;
  24 import dmd.dstruct;
  25 import dmd.dsymbol;
  26 import dmd.dtemplate;
  27 import dmd.errors;
  28 import dmd.expression;
  29 import dmd.expressionsem;
  30 import dmd.func;
  31 import dmd.globals;
  32 import dmd.hdrgen;
  33 import dmd.id;
  34 import dmd.identifier;
  35 import dmd.importc;
  36 import dmd.init;
  37 import dmd.location;
  38 import dmd.mtype;
  39 import dmd.opover;
  40 import dmd.statement;
  41 import dmd.target;
  42 import dmd.tokens;
  43 import dmd.typesem;
  44
  45 /********************************
  46  * If possible, convert array initializer to associative array initializer.
  47  *
  48  *  Params:
  49  *     ai = array initializer to be converted
  50  *
  51  *  Returns:
  52  *     The converted associative array initializer or ErrorExp if `ai`
  53  *     is not an associative array initializer.
  54  */
  55 Expression toAssocArrayLiteral(ArrayInitializer ai)
  56 {
  57     //printf("ArrayInitializer::toAssocArrayInitializer(%s)\n", ai.toChars());
  58     //static int i; if (++i == 2) assert(0);
  59     const dim = ai.value.length;
  60     if (!dim)
  61     {
  62         error(ai.loc, "invalid associative array initializer `%s`, use `null` instead",
  63             toChars(ai));
  64         return ErrorExp.get();
  65     }
  66     auto no(const char* format, Initializer i)
  67     {
  68         error(i.loc, format, toChars(i));
  69         return ErrorExp.get();
  70     }
  71     Expression e;
  72     auto keys = new Expressions(dim);
  73     auto values = new Expressions(dim);
  74     for (size_t i = 0; i < dim; i++)
  75     {
  76         Initializer iz = ai.value[i];
  77         assert(iz);
  78         e = iz.initializerToExpression();
  79         if (!e)
  80             return no("invalid value `%s` in initializer", iz);
  81         (*values)[i] = e;
  82         e = ai.index[i];
  83         if (!e)
  84             return no("missing key for value `%s` in initializer", iz);
  85         (*keys)[i] = e;
  86     }
  87     e = new AssocArrayLiteralExp(ai.loc, keys, values);
  88     return e;
  89 }
  90
  91 /******************************************
  92  * Perform semantic analysis on init.
  93  * Params:
  94  *      init = Initializer AST node
  95  *      sc = context
  96  *      tx = type that the initializer needs to become. If tx is an incomplete
  97  *           type and the initializer completes it, it is updated to be the
  98  *           complete type. ImportC has incomplete types
  99  *      needInterpret = if CTFE needs to be run on this,
 100  *                      such as if it is the initializer for a const declaration
 101  * Returns:
 102  *      `Initializer` with completed semantic analysis, `ErrorInitializer` if errors
 103  *      were encountered
 104  */
 105 extern(C++) Initializer initializerSemantic(Initializer init, Scope* sc, ref Type tx, NeedInterpret needInterpret)
 106 {
 107     Type t = tx;
 108
 109     static Initializer err()
 110     {
 111         return new ErrorInitializer();
 112     }
 113
 114     Initializer visitVoid(VoidInitializer i)
 115     {
 116         i.type = t;
 117         return i;
 118     }
 119
 120     Initializer visitError(ErrorInitializer i)
 121     {
 122         return i;
 123     }
 124
 125     Initializer visitStruct(StructInitializer i)
 126     {
 127         //printf("StructInitializer::semantic(t = %s) %s\n", t.toChars(), i.toChars());
 128         /* This works by replacing the StructInitializer with an ExpInitializer.
 129           */
 130         t = t.toBasetype();
 131         if (t.ty == Tsarray && t.nextOf().toBasetype().ty == Tstruct)
 132             t = t.nextOf().toBasetype();
 133         if (auto ts = t.isTypeStruct())
 134         {
 135             StructDeclaration sd = ts.sym;
 136             // check if the sd has a regular ctor (user defined non-copy ctor)
 137             // that is not disabled.
 138             if (sd.hasRegularCtor(true))
 139             {
 140                 error(i.loc, "%s `%s` has constructors, cannot use `{ initializers }`, use `%s( initializers )` instead", sd.kind(), sd.toChars(), sd.toChars());
 141                 return err();
 142             }
 143             sd.size(i.loc);
 144             if (sd.sizeok != Sizeok.done)
 145                 return err();
 146
 147         Expression getExp(size_t j, Type fieldType)
 148         {
 149             // Convert initializer to Expression `ex`
 150             auto tm = fieldType.addMod(t.mod);
 151             auto iz = i.value[j].initializerSemantic(sc, tm, needInterpret);
 152             auto ex = iz.initializerToExpression(null, (sc.flags & SCOPE.Cfile) != 0);
 153             if (ex.op != EXP.error)
 154                 i.value[j] = iz;
 155             return ex;
 156         }
 157             auto elements = resolveStructLiteralNamedArgs(sd, t, sc, i.loc, i.field[], &getExp, (size_t j) => i.value[j].loc);
 158             if (!elements)
 159                 return err();
 160
 161             // Make a StructLiteralExp out of elements[]
 162             auto sle = new StructLiteralExp(i.loc, sd, elements, t);
 163             if (!sd.fill(i.loc, *elements, false))
 164                 return err();
 165             sle.type = t;
 166             auto ie = new ExpInitializer(i.loc, sle);
 167             return ie.initializerSemantic(sc, t, needInterpret);
 168         }
 169         else if ((t.ty == Tdelegate || t.isPtrToFunction()) && i.value.length == 0)
 170         {
 171             const tok = (t.ty == Tdelegate) ? TOK.delegate_ : TOK.function_;
 172             /* Rewrite as empty delegate literal { }
 173              */
 174             Type tf = new TypeFunction(ParameterList(), null, LINK.d);
 175             auto fd = new FuncLiteralDeclaration(i.loc, Loc.initial, tf, tok, null);
 176             fd.fbody = new CompoundStatement(i.loc, new Statements());
 177             fd.endloc = i.loc;
 178             Expression e = new FuncExp(i.loc, fd);
 179             auto ie = new ExpInitializer(i.loc, e);
 180             return ie.initializerSemantic(sc, t, needInterpret);
 181         }
 182         if (t.ty != Terror)
 183             error(i.loc, "a struct is not a valid initializer for a `%s`", t.toChars());
 184         return err();
 185     }
 186
 187     Initializer visitArray(ArrayInitializer i)
 188     {
 189         uint length;
 190         const(uint) amax = 0x80000000;
 191         bool errors = false;
 192         //printf("ArrayInitializer::semantic(%s), ai: %s %p\n", t.toChars(), i.toChars(), i);
 193         if (i.sem) // if semantic() already run
 194         {
 195             return i;
 196         }
 197         i.sem = true;
 198         t = t.toBasetype();
 199         switch (t.ty)
 200         {
 201         case Tsarray:
 202         case Tarray:
 203             break;
 204         case Tvector:
 205             t = t.isTypeVector().basetype;
 206             break;
 207         case Taarray:
 208         case Tstruct: // consider implicit constructor call
 209             {
 210                 Expression e;
 211                 // note: MyStruct foo = [1:2, 3:4] is correct code if MyStruct has a this(int[int])
 212                 if (t.ty == Taarray || i.isAssociativeArray())
 213                     e = i.toAssocArrayLiteral();
 214                 else
 215                     e = i.initializerToExpression();
 216                 // Bugzilla 13987
 217                 if (!e)
 218                 {
 219                     error(i.loc, "cannot use array to initialize `%s`", t.toChars());
 220                     return err();
 221                 }
 222                 auto ei = new ExpInitializer(e.loc, e);
 223                 return ei.initializerSemantic(sc, t, needInterpret);
 224             }
 225         case Tpointer:
 226             if (t.nextOf().ty != Tfunction)
 227                 break;
 228             goto default;
 229         default:
 230             error(i.loc, "cannot use array to initialize `%s`", t.toChars());
 231             return err();
 232         }
 233         i.type = t;
 234         length = 0;
 235         for (size_t j = 0; j < i.index.length; j++)
 236         {
 237             Expression idx = i.index[j];
 238             if (idx)
 239             {
 240                 sc = sc.startCTFE();
 241                 idx = idx.expressionSemantic(sc);
 242                 sc = sc.endCTFE();
 243                 idx = idx.ctfeInterpret();
 244                 i.index[j] = idx;
 245                 const uinteger_t idxvalue = idx.toInteger();
 246                 if (idxvalue >= amax)
 247                 {
 248                     error(i.loc, "array index %llu overflow", idxvalue);
 249                     errors = true;
 250                 }
 251                 length = cast(uint)idxvalue;
 252                 if (idx.op == EXP.error)
 253                     errors = true;
 254             }
 255             Initializer val = i.value[j];
 256             ExpInitializer ei = val.isExpInitializer();
 257             if (ei && !idx)
 258                 ei.expandTuples = true;
 259             auto tn = t.nextOf();
 260             val = val.initializerSemantic(sc, tn, needInterpret);
 261             if (val.isErrorInitializer())
 262                 errors = true;
 263             ei = val.isExpInitializer();
 264             // found a tuple, expand it
 265             if (ei && ei.exp.op == EXP.tuple)
 266             {
 267                 TupleExp te = ei.exp.isTupleExp();
 268                 i.index.remove(j);
 269                 i.value.remove(j);
 270                 for (size_t k = 0; k < te.exps.length; ++k)
 271                 {
 272                     Expression e = (*te.exps)[k];
 273                     i.index.insert(j + k, cast(Expression)null);
 274                     i.value.insert(j + k, new ExpInitializer(e.loc, e));
 275                 }
 276                 j--;
 277                 continue;
 278             }
 279             else
 280             {
 281                 i.value[j] = val;
 282             }
 283             length++;
 284             if (length == 0)
 285             {
 286                 error(i.loc, "array dimension overflow");
 287                 return err();
 288             }
 289             if (length > i.dim)
 290                 i.dim = length;
 291         }
 292         if (auto tsa = t.isTypeSArray())
 293         {
 294             if (sc.flags & SCOPE.Cfile && tsa.isIncomplete())
 295             {
 296                 // Change to array of known length
 297                 auto tn = tsa.next.toBasetype();
 298                 tsa = new TypeSArray(tn, new IntegerExp(Loc.initial, i.dim, Type.tsize_t));
 299                 tx = tsa;      // rewrite caller's type
 300                 i.type = tsa;  // remember for later passes
 301             }
 302             else
 303             {
 304                 uinteger_t edim = tsa.dim.toInteger();
 305                 if (i.dim > edim)
 306                 {
 307                     error(i.loc, "array initializer has %u elements, but array length is %llu", i.dim, edim);
 308                     return err();
 309                 }
 310             }
 311         }
 312         if (errors)
 313             return err();
 314
 315         const sz = t.nextOf().size();
 316         if (sz == SIZE_INVALID)
 317             return err();
 318         bool overflow;
 319         const max = mulu(i.dim, sz, overflow);
 320         if (overflow || max >= amax)
 321         {
 322             error(i.loc, "array dimension %llu exceeds max of %llu", ulong(i.dim), ulong(amax / sz));
 323             return err();
 324         }
 325         //printf("returns ai: %s\n", i.toChars());
 326         return i;
 327     }
 328
 329     Initializer visitExp(ExpInitializer i)
 330     {
 331         //printf("ExpInitializer::semantic(%s), type = %s\n", i.exp.toChars(), t.toChars());
 332         if (needInterpret)
 333             sc = sc.startCTFE();
 334         i.exp = i.exp.expressionSemantic(sc);
 335         i.exp = resolveProperties(sc, i.exp);
 336         if (needInterpret)
 337             sc = sc.endCTFE();
 338         if (i.exp.op == EXP.error)
 339             return err();
 340         uint olderrors = global.errors;
 341
 342         /* ImportC: convert arrays to pointers, functions to pointers to functions
 343          */
 344         Type tb = t.toBasetype();
 345         if (tb.isTypePointer())
 346             i.exp = i.exp.arrayFuncConv(sc);
 347
 348         /* Save the expression before ctfe
 349          * Otherwise the error message would contain for example "&[0][0]" instead of "new int"
 350          * Regression: https://issues.dlang.org/show_bug.cgi?id=21687
 351          */
 352         Expression currExp = i.exp;
 353         if (needInterpret)
 354         {
 355             // If the result will be implicitly cast, move the cast into CTFE
 356             // to avoid premature truncation of polysemous types.
 357             // eg real [] x = [1.1, 2.2]; should use real precision.
 358             if (i.exp.implicitConvTo(t) && !(sc.flags & SCOPE.Cfile))
 359             {
 360                 i.exp = i.exp.implicitCastTo(sc, t);
 361             }
 362             if (!global.gag && olderrors != global.errors)
 363             {
 364                 return i;
 365             }
 366             if (sc.flags & SCOPE.Cfile)
 367             {
 368                 /* the interpreter turns (char*)"string" into &"string"[0] which then
 369                  * it cannot interpret. Resolve that case by doing optimize() first
 370                  */
 371                 i.exp = i.exp.optimize(WANTvalue);
 372                 if (i.exp.isSymOffExp())
 373                 {
 374                     /* `static variable cannot be read at compile time`
 375                      * https://issues.dlang.org/show_bug.cgi?id=22513
 376                      * Maybe this would be better addressed in ctfeInterpret()?
 377                      */
 378                     needInterpret = NeedInterpret.INITnointerpret;
 379                 }
 380             }
 381             if (needInterpret)
 382                 i.exp = i.exp.ctfeInterpret();
 383             if (i.exp.op == EXP.voidExpression)
 384                 error(i.loc, "variables cannot be initialized with an expression of type `void`. Use `void` initialization instead.");
 385         }
 386         else
 387         {
 388             i.exp = i.exp.optimize(WANTvalue);
 389         }
 390
 391         if (!global.gag && olderrors != global.errors)
 392         {
 393             return i; // Failed, suppress duplicate error messages
 394         }
 395         if (i.exp.type.isTypeTuple() && i.exp.type.isTypeTuple().arguments.length == 0)
 396         {
 397             Type et = i.exp.type;
 398             i.exp = new TupleExp(i.exp.loc, new Expressions());
 399             i.exp.type = et;
 400         }
 401         if (i.exp.op == EXP.type)
 402         {
 403             error(i.exp.loc, "initializer must be an expression, not `%s`", i.exp.toChars());
 404             return err();
 405         }
 406         // Make sure all pointers are constants
 407         if (needInterpret && hasNonConstPointers(i.exp))
 408         {
 409             error(i.exp.loc, "cannot use non-constant CTFE pointer in an initializer `%s`", currExp.toChars());
 410             return err();
 411         }
 412         Type ti = i.exp.type.toBasetype();
 413         if (i.exp.op == EXP.tuple && i.expandTuples && !i.exp.implicitConvTo(t))
 414         {
 415             return new ExpInitializer(i.loc, i.exp);
 416         }
 417         /* Look for case of initializing a static array with a too-short
 418          * string literal, such as:
 419          *  char[5] foo = "abc";
 420          * Allow this by doing an explicit cast, which will lengthen the string
 421          * literal.
 422          */
 423         if (i.exp.op == EXP.string_ && tb.ty == Tsarray)
 424         {
 425             StringExp se = i.exp.isStringExp();
 426             Type typeb = se.type.toBasetype();
 427             TY tynto = tb.nextOf().ty;
 428             if (!se.committed &&
 429                 (typeb.ty == Tarray || typeb.ty == Tsarray) && tynto.isSomeChar &&
 430                 se.numberOfCodeUnits(tynto) < tb.isTypeSArray().dim.toInteger())
 431             {
 432                 i.exp = se.castTo(sc, t);
 433                 goto L1;
 434             }
 435
 436             /* Lop off terminating 0 of initializer for:
 437              *  static char s[5] = "hello";
 438              */
 439             if (sc.flags & SCOPE.Cfile &&
 440                 typeb.ty == Tsarray &&
 441                 tynto.isSomeChar &&
 442                 tb.isTypeSArray().dim.toInteger() + 1 == typeb.isTypeSArray().dim.toInteger())
 443             {
 444                 i.exp = se.castTo(sc, t);
 445                 goto L1;
 446             }
 447         }
 448         /* C11 6.7.9-14..15
 449          * Initialize an array of unknown size with a string.
 450          * Change to static array of known size
 451          */
 452         if (sc.flags & SCOPE.Cfile && i.exp.isStringExp() &&
 453             tb.isTypeSArray() && tb.isTypeSArray().isIncomplete())
 454         {
 455             StringExp se = i.exp.isStringExp();
 456             auto ts = new TypeSArray(tb.nextOf(), new IntegerExp(Loc.initial, se.len + 1, Type.tsize_t));
 457             t = typeSemantic(ts, Loc.initial, sc);
 458             i.exp.type = t;
 459             tx = t;
 460         }
 461
 462         // Look for implicit constructor call
 463         if (tb.ty == Tstruct && !(ti.ty == Tstruct && tb.toDsymbol(sc) == ti.toDsymbol(sc)) && !i.exp.implicitConvTo(t))
 464         {
 465             StructDeclaration sd = tb.isTypeStruct().sym;
 466             if (sd.ctor)
 467             {
 468                 // Rewrite as S().ctor(exp)
 469                 Expression e;
 470                 e = new StructLiteralExp(i.loc, sd, null);
 471                 e = new DotIdExp(i.loc, e, Id.ctor);
 472                 e = new CallExp(i.loc, e, i.exp);
 473                 e = e.expressionSemantic(sc);
 474                 if (needInterpret)
 475                     i.exp = e.ctfeInterpret();
 476                 else
 477                     i.exp = e.optimize(WANTvalue);
 478             }
 479             else if (search_function(sd, Id.call))
 480             {
 481                 /* https://issues.dlang.org/show_bug.cgi?id=1547
 482                  *
 483                  * Look for static opCall
 484                  *
 485                  * Rewrite as:
 486                  *  i.exp = typeof(sd).opCall(arguments)
 487                  */
 488
 489                 Expression e = typeDotIdExp(i.loc, sd.type, Id.call);
 490                 e = new CallExp(i.loc, e, i.exp);
 491                 e = e.expressionSemantic(sc);
 492                 e = resolveProperties(sc, e);
 493                 if (needInterpret)
 494                     i.exp = e.ctfeInterpret();
 495                 else
 496                     i.exp = e.optimize(WANTvalue);
 497             }
 498         }
 499
 500         // Look for the case of statically initializing an array with a single member.
 501         // Recursively strip static array / enum layers until a compatible element is found,
 502         // and return an `ArrayLiteralExp` repeating the initializer, or `null` if no match found
 503         // int[2][3] = 7       => [[7, 7], [7, 7], [7, 7]]
 504         // int[2] = new Object => null
 505         Expression sarrayRepeat(Type tb)
 506         {
 507             auto tsa = tb.isTypeSArray();
 508             if (!tsa)
 509                 return null;
 510
 511             // printf("i.exp = %s, tsa = %s\n", i.exp.toChars(), tsa.toChars());
 512             Expression elem = null;
 513             if (i.exp.implicitConvTo(tb.nextOf()))
 514                 elem = i.exp.implicitCastTo(sc, tb.nextOf());
 515             else if (auto ae = sarrayRepeat(tb.nextOf().toBasetype()))
 516                 elem = ae;
 517             else
 518                 return null;
 519
 520             auto arrayElements = new Expressions(cast(size_t) tsa.dim.toInteger());
 521             foreach (ref e; *arrayElements)
 522                 e = elem;
 523             return new ArrayLiteralExp(i.exp.loc, tb, elem, arrayElements);
 524         }
 525
 526         if (auto sa = sarrayRepeat(tb))
 527         {
 528             // printf("sa = %s\n", sa.toChars());
 529             i.exp = sa;
 530         }
 531
 532         {
 533         auto tta = t.isTypeSArray();
 534         if (i.exp.implicitConvTo(t))
 535         {
 536             i.exp = i.exp.implicitCastTo(sc, t);
 537         }
 538         else if (sc.flags & SCOPE.Cfile && i.exp.isStringExp() &&
 539             tta && (tta.next.ty == Tint8 || tta.next.ty == Tuns8) &&
 540             ti.ty == Tsarray && ti.nextOf().ty == Tchar)
 541         {
 542             /* unsigned char bbb[1] = "";
 543              *   signed char ccc[1] = "";
 544              */
 545             i.exp = i.exp.castTo(sc, t);
 546         }
 547         else
 548         {
 549             auto tba = tb.isTypeSArray();
 550             // Look for mismatch of compile-time known length to emit
 551             // better diagnostic message, as same as AssignExp::semantic.
 552             if (tba && i.exp.implicitConvTo(tba.next.arrayOf()) > MATCH.nomatch)
 553             {
 554                 uinteger_t dim1 = tba.dim.toInteger();
 555                 uinteger_t dim2 = dim1;
 556                 if (auto ale = i.exp.isArrayLiteralExp())
 557                 {
 558                     dim2 = ale.elements ? ale.elements.length : 0;
 559                 }
 560                 else if (auto se = i.exp.isSliceExp())
 561                 {
 562                     if (Type tx = toStaticArrayType(se))
 563                         dim2 = tx.isTypeSArray().dim.toInteger();
 564                 }
 565                 if (dim1 != dim2)
 566                 {
 567                     error(i.exp.loc, "mismatched array lengths, %d and %d", cast(int)dim1, cast(int)dim2);
 568                     i.exp = ErrorExp.get();
 569                 }
 570             }
 571             Type et = i.exp.type;
 572             const errors = global.startGagging();
 573             i.exp = i.exp.implicitCastTo(sc, t);
 574             if (global.endGagging(errors))
 575                 error(currExp.loc, "cannot implicitly convert expression `%s` of type `%s` to `%s`", currExp.toChars(), et.toChars(), t.toChars());
 576         }
 577         }
 578     L1:
 579         if (i.exp.op == EXP.error)
 580         {
 581             return i;
 582         }
 583         if (needInterpret)
 584             i.exp = i.exp.ctfeInterpret();
 585         else
 586             i.exp = i.exp.optimize(WANTvalue);
 587         //printf("-ExpInitializer::semantic(): "); i.exp.print();
 588         return i;
 589     }
 590
 591     Initializer visitC(CInitializer ci)
 592     {
 593         //printf("CInitializer::semantic() tx: %s t: %s ci: %s\n", (tx ? tx.toChars() : "".ptr), t.toChars(), ci.toChars());
 594         /* Rewrite CInitializer into ExpInitializer, ArrayInitializer, or StructInitializer
 595          */
 596         t = t.toBasetype();
 597
 598         if (auto tv = t.isTypeVector())
 599             t = tv.basetype;
 600
 601         /* If `{ expression }` return the expression initializer
 602          */
 603         ExpInitializer isBraceExpression()
 604         {
 605             auto dil = ci.initializerList[];
 606             return (dil.length == 1 && !dil[0].designatorList)
 607                     ? dil[0].initializer.isExpInitializer()
 608                     : null;
 609         }
 610
 611         /********************************
 612          */
 613         bool overlaps(VarDeclaration field, VarDeclaration[] fields, StructInitializer si)
 614         {
 615             foreach (fld; fields)
 616             {
 617                 if (field.isOverlappedWith(fld))
 618                 {
 619                     // look for initializer corresponding with fld
 620                     foreach (i, ident; si.field[])
 621                     {
 622                         if (ident == fld.ident && si.value[i])
 623                             return true;   // already an initializer for `field`
 624                     }
 625                 }
 626             }
 627             return false;
 628         }
 629
 630         /* Run semantic on ExpInitializer, see if it represents entire struct ts
 631          */
 632         bool representsStruct(ExpInitializer ei, TypeStruct ts)
 633         {
 634             if (needInterpret)
 635                 sc = sc.startCTFE();
 636             ei.exp = ei.exp.expressionSemantic(sc);
 637             ei.exp = resolveProperties(sc, ei.exp);
 638             if (needInterpret)
 639                 sc = sc.endCTFE();
 640             return ei.exp.implicitConvTo(ts) != MATCH.nomatch; // initializer represents the entire struct
 641         }
 642
 643         /* If { } are omitted from substructs, use recursion to reconstruct where
 644          * brackets go
 645          * Params:
 646          *  ts = substruct to initialize
 647          *  index = index into ci.initializer, updated
 648          * Returns: struct initializer for this substruct
 649          */
 650         Initializer subStruct()(TypeStruct ts, ref size_t index)
 651         {
 652             //printf("subStruct(ts: %s, index %d)\n", ts.toChars(), cast(int)index);
 653
 654             auto si = new StructInitializer(ci.loc);
 655             StructDeclaration sd = ts.sym;
 656             sd.size(ci.loc);
 657             if (sd.sizeok != Sizeok.done)
 658             {
 659                 index = ci.initializerList.length;
 660                 return err();
 661             }
 662             const nfields = sd.fields.length;
 663
 664             foreach (fieldi; 0 .. nfields)
 665             {
 666                 if (index >= ci.initializerList.length)
 667                     break;          // ran out of initializers
 668                 auto di = ci.initializerList[index];
 669                 if (di.designatorList && fieldi != 0)
 670                     break;          // back to top level
 671                 else
 672                 {
 673                     VarDeclaration field;
 674                     while (1)   // skip field if it overlaps with previously seen fields
 675                     {
 676                         field = sd.fields[fieldi];
 677                         ++fieldi;
 678                         if (!overlaps(field, sd.fields[], si))
 679                             break;
 680                         if (fieldi == nfields)
 681                             break;
 682                     }
 683                     auto tn = field.type.toBasetype();
 684                     auto tnsa = tn.isTypeSArray();
 685                     auto tns = tn.isTypeStruct();
 686                     auto ix = di.initializer;
 687                     if (tnsa && ix.isExpInitializer())
 688                     {
 689                         ExpInitializer ei = ix.isExpInitializer();
 690                         if (ei.exp.isStringExp() && tnsa.nextOf().isintegral())
 691                         {
 692                             si.addInit(field.ident, ei);
 693                             ++index;
 694                         }
 695                         else
 696                             si.addInit(field.ident, subArray(tnsa, index)); // fwd ref of subArray is why subStruct is a template
 697                     }
 698                     else if (tns && ix.isExpInitializer())
 699                     {
 700                         /* Disambiguate between an exp representing the entire
 701                          * struct, and an exp representing the first field of the struct
 702                          */
 703                         if (representsStruct(ix.isExpInitializer(), tns)) // initializer represents the entire struct
 704                         {
 705                             si.addInit(field.ident, initializerSemantic(ix, sc, tn, needInterpret));
 706                             ++index;
 707                         }
 708                         else                                // field initializers for struct
 709                             si.addInit(field.ident, subStruct(tns, index)); // the first field
 710                     }
 711                     else
 712                     {
 713                         si.addInit(field.ident, ix);
 714                         ++index;
 715                     }
 716                 }
 717             }
 718             //printf("subStruct() returns ai: %s, index: %d\n", si.toChars(), cast(int)index);
 719             return si;
 720         }
 721
 722         /* If { } are omitted from subarrays, use recursion to reconstruct where
 723          * brackets go
 724          * Params:
 725          *  tsa = subarray to initialize
 726          *  index = index into ci.initializer, updated
 727          * Returns: array initializer for this subarray
 728          */
 729         Initializer subArray(TypeSArray tsa, ref size_t index)
 730         {
 731             //printf("array(tsa: %s, index %d)\n", tsa.toChars(), cast(int)index);
 732             if (tsa.isIncomplete())
 733             {
 734                 // C11 6.2.5-20 "element type shall be complete whenever the array type is specified"
 735                 assert(0); // should have been detected by parser
 736             }
 737
 738             auto tnsa = tsa.nextOf().toBasetype().isTypeSArray();
 739
 740             auto ai = new ArrayInitializer(ci.loc);
 741             ai.isCarray = true;
 742
 743             foreach (n; 0 .. cast(size_t)tsa.dim.toInteger())
 744             {
 745                 if (index >= ci.initializerList.length)
 746                     break;          // ran out of initializers
 747                 auto di = ci.initializerList[index];
 748                 if (di.designatorList)
 749                     break;          // back to top level
 750                 else if (tnsa && di.initializer.isExpInitializer())
 751                 {
 752                     ExpInitializer ei = di.initializer.isExpInitializer();
 753                     if (ei.exp.isStringExp() && tnsa.nextOf().isintegral())
 754                     {
 755                         ai.addInit(null, ei);
 756                         ++index;
 757                     }
 758                     else
 759                         ai.addInit(null, subArray(tnsa, index));
 760                 }
 761                 else
 762                 {
 763                     ai.addInit(null, di.initializer);
 764                     ++index;
 765                 }
 766             }
 767             //printf("array() returns ai: %s, index: %d\n", ai.toChars(), cast(int)index);
 768             return ai;
 769         }
 770
 771         if (auto ts = t.isTypeStruct())
 772         {
 773             auto si = new StructInitializer(ci.loc);
 774             StructDeclaration sd = ts.sym;
 775             sd.size(ci.loc);            // run semantic() on sd to get fields
 776             if (sd.sizeok != Sizeok.done)
 777             {
 778                 return err();
 779             }
 780             const nfields = sd.fields.length;
 781             size_t fieldi = 0;
 782
 783         Loop1:
 784             for (size_t index = 0; index < ci.initializerList.length; )
 785             {
 786                 CInitializer cprev;
 787              L1:
 788                 DesigInit di = ci.initializerList[index];
 789                 Designators* dlist = di.designatorList;
 790                 if (dlist)
 791                 {
 792                     const length = (*dlist).length;
 793                     if (length == 0 || !(*dlist)[0].ident)
 794                     {
 795                         error(ci.loc, "`.identifier` expected for C struct field initializer `%s`", toChars(ci));
 796                         return err();
 797                     }
 798                     if (length > 1)
 799                     {
 800                         error(ci.loc, "only 1 designator currently allowed for C struct field initializer `%s`", toChars(ci));
 801                         return err();
 802                     }
 803                     auto id = (*dlist)[0].ident;
 804                     foreach (k, f; sd.fields[])         // linear search for now
 805                     {
 806                         if (f.ident == id)
 807                         {
 808                             fieldi = k;
 809                             si.addInit(id, di.initializer);
 810                             ++fieldi;
 811                             ++index;
 812                             continue Loop1;
 813                         }
 814                     }
 815                     if (cprev)
 816                     {
 817                         /* The peeling didn't work, so unpeel it
 818                          */
 819                         ci = cprev;
 820                         di = ci.initializerList[index];
 821                         goto L2;
 822                     }
 823                     error(ci.loc, "`.%s` is not a field of `%s`\n", id.toChars(), sd.toChars());
 824                     return err();
 825                 }
 826                 else
 827                 {
 828                     if (fieldi == nfields)
 829                         break;
 830                     if (index == 0 && ci.initializerList.length == 1 && di.initializer.isCInitializer())
 831                     {
 832                         /* Try peeling off this set of { } and see if it works
 833                          */
 834                         cprev = ci;
 835                         ci = di.initializer.isCInitializer();
 836                         goto L1;
 837                     }
 838
 839                 L2:
 840                     VarDeclaration field;
 841                     while (1)   // skip field if it overlaps with previously seen fields
 842                     {
 843                         field = sd.fields[fieldi];
 844                         ++fieldi;
 845                         if (!overlaps(field, sd.fields[], si))
 846                             break;
 847                         if (fieldi == nfields)
 848                             break;
 849                     }
 850                     auto tn = field.type.toBasetype();
 851                     auto tnsa = tn.isTypeSArray();
 852                     auto tns = tn.isTypeStruct();
 853                     auto ix = di.initializer;
 854                     if (tnsa && ix.isExpInitializer())
 855                     {
 856                         ExpInitializer ei = ix.isExpInitializer();
 857                         if (ei.exp.isStringExp() && tnsa.nextOf().isintegral())
 858                         {
 859                             si.addInit(field.ident, ei);
 860                             ++index;
 861                         }
 862                         else
 863                             si.addInit(field.ident, subArray(tnsa, index));
 864                     }
 865                     else if (tns && ix.isExpInitializer())
 866                     {
 867                         /* Disambiguate between an exp representing the entire
 868                          * struct, and an exp representing the first field of the struct
 869                          */
 870                         if (representsStruct(ix.isExpInitializer(), tns)) // initializer represents the entire struct
 871                         {
 872                             si.addInit(field.ident, initializerSemantic(ix, sc, tn, needInterpret));
 873                             ++index;
 874                         }
 875                         else                                // field initializers for struct
 876                             si.addInit(field.ident, subStruct(tns, index)); // the first field
 877                     }
 878                     else
 879                     {
 880                         si.addInit(field.ident, di.initializer);
 881                         ++index;
 882                     }
 883                 }
 884             }
 885             return initializerSemantic(si, sc, t, needInterpret);
 886         }
 887         else if (auto ta = t.isTypeSArray())
 888         {
 889             auto tn = t.nextOf().toBasetype();  // element type of array
 890
 891             /* If it's an array of integral being initialized by `{ string }`
 892              * replace with `string`
 893              */
 894             if (tn.isintegral())
 895             {
 896                 if (ExpInitializer ei = isBraceExpression())
 897                 {
 898                     if (ei.exp.isStringExp())
 899                         return ei.initializerSemantic(sc, t, needInterpret);
 900                 }
 901             }
 902
 903             auto tnsa = tn.isTypeSArray();      // array of array
 904             auto tns = tn.isTypeStruct();       // array of struct
 905
 906             auto ai = new ArrayInitializer(ci.loc);
 907             ai.isCarray = true;
 908             for (size_t index = 0; index < ci.initializerList.length; )
 909             {
 910                 auto di = ci.initializerList[index];
 911                 if (auto dlist = di.designatorList)
 912                 {
 913                     const length = (*dlist).length;
 914                     if (length == 0 || !(*dlist)[0].exp)
 915                     {
 916                         error(ci.loc, "`[ constant-expression ]` expected for C array element initializer `%s`", toChars(ci));
 917                         return err();
 918                     }
 919                     if (length > 1)
 920                     {
 921                         error(ci.loc, "only 1 designator currently allowed for C array element initializer `%s`", toChars(ci));
 922                         return err();
 923                     }
 924                     //printf("tn: %s, di.initializer: %s\n", tn.toChars(), di.initializer.toChars());
 925                     auto ix = di.initializer;
 926                     if (tnsa && ix.isExpInitializer())
 927                     {
 928                         // Wrap initializer in [ ]
 929                         auto ain = new ArrayInitializer(ci.loc);
 930                         ain.addInit(null, di.initializer);
 931                         ix = ain;
 932                         ai.addInit((*dlist)[0].exp, initializerSemantic(ix, sc, tn, needInterpret));
 933                         ++index;
 934                     }
 935                     else if (tns && ix.isExpInitializer())
 936                     {
 937                         /* Disambiguate between an exp representing the entire
 938                          * struct, and an exp representing the first field of the struct
 939                          */
 940                         if (representsStruct(ix.isExpInitializer(), tns)) // initializer represents the entire struct
 941                         {
 942                             ai.addInit((*dlist)[0].exp, initializerSemantic(ix, sc, tn, needInterpret));
 943                             ++index;
 944                         }
 945                         else                                // field initializers for struct
 946                             ai.addInit((*dlist)[0].exp, subStruct(tns, index)); // the first field
 947                     }
 948                     else
 949                     {
 950                         ai.addInit((*dlist)[0].exp, initializerSemantic(ix, sc, tn, needInterpret));
 951                         ++index;
 952                     }
 953                 }
 954                 else if (tnsa && di.initializer.isExpInitializer())
 955                 {
 956                     ExpInitializer ei = di.initializer.isExpInitializer();
 957                     if (ei.exp.isStringExp() && tnsa.nextOf().isintegral())
 958                     {
 959                         ai.addInit(null, ei);
 960                         ++index;
 961                     }
 962                     else
 963                         ai.addInit(null, subArray(tnsa, index));
 964                 }
 965                 else if (tns && di.initializer.isExpInitializer())
 966                 {
 967                     /* Disambiguate between an exp representing the entire
 968                      * struct, and an exp representing the first field of the struct
 969                      */
 970                     if (representsStruct(di.initializer.isExpInitializer(), tns)) // initializer represents the entire struct
 971                     {
 972                         ai.addInit(null, initializerSemantic(di.initializer, sc, tn, needInterpret));
 973                         ++index;
 974                     }
 975                     else                                // field initializers for struct
 976                         ai.addInit(null, subStruct(tns, index)); // the first field
 977                 }
 978                 else
 979                 {
 980                     ai.addInit(null, initializerSemantic(di.initializer, sc, tn, needInterpret));
 981                     ++index;
 982                 }
 983             }
 984             return initializerSemantic(ai, sc, tx, needInterpret);
 985         }
 986         else if (ExpInitializer ei = isBraceExpression())
 987         {
 988             return visitExp(ei);
 989         }
 990         else
 991         {
 992             error(ci.loc, "unrecognized C initializer `%s`", toChars(ci));
 993             return err();
 994         }
 995     }
 996
 997     mixin VisitInitializer!Initializer visit;
 998     auto result = visit.VisitInitializer(init);
 999     return (result !is null) ? result : new ErrorInitializer();
1000 }
1001
1002 /***********************
1003  * Translate init to an `Expression` in order to infer the type.
1004  * Params:
1005  *      init = `Initializer` AST node
1006  *      sc = context
1007  * Returns:
1008  *      an equivalent `ExpInitializer` if successful, or `ErrorInitializer` if it cannot be translated
1009  */
1010 Initializer inferType(Initializer init, Scope* sc)
1011 {
1012     Initializer visitVoid(VoidInitializer i)
1013     {
1014         error(i.loc, "cannot infer type from void initializer");
1015         return new ErrorInitializer();
1016     }
1017
1018     Initializer visitError(ErrorInitializer i)
1019     {
1020         return i;
1021     }
1022
1023     Initializer visitStruct(StructInitializer i)
1024     {
1025         error(i.loc, "cannot infer type from struct initializer");
1026         return new ErrorInitializer();
1027     }
1028
1029     Initializer visitArray(ArrayInitializer init)
1030     {
1031         //printf("ArrayInitializer::inferType() %s\n", toChars());
1032         Expressions* keys = null;
1033         Expressions* values;
1034         if (init.isAssociativeArray())
1035         {
1036             keys = new Expressions(init.value.length);
1037             values = new Expressions(init.value.length);
1038             for (size_t i = 0; i < init.value.length; i++)
1039             {
1040                 Expression e = init.index[i];
1041                 if (!e)
1042                     goto Lno;
1043                 (*keys)[i] = e;
1044                 Initializer iz = init.value[i];
1045                 if (!iz)
1046                     goto Lno;
1047                 iz = iz.inferType(sc);
1048                 if (iz.isErrorInitializer())
1049                 {
1050                     return iz;
1051                 }
1052                 (*values)[i] = iz.isExpInitializer().exp;
1053                 assert(!(*values)[i].isErrorExp());
1054             }
1055             Expression e = new AssocArrayLiteralExp(init.loc, keys, values);
1056             auto ei = new ExpInitializer(init.loc, e);
1057             return ei.inferType(sc);
1058         }
1059         else
1060         {
1061             auto elements = new Expressions(init.value.length);
1062             elements.zero();
1063             for (size_t i = 0; i < init.value.length; i++)
1064             {
1065                 assert(!init.index[i]); // already asserted by isAssociativeArray()
1066                 Initializer iz = init.value[i];
1067                 if (!iz)
1068                     goto Lno;
1069                 iz = iz.inferType(sc);
1070                 if (iz.isErrorInitializer())
1071                 {
1072                     return iz;
1073                 }
1074                 (*elements)[i] = iz.isExpInitializer().exp;
1075                 assert(!(*elements)[i].isErrorExp());
1076             }
1077             Expression e = new ArrayLiteralExp(init.loc, null, elements);
1078             auto ei = new ExpInitializer(init.loc, e);
1079             return ei.inferType(sc);
1080         }
1081     Lno:
1082         if (keys)
1083         {
1084             error(init.loc, "not an associative array initializer");
1085         }
1086         else
1087         {
1088             error(init.loc, "cannot infer type from array initializer");
1089         }
1090         return new ErrorInitializer();
1091     }
1092
1093     Initializer visitExp(ExpInitializer init)
1094     {
1095         //printf("ExpInitializer::inferType() %s\n", init.toChars());
1096         init.exp = init.exp.expressionSemantic(sc);
1097
1098         // for static alias this: https://issues.dlang.org/show_bug.cgi?id=17684
1099         if (init.exp.op == EXP.type)
1100             init.exp = resolveAliasThis(sc, init.exp);
1101
1102         init.exp = resolveProperties(sc, init.exp);
1103         if (auto se = init.exp.isScopeExp())
1104         {
1105             TemplateInstance ti = se.sds.isTemplateInstance();
1106             if (ti && ti.semanticRun == PASS.semantic && !ti.aliasdecl)
1107                 error(se.loc, "cannot infer type from %s `%s`, possible circular dependency", se.sds.kind(), se.toChars());
1108             else
1109                 error(se.loc, "cannot infer type from %s `%s`", se.sds.kind(), se.toChars());
1110             return new ErrorInitializer();
1111         }
1112
1113         // Give error for overloaded function addresses
1114         bool hasOverloads;
1115         if (auto f = isFuncAddress(init.exp, &hasOverloads))
1116         {
1117             if (f.checkForwardRef(init.loc))
1118             {
1119                 return new ErrorInitializer();
1120             }
1121             if (hasOverloads && !f.isUnique())
1122             {
1123                 error(init.exp.loc, "cannot infer type from overloaded function symbol `%s`", init.exp.toChars());
1124                 return new ErrorInitializer();
1125             }
1126         }
1127         if (auto ae = init.exp.isAddrExp())
1128         {
1129             if (ae.e1.op == EXP.overloadSet)
1130             {
1131                 error(init.exp.loc, "cannot infer type from overloaded function symbol `%s`", init.exp.toChars());
1132                 return new ErrorInitializer();
1133             }
1134         }
1135         if (init.exp.isErrorExp())
1136         {
1137             return new ErrorInitializer();
1138         }
1139         if (!init.exp.type)
1140         {
1141             return new ErrorInitializer();
1142         }
1143         return init;
1144     }
1145
1146     Initializer visitC(CInitializer i)
1147     {
1148         //printf("CInitializer.inferType()\n");
1149         error(i.loc, "TODO C inferType initializers not supported yet");
1150         return new ErrorInitializer();
1151     }
1152
1153     mixin VisitInitializer!Initializer visit;
1154     auto result = visit.VisitInitializer(init);
1155     return (result !is null) ? result : new ErrorInitializer();
1156 }
1157
1158 /***********************
1159  * Translate init to an `Expression`.
1160  * Params:
1161  *      init = `Initializer` AST node
1162  *      itype = if not `null`, type to coerce expression to
1163  *      isCfile = default initializers are different with C
1164  * Returns:
1165  *      `Expression` created, `null` if cannot, `ErrorExp` for other errors
1166  */
1167 extern (C++) Expression initializerToExpression(Initializer init, Type itype = null, const bool isCfile = false)
1168 {
1169     //printf("initializerToExpression() isCfile: %d\n", isCfile);
1170
1171     Expression visitVoid(VoidInitializer)
1172     {
1173         return null;
1174     }
1175
1176     Expression visitError(ErrorInitializer)
1177     {
1178         return ErrorExp.get();
1179     }
1180
1181     /***************************************
1182      * This works by transforming a struct initializer into
1183      * a struct literal. In the future, the two should be the
1184      * same thing.
1185      */
1186     Expression visitStruct(StructInitializer)
1187     {
1188         // cannot convert to an expression without target 'ad'
1189         return null;
1190     }
1191
1192     /********************************
1193      * If possible, convert array initializer to array literal.
1194      * Otherwise return NULL.
1195      */
1196     Expression visitArray(ArrayInitializer init)
1197     {
1198         //printf("ArrayInitializer::toExpression(), dim = %d\n", dim);
1199         //static int i; if (++i == 2) assert(0);
1200         uint edim;      // the length of the resulting array literal
1201         const(uint) amax = 0x80000000;
1202         Type t = null;  // type of the array literal being initialized
1203         if (init.type)
1204         {
1205             if (init.type == Type.terror)
1206             {
1207                 return ErrorExp.get();
1208             }
1209             t = init.type.toBasetype();
1210             switch (t.ty)
1211             {
1212             case Tvector:
1213                 t = t.isTypeVector().basetype;
1214                 goto case Tsarray;
1215
1216             case Tsarray:
1217                 uinteger_t adim = t.isTypeSArray().dim.toInteger();
1218                 if (adim >= amax)
1219                     return null;
1220                 edim = cast(uint)adim;
1221                 break;
1222
1223             case Tpointer:
1224             case Tarray:
1225                 edim = init.dim;
1226                 break;
1227
1228             default:
1229                 assert(0);
1230             }
1231         }
1232         else
1233         {
1234             /* Calculate the length of the array literal
1235              */
1236             edim = cast(uint)init.value.length;
1237             size_t j = 0;
1238             foreach (i; 0 .. init.value.length)
1239             {
1240                 if (auto e = init.index[i])
1241                 {
1242                     if (e.op == EXP.int64)
1243                     {
1244                         const uinteger_t idxval = e.toInteger();
1245                         if (idxval >= amax)
1246                             return null;
1247                         j = cast(size_t)idxval;
1248                     }
1249                     else
1250                         return null;
1251                 }
1252                 ++j;
1253                 if (j > edim)
1254                     edim = cast(uint)j;
1255             }
1256         }
1257
1258         auto elements = new Expressions(edim);
1259         elements.zero();
1260         size_t j = 0;
1261         foreach (i; 0 .. init.value.length)
1262         {
1263             if (auto e = init.index[i])
1264                 j = cast(size_t)e.toInteger();
1265             assert(j < edim);
1266             if (Initializer iz = init.value[i])
1267             {
1268                 if (Expression ex = iz.initializerToExpression(null, isCfile))
1269                 {
1270                     (*elements)[j] = ex;
1271                     ++j;
1272                 }
1273                 else
1274                     return null;
1275             }
1276             else
1277                 return null;
1278         }
1279
1280         /* Fill in any missing elements with the default initializer
1281          */
1282         Expression defaultInit = null;  // lazily create it
1283         foreach (ref element; (*elements)[0 .. edim])
1284         {
1285             if (!element)
1286             {
1287                 if (!init.type) // don't know what type to use
1288                     return null;
1289                 if (!defaultInit)
1290                     defaultInit = (cast(TypeNext)t).next.defaultInit(Loc.initial, isCfile);
1291                 element = defaultInit;
1292             }
1293         }
1294
1295         /* Expand any static array initializers that are a single expression
1296          * into an array of them
1297          *    e => [e, e, ..., e, e]
1298          */
1299         if (t)
1300         {
1301             Type tn = t.nextOf().toBasetype();
1302             if (tn.ty == Tsarray)
1303             {
1304                 const dim = cast(size_t)(cast(TypeSArray)tn).dim.toInteger();
1305                 Type te = tn.nextOf().toBasetype();
1306                 foreach (ref e; *elements)
1307                 {
1308                     if (te.equals(e.type))
1309                     {
1310                         auto elements2 = new Expressions(dim);
1311                         foreach (ref e2; *elements2)
1312                             e2 = e;
1313                         e = new ArrayLiteralExp(e.loc, tn, elements2);
1314                     }
1315                 }
1316             }
1317         }
1318
1319         /* If any elements are errors, then the whole thing is an error
1320          */
1321         foreach (e; (*elements)[0 .. edim])
1322         {
1323             if (e.op == EXP.error)
1324             {
1325                 return e;
1326             }
1327         }
1328
1329         Expression e = new ArrayLiteralExp(init.loc, init.type, elements);
1330         return e;
1331     }
1332
1333     Expression visitExp(ExpInitializer i)
1334     {
1335         if (itype)
1336         {
1337             //printf("ExpInitializer::toExpression(t = %s) exp = %s\n", itype.toChars(), i.exp.toChars());
1338             Type tb = itype.toBasetype();
1339             Expression e = (i.exp.op == EXP.construct || i.exp.op == EXP.blit) ? (cast(AssignExp)i.exp).e2 : i.exp;
1340             if (tb.ty == Tsarray && e.implicitConvTo(tb.nextOf()))
1341             {
1342                 TypeSArray tsa = cast(TypeSArray)tb;
1343                 size_t d = cast(size_t)tsa.dim.toInteger();
1344                 auto elements = new Expressions(d);
1345                 for (size_t j = 0; j < d; j++)
1346                     (*elements)[j] = e;
1347                 auto ae = new ArrayLiteralExp(e.loc, itype, elements);
1348                 return ae;
1349             }
1350         }
1351         return i.exp;
1352     }
1353
1354     Expression visitC(CInitializer i)
1355     {
1356         //printf("CInitializer.initializerToExpression(null, true)\n");
1357         return null;
1358     }
1359
1360     mixin VisitInitializer!Expression visit;
1361     return visit.VisitInitializer(init);
1362 }
1363
1364
1365 /**************************************
1366  * Determine if expression has non-constant pointers, or more precisely,
1367  * a pointer that CTFE cannot handle.
1368  * Params:
1369  *    e = expression to check
1370  * Returns:
1371  *    true if it has non-constant pointers
1372  */
1373 private bool hasNonConstPointers(Expression e)
1374 {
1375     static bool checkArray(Expressions* elems)
1376     {
1377         foreach (e; *elems)
1378         {
1379             if (e && hasNonConstPointers(e))
1380                 return true;
1381         }
1382         return false;
1383     }
1384
1385     if (e.type.ty == Terror)
1386         return false;
1387     if (e.op == EXP.null_)
1388         return false;
1389     if (auto se = e.isStructLiteralExp())
1390     {
1391         return checkArray(se.elements);
1392     }
1393     if (auto ae = e.isArrayLiteralExp())
1394     {
1395         if (!ae.type.nextOf().hasPointers())
1396             return false;
1397         return checkArray(ae.elements);
1398     }
1399     if (auto ae = e.isAssocArrayLiteralExp())
1400     {
1401         if (ae.type.nextOf().hasPointers() && checkArray(ae.values))
1402             return true;
1403         if (ae.type.isTypeAArray().index.hasPointers())
1404             return checkArray(ae.keys);
1405         return false;
1406     }
1407     if (auto ae = e.isAddrExp())
1408     {
1409         if (ae.type.nextOf().isImmutable() || ae.type.nextOf().isConst())
1410         {
1411             return false;
1412         }
1413         if (auto se = ae.e1.isStructLiteralExp())
1414         {
1415             if (!(se.stageflags & stageSearchPointers))
1416             {
1417                 const old = se.stageflags;
1418                 se.stageflags |= stageSearchPointers;
1419                 bool ret = checkArray(se.elements);
1420                 se.stageflags = old;
1421                 return ret;
1422             }
1423             else
1424             {
1425                 return false;
1426             }
1427         }
1428         return true;
1429     }
1430     if (e.type.ty == Tpointer && !e.type.isPtrToFunction())
1431     {
1432         if (e.op == EXP.symbolOffset) // address of a global is OK
1433             return false;
1434         if (e.op == EXP.int64) // cast(void *)int is OK
1435             return false;
1436         if (e.op == EXP.string_) // "abc".ptr is OK
1437             return false;
1438         return true;
1439     }
1440     return false;
1441 }
1442
1443 /**
1444 Given the names and values of a `StructInitializer` or `CallExp`,
1445 resolve it to a list of expressions to construct a `StructLiteralExp`.
1446
1447 Params:
1448     sd = struct
1449     t = type of struct (potentially including qualifiers such as `const` or `immutable`)
1450     sc = scope of the expression initializing the struct
1451     iloc = location of expression initializing the struct
1452     names = identifiers passed in argument list, `null` entries for positional arguments
1453     getExp = function that, given an index into `names` and destination type, returns the initializing expression
1454     getLoc = function that, given an index into `names`, returns a location for error messages
1455
1456 Returns: list of expressions ordered to the struct's fields, or `null` on error
1457 */
1458 Expressions* resolveStructLiteralNamedArgs(StructDeclaration sd, Type t, Scope* sc,
1459     Loc iloc, Identifier[] names, scope Expression delegate(size_t i, Type fieldType) getExp,
1460     scope Loc delegate(size_t i) getLoc
1461 )
1462 {
1463     //expandTuples for non-identity arguments?
1464     const nfields = sd.nonHiddenFields();
1465     auto elements = new Expressions(nfields);
1466     auto elems = (*elements)[];
1467     foreach (ref elem; elems)
1468         elem = null;
1469
1470     // Run semantic for explicitly given initializers
1471     // TODO: this part is slightly different from StructLiteralExp::semantic.
1472     bool errors = false;
1473     size_t fieldi = 0;
1474     foreach (j, id; names)
1475     {
1476         const argLoc = getLoc(j);
1477         if (id)
1478         {
1479             // Determine `fieldi` that `id` matches
1480             Dsymbol s = sd.search(iloc, id);
1481             if (!s)
1482             {
1483                 s = sd.search_correct(id);
1484                 if (s)
1485                     error(argLoc, "`%s` is not a member of `%s`, did you mean %s `%s`?", id.toChars(), sd.toChars(), s.kind(), s.toChars());
1486                 else
1487                     error(argLoc, "`%s` is not a member of `%s`", id.toChars(), sd.toChars());
1488                 return null;
1489             }
1490             s.checkDeprecated(iloc, sc);
1491             s = s.toAlias();
1492
1493             // Find out which field index `s` is
1494             for (fieldi = 0; 1; fieldi++)
1495             {
1496                 if (fieldi >= nfields)
1497                 {
1498                     error(iloc, "`%s.%s` is not a per-instance initializable field", sd.toChars(), s.toChars());
1499                     return null;
1500                 }
1501                 if (s == sd.fields[fieldi])
1502                     break;
1503             }
1504         }
1505         if (nfields == 0)
1506         {
1507             error(argLoc, "initializer provided for struct `%s` with no fields", sd.toChars());
1508             return null;
1509         }
1510         if (j >= nfields)
1511         {
1512             error(argLoc, "too many initializers for `%s` with %d field%s", sd.toChars(),
1513                 cast(int) nfields, nfields != 1 ? "s".ptr : "".ptr);
1514             return null;
1515         }
1516
1517         VarDeclaration vd = sd.fields[fieldi];
1518         if (elems[fieldi])
1519         {
1520             error(argLoc, "duplicate initializer for field `%s`", vd.toChars());
1521             errors = true;
1522             elems[fieldi] = ErrorExp.get(); // for better diagnostics on multiple errors
1523             ++fieldi;
1524             continue;
1525         }
1526
1527         // Check for @safe violations
1528         if (vd.type.hasPointers)
1529         {
1530             if ((!t.alignment.isDefault() && t.alignment.get() < target.ptrsize ||
1531                     (vd.offset & (target.ptrsize - 1))))
1532             {
1533                 if (sc.setUnsafe(false, argLoc,
1534                     "field `%s.%s` cannot assign to misaligned pointers in `@safe` code", sd, vd))
1535                 {
1536                     errors = true;
1537                     elems[fieldi] = ErrorExp.get(); // for better diagnostics on multiple errors
1538                     ++fieldi;
1539                     continue;
1540                 }
1541             }
1542         }
1543
1544         // Check for overlapping initializations (can happen with unions)
1545         foreach (k, v2; sd.fields[0 .. nfields])
1546         {
1547             if (vd.isOverlappedWith(v2) && elems[k])
1548             {
1549                 error(elems[k].loc, "overlapping initialization for field `%s` and `%s`", v2.toChars(), vd.toChars());
1550                 enum errorMsg = "`struct` initializers that contain anonymous unions" ~
1551                     " must initialize only the first member of a `union`. All subsequent" ~
1552                     " non-overlapping fields are default initialized";
1553                 if (!sd.isUnionDeclaration())
1554                     .errorSupplemental(elems[k].loc, errorMsg);
1555                 errors = true;
1556                 continue;
1557             }
1558         }
1559
1560         assert(sc);
1561
1562         auto ex = getExp(j, vd.type);
1563
1564         if (ex.op == EXP.error)
1565         {
1566             errors = true;
1567             elems[fieldi] = ErrorExp.get(); // for better diagnostics on multiple errors
1568             ++fieldi;
1569             continue;
1570         }
1571
1572         elems[fieldi] = doCopyOrMove(sc, ex);
1573         ++fieldi;
1574     }
1575     if (errors)
1576         return null;
1577
1578     return elements;
1579 }