gcc/d/dmd/initsem.c

   1
   2 /* Compiler implementation of the D programming language
   3  * Copyright (C) 1999-2018 by The D Language Foundation, All Rights Reserved
   4  * written by Walter Bright
   5  * http://www.digitalmars.com
   6  * Distributed under the Boost Software License, Version 1.0.
   7  * http://www.boost.org/LICENSE_1_0.txt
   8  */
   9
  10 #include "root/checkedint.h"
  11 #include "mars.h"
  12 #include "init.h"
  13 #include "expression.h"
  14 #include "statement.h"
  15 #include "declaration.h"
  16 #include "aggregate.h"
  17 #include "scope.h"
  18 #include "mtype.h"
  19 #include "template.h"
  20 #include "id.h"
  21
  22 FuncDeclaration *isFuncAddress(Expression *e, bool *hasOverloads = NULL);
  23 Expression *semantic(Expression *e, Scope *sc);
  24 Initializer *inferType(Initializer *init, Scope *sc);
  25 Initializer *semantic(Initializer *init, Scope *sc, Type *t, NeedInterpret needInterpret);
  26 bool hasNonConstPointers(Expression *e);
  27
  28 class InitializerSemanticVisitor : public Visitor
  29 {
  30 public:
  31     Initializer *result;
  32     Scope *sc;
  33     Type *t;
  34     NeedInterpret needInterpret;
  35
  36     InitializerSemanticVisitor(Scope *sc, Type *t, NeedInterpret needInterpret)
  37     {
  38         this->result = NULL;
  39         this->sc = sc;
  40         this->t = t;
  41         this->needInterpret = needInterpret;
  42     }
  43
  44     void visit(ErrorInitializer *i)
  45     {
  46         //printf("ErrorInitializer::semantic(t = %p)\n", t);
  47         result = i;
  48     }
  49
  50     void visit(VoidInitializer *i)
  51     {
  52         //printf("VoidInitializer::semantic(t = %p)\n", t);
  53         i->type = t;
  54         result = i;
  55     }
  56
  57     void visit(StructInitializer *i)
  58     {
  59         //printf("StructInitializer::semantic(t = %s) %s\n", t->toChars(), toChars());
  60         t = t->toBasetype();
  61         if (t->ty == Tsarray && t->nextOf()->toBasetype()->ty == Tstruct)
  62             t = t->nextOf()->toBasetype();
  63         if (t->ty == Tstruct)
  64         {
  65             StructDeclaration *sd = ((TypeStruct *)t)->sym;
  66             if (sd->ctor)
  67             {
  68                 error(i->loc, "%s %s has constructors, cannot use { initializers }, use %s( initializers ) instead",
  69                       sd->kind(), sd->toChars(), sd->toChars());
  70                 result = new ErrorInitializer();
  71                 return;
  72             }
  73             sd->size(i->loc);
  74             if (sd->sizeok != SIZEOKdone)
  75             {
  76                 result = new ErrorInitializer();
  77                 return;
  78             }
  79             size_t nfields = sd->fields.dim - sd->isNested();
  80
  81             //expandTuples for non-identity arguments?
  82
  83             Expressions *elements = new Expressions();
  84             elements->setDim(nfields);
  85             for (size_t j = 0; j < elements->dim; j++)
  86                 (*elements)[j] = NULL;
  87
  88             // Run semantic for explicitly given initializers
  89             // TODO: this part is slightly different from StructLiteralExp::semantic.
  90             bool errors = false;
  91             for (size_t fieldi = 0, j = 0; j < i->field.dim; j++)
  92             {
  93                 if (Identifier *id = i->field[j])
  94                 {
  95                     Dsymbol *s = sd->search(i->loc, id);
  96                     if (!s)
  97                     {
  98                         s = sd->search_correct(id);
  99                         if (s)
 100                             error(i->loc, "'%s' is not a member of '%s', did you mean %s '%s'?",
 101                                   id->toChars(), sd->toChars(), s->kind(), s->toChars());
 102                         else
 103                             error(i->loc, "'%s' is not a member of '%s'", id->toChars(), sd->toChars());
 104                         result = new ErrorInitializer();
 105                         return;
 106                     }
 107                     s = s->toAlias();
 108
 109                     // Find out which field index it is
 110                     for (fieldi = 0; 1; fieldi++)
 111                     {
 112                         if (fieldi >= nfields)
 113                         {
 114                             error(i->loc, "%s.%s is not a per-instance initializable field",
 115                                   sd->toChars(), s->toChars());
 116                             result = new ErrorInitializer();
 117                             return;
 118                         }
 119                         if (s == sd->fields[fieldi])
 120                             break;
 121                     }
 122                 }
 123                 else if (fieldi >= nfields)
 124                 {
 125                     error(i->loc, "too many initializers for %s", sd->toChars());
 126                     result = new ErrorInitializer();
 127                     return;
 128                 }
 129
 130                 VarDeclaration *vd = sd->fields[fieldi];
 131                 if ((*elements)[fieldi])
 132                 {
 133                     error(i->loc, "duplicate initializer for field '%s'", vd->toChars());
 134                     errors = true;
 135                     continue;
 136                 }
 137                 for (size_t k = 0; k < nfields; k++)
 138                 {
 139                     VarDeclaration *v2 = sd->fields[k];
 140                     if (vd->isOverlappedWith(v2) && (*elements)[k])
 141                     {
 142                         error(i->loc, "overlapping initialization for field %s and %s",
 143                               v2->toChars(), vd->toChars());
 144                         errors = true;
 145                         continue;
 146                     }
 147                 }
 148
 149                 assert(sc);
 150                 Initializer *iz = i->value[j];
 151                 iz = ::semantic(iz, sc, vd->type->addMod(t->mod), needInterpret);
 152                 Expression *ex = initializerToExpression(iz);
 153                 if (ex->op == TOKerror)
 154                 {
 155                     errors = true;
 156                     continue;
 157                 }
 158                 i->value[j] = iz;
 159                 (*elements)[fieldi] = doCopyOrMove(sc, ex);
 160                 ++fieldi;
 161             }
 162             if (errors)
 163             {
 164                 result = new ErrorInitializer();
 165                 return;
 166             }
 167
 168             StructLiteralExp *sle = new StructLiteralExp(i->loc, sd, elements, t);
 169             if (!sd->fill(i->loc, elements, false))
 170             {
 171                 result = new ErrorInitializer();
 172                 return;
 173             }
 174             sle->type = t;
 175
 176             ExpInitializer *ie = new ExpInitializer(i->loc, sle);
 177             result = ::semantic(ie, sc, t, needInterpret);
 178             return;
 179         }
 180         else if ((t->ty == Tdelegate || (t->ty == Tpointer && t->nextOf()->ty == Tfunction)) && i->value.dim == 0)
 181         {
 182             TOK tok = (t->ty == Tdelegate) ? TOKdelegate : TOKfunction;
 183             /* Rewrite as empty delegate literal { }
 184             */
 185             Parameters *parameters = new Parameters;
 186             Type *tf = new TypeFunction(parameters, NULL, 0, LINKd);
 187             FuncLiteralDeclaration *fd = new FuncLiteralDeclaration(i->loc, Loc(), tf, tok, NULL);
 188             fd->fbody = new CompoundStatement(i->loc, new Statements());
 189             fd->endloc = i->loc;
 190             Expression *e = new FuncExp(i->loc, fd);
 191             ExpInitializer *ie = new ExpInitializer(i->loc, e);
 192             result = ::semantic(ie, sc, t, needInterpret);
 193             return;
 194         }
 195
 196         error(i->loc, "a struct is not a valid initializer for a %s", t->toChars());
 197         result = new ErrorInitializer();
 198     }
 199
 200     void visit(ArrayInitializer *i)
 201     {
 202         unsigned length;
 203         const unsigned amax = 0x80000000;
 204         bool errors = false;
 205
 206         //printf("ArrayInitializer::semantic(%s)\n", t->toChars());
 207         if (i->sem)                            // if semantic() already run
 208         {
 209             result = i;
 210             return;
 211         }
 212         i->sem = true;
 213         t = t->toBasetype();
 214         switch (t->ty)
 215         {
 216             case Tsarray:
 217             case Tarray:
 218                 break;
 219
 220             case Tvector:
 221                 t = ((TypeVector *)t)->basetype;
 222                 break;
 223
 224             case Taarray:
 225             case Tstruct:   // consider implicit constructor call
 226                 {
 227                     Expression *e;
 228                     // note: MyStruct foo = [1:2, 3:4] is correct code if MyStruct has a this(int[int])
 229                     if (t->ty == Taarray || i->isAssociativeArray())
 230                         e = i->toAssocArrayLiteral();
 231                     else
 232                         e = initializerToExpression(i);
 233                     if (!e) // Bugzilla 13987
 234                     {
 235                         error(i->loc, "cannot use array to initialize %s", t->toChars());
 236                         goto Lerr;
 237                     }
 238                     ExpInitializer *ei = new ExpInitializer(e->loc, e);
 239                     result = ::semantic(ei, sc, t, needInterpret);
 240                     return;
 241                 }
 242             case Tpointer:
 243                 if (t->nextOf()->ty != Tfunction)
 244                     break;
 245                 /* fall through */
 246
 247             default:
 248                 error(i->loc, "cannot use array to initialize %s", t->toChars());
 249                 goto Lerr;
 250         }
 251
 252         i->type = t;
 253
 254         length = 0;
 255         for (size_t j = 0; j < i->index.dim; j++)
 256         {
 257             Expression *idx = i->index[j];
 258             if (idx)
 259             {
 260                 sc = sc->startCTFE();
 261                 idx = ::semantic(idx, sc);
 262                 sc = sc->endCTFE();
 263                 idx = idx->ctfeInterpret();
 264                 i->index[j] = idx;
 265                 const uinteger_t idxvalue = idx->toInteger();
 266                 if (idxvalue >= amax)
 267                 {
 268                     error(i->loc, "array index %llu overflow", (ulonglong)idxvalue);
 269                     errors = true;
 270                 }
 271                 length = (unsigned)idx->toInteger();
 272                 if (idx->op == TOKerror)
 273                     errors = true;
 274             }
 275
 276             Initializer *val = i->value[j];
 277             ExpInitializer *ei = val->isExpInitializer();
 278             if (ei && !idx)
 279                 ei->expandTuples = true;
 280             val = ::semantic(val, sc, t->nextOf(), needInterpret);
 281             if (val->isErrorInitializer())
 282                 errors = true;
 283
 284             ei = val->isExpInitializer();
 285             // found a tuple, expand it
 286             if (ei && ei->exp->op == TOKtuple)
 287             {
 288                 TupleExp *te = (TupleExp *)ei->exp;
 289                 i->index.remove(j);
 290                 i->value.remove(j);
 291
 292                 for (size_t k = 0; k < te->exps->dim; ++k)
 293                 {
 294                     Expression *e = (*te->exps)[k];
 295                     i->index.insert(j + k, (Expression *)NULL);
 296                     i->value.insert(j + k, new ExpInitializer(e->loc, e));
 297                 }
 298                 j--;
 299                 continue;
 300             }
 301             else
 302             {
 303                 i->value[j] = val;
 304             }
 305
 306             length++;
 307             if (length == 0)
 308             {
 309                 error(i->loc, "array dimension overflow");
 310                 goto Lerr;
 311             }
 312             if (length > i->dim)
 313                 i->dim = length;
 314         }
 315         if (t->ty == Tsarray)
 316         {
 317             uinteger_t edim = ((TypeSArray *)t)->dim->toInteger();
 318             if (i->dim > edim)
 319             {
 320                 error(i->loc, "array initializer has %u elements, but array length is %llu", i->dim, (ulonglong)edim);
 321                 goto Lerr;
 322             }
 323         }
 324         if (errors)
 325             goto Lerr;
 326         else
 327         {
 328             d_uns64 sz = t->nextOf()->size();
 329             bool overflow = false;
 330             const d_uns64 max = mulu((d_uns64)i->dim, sz, overflow);
 331             if (overflow || max > amax)
 332             {
 333                 error(i->loc, "array dimension %llu exceeds max of %llu", (ulonglong)i->dim, (ulonglong)(amax / sz));
 334                 goto Lerr;
 335             }
 336             result = i;
 337             return;
 338         }
 339
 340     Lerr:
 341         result = new ErrorInitializer();
 342     }
 343
 344     void visit(ExpInitializer *i)
 345     {
 346         //printf("ExpInitializer::semantic(%s), type = %s\n", i->exp->toChars(), t->toChars());
 347         if (needInterpret) sc = sc->startCTFE();
 348         i->exp = ::semantic(i->exp, sc);
 349         i->exp = resolveProperties(sc, i->exp);
 350         if (needInterpret) sc = sc->endCTFE();
 351         if (i->exp->op == TOKerror)
 352         {
 353             result = new ErrorInitializer();
 354             return;
 355         }
 356
 357         unsigned int olderrors = global.errors;
 358         if (needInterpret)
 359         {
 360             // If the result will be implicitly cast, move the cast into CTFE
 361             // to avoid premature truncation of polysemous types.
 362             // eg real [] x = [1.1, 2.2]; should use real precision.
 363             if (i->exp->implicitConvTo(t))
 364             {
 365                 i->exp = i->exp->implicitCastTo(sc, t);
 366             }
 367             if (!global.gag && olderrors != global.errors)
 368             {
 369                 result = i;
 370                 return;
 371             }
 372             i->exp = i->exp->ctfeInterpret();
 373         }
 374         else
 375         {
 376             i->exp = i->exp->optimize(WANTvalue);
 377         }
 378         if (!global.gag && olderrors != global.errors)
 379         {
 380             result = i; // Failed, suppress duplicate error messages
 381             return;
 382         }
 383
 384         if (i->exp->type->ty == Ttuple && ((TypeTuple *)i->exp->type)->arguments->dim == 0)
 385         {
 386             Type *et = i->exp->type;
 387             i->exp = new TupleExp(i->exp->loc, new Expressions());
 388             i->exp->type = et;
 389         }
 390         if (i->exp->op == TOKtype)
 391         {
 392             i->exp->error("initializer must be an expression, not '%s'", i->exp->toChars());
 393             result = new ErrorInitializer();
 394             return;
 395         }
 396
 397         // Make sure all pointers are constants
 398         if (needInterpret && hasNonConstPointers(i->exp))
 399         {
 400             i->exp->error("cannot use non-constant CTFE pointer in an initializer '%s'", i->exp->toChars());
 401             result = new ErrorInitializer();
 402             return;
 403         }
 404
 405         Type *tb = t->toBasetype();
 406         Type *ti = i->exp->type->toBasetype();
 407
 408         if (i->exp->op == TOKtuple && i->expandTuples && !i->exp->implicitConvTo(t))
 409         {
 410             result = new ExpInitializer(i->loc, i->exp);
 411             return;
 412         }
 413
 414         /* Look for case of initializing a static array with a too-short
 415          * string literal, such as:
 416          *  char[5] foo = "abc";
 417          * Allow this by doing an explicit cast, which will lengthen the string
 418          * literal.
 419          */
 420         if (i->exp->op == TOKstring && tb->ty == Tsarray)
 421         {
 422             StringExp *se = (StringExp *)i->exp;
 423             Type *typeb = se->type->toBasetype();
 424             TY tynto = tb->nextOf()->ty;
 425             if (!se->committed &&
 426                 (typeb->ty == Tarray || typeb->ty == Tsarray) &&
 427                 (tynto == Tchar || tynto == Twchar || tynto == Tdchar) &&
 428                 se->numberOfCodeUnits(tynto) < ((TypeSArray *)tb)->dim->toInteger())
 429             {
 430                 i->exp = se->castTo(sc, t);
 431                 goto L1;
 432             }
 433         }
 434
 435         // Look for implicit constructor call
 436         if (tb->ty == Tstruct &&
 437             !(ti->ty == Tstruct && tb->toDsymbol(sc) == ti->toDsymbol(sc)) &&
 438             !i->exp->implicitConvTo(t))
 439         {
 440             StructDeclaration *sd = ((TypeStruct *)tb)->sym;
 441             if (sd->ctor)
 442             {
 443                 // Rewrite as S().ctor(exp)
 444                 Expression *e;
 445                 e = new StructLiteralExp(i->loc, sd, NULL);
 446                 e = new DotIdExp(i->loc, e, Id::ctor);
 447                 e = new CallExp(i->loc, e, i->exp);
 448                 e = ::semantic(e, sc);
 449                 if (needInterpret)
 450                     i->exp = e->ctfeInterpret();
 451                 else
 452                     i->exp = e->optimize(WANTvalue);
 453             }
 454         }
 455
 456         // Look for the case of statically initializing an array
 457         // with a single member.
 458         if (tb->ty == Tsarray &&
 459             !tb->nextOf()->equals(ti->toBasetype()->nextOf()) &&
 460             i->exp->implicitConvTo(tb->nextOf())
 461            )
 462         {
 463             /* If the variable is not actually used in compile time, array creation is
 464              * redundant. So delay it until invocation of toExpression() or toDt().
 465              */
 466             t = tb->nextOf();
 467         }
 468
 469         if (i->exp->implicitConvTo(t))
 470         {
 471             i->exp = i->exp->implicitCastTo(sc, t);
 472         }
 473         else
 474         {
 475             // Look for mismatch of compile-time known length to emit
 476             // better diagnostic message, as same as AssignExp::semantic.
 477             if (tb->ty == Tsarray &&
 478                 i->exp->implicitConvTo(tb->nextOf()->arrayOf()) > MATCHnomatch)
 479             {
 480                 uinteger_t dim1 = ((TypeSArray *)tb)->dim->toInteger();
 481                 uinteger_t dim2 = dim1;
 482                 if (i->exp->op == TOKarrayliteral)
 483                 {
 484                     ArrayLiteralExp *ale = (ArrayLiteralExp *)i->exp;
 485                     dim2 = ale->elements ? ale->elements->dim : 0;
 486                 }
 487                 else if (i->exp->op == TOKslice)
 488                 {
 489                     Type *tx = toStaticArrayType((SliceExp *)i->exp);
 490                     if (tx)
 491                         dim2 = ((TypeSArray *)tx)->dim->toInteger();
 492                 }
 493                 if (dim1 != dim2)
 494                 {
 495                     i->exp->error("mismatched array lengths, %d and %d", (int)dim1, (int)dim2);
 496                     i->exp = new ErrorExp();
 497                 }
 498             }
 499             i->exp = i->exp->implicitCastTo(sc, t);
 500         }
 501     L1:
 502         if (i->exp->op == TOKerror)
 503         {
 504             result = i;
 505             return;
 506         }
 507         if (needInterpret)
 508             i->exp = i->exp->ctfeInterpret();
 509         else
 510             i->exp = i->exp->optimize(WANTvalue);
 511         //printf("-ExpInitializer::semantic(): "); i->exp->print();
 512         result = i;
 513     }
 514 };
 515
 516 // Performs semantic analisys on Initializer AST nodes
 517 Initializer *semantic(Initializer *init, Scope *sc, Type *t, NeedInterpret needInterpret)
 518 {
 519     InitializerSemanticVisitor v = InitializerSemanticVisitor(sc, t, needInterpret);
 520     init->accept(&v);
 521     return v.result;
 522 }
 523
 524 class InferTypeVisitor : public Visitor
 525 {
 526 public:
 527     Initializer *result;
 528     Scope *sc;
 529
 530     InferTypeVisitor(Scope *sc)
 531     {
 532         this->result = NULL;
 533         this->sc = sc;
 534     }
 535
 536     void visit(ErrorInitializer *i)
 537     {
 538         result = i;
 539     }
 540
 541     void visit(VoidInitializer *i)
 542     {
 543         error(i->loc, "cannot infer type from void initializer");
 544         result = new ErrorInitializer();
 545     }
 546
 547     void visit(StructInitializer *i)
 548     {
 549         error(i->loc, "cannot infer type from struct initializer");
 550         result = new ErrorInitializer();
 551     }
 552
 553     void visit(ArrayInitializer *init)
 554     {
 555         //printf("ArrayInitializer::inferType() %s\n", init->toChars());
 556         Expressions *keys = NULL;
 557         Expressions *values;
 558         if (init->isAssociativeArray())
 559         {
 560             keys = new Expressions();
 561             keys->setDim(init->value.dim);
 562             values = new Expressions();
 563             values->setDim(init->value.dim);
 564
 565             for (size_t i = 0; i < init->value.dim; i++)
 566             {
 567                 Expression *e = init->index[i];
 568                 if (!e)
 569                     goto Lno;
 570                 (*keys)[i] = e;
 571
 572                 Initializer *iz = init->value[i];
 573                 if (!iz)
 574                     goto Lno;
 575                 iz = inferType(iz, sc);
 576                 if (iz->isErrorInitializer())
 577                 {
 578                     result = iz;
 579                     return;
 580                 }
 581                 assert(iz->isExpInitializer());
 582                 (*values)[i] = ((ExpInitializer *)iz)->exp;
 583                 assert((*values)[i]->op != TOKerror);
 584             }
 585
 586             Expression *e = new AssocArrayLiteralExp(init->loc, keys, values);
 587             ExpInitializer *ei = new ExpInitializer(init->loc, e);
 588             result = inferType(ei, sc);
 589             return;
 590         }
 591         else
 592         {
 593             Expressions *elements = new Expressions();
 594             elements->setDim(init->value.dim);
 595             elements->zero();
 596
 597             for (size_t i = 0; i < init->value.dim; i++)
 598             {
 599                 assert(!init->index[i]);  // already asserted by isAssociativeArray()
 600
 601                 Initializer *iz = init->value[i];
 602                 if (!iz)
 603                     goto Lno;
 604                 iz = inferType(iz, sc);
 605                 if (iz->isErrorInitializer())
 606                 {
 607                     result = iz;
 608                     return;
 609                 }
 610                 assert(iz->isExpInitializer());
 611                 (*elements)[i] = ((ExpInitializer *)iz)->exp;
 612                 assert((*elements)[i]->op != TOKerror);
 613             }
 614
 615             Expression *e = new ArrayLiteralExp(init->loc, elements);
 616             ExpInitializer *ei = new ExpInitializer(init->loc, e);
 617             result = inferType(ei, sc);
 618             return;
 619         }
 620     Lno:
 621         if (keys)
 622         {
 623             delete keys;
 624             delete values;
 625             error(init->loc, "not an associative array initializer");
 626         }
 627         else
 628         {
 629             error(init->loc, "cannot infer type from array initializer");
 630         }
 631         result = new ErrorInitializer();
 632     }
 633
 634     void visit(ExpInitializer *init)
 635     {
 636         //printf("ExpInitializer::inferType() %s\n", init->toChars());
 637         init->exp = ::semantic(init->exp, sc);
 638         init->exp = resolveProperties(sc, init->exp);
 639
 640         if (init->exp->op == TOKscope)
 641         {
 642             ScopeExp *se = (ScopeExp *)init->exp;
 643             TemplateInstance *ti = se->sds->isTemplateInstance();
 644             if (ti && ti->semanticRun == PASSsemantic && !ti->aliasdecl)
 645                 se->error("cannot infer type from %s %s, possible circular dependency", se->sds->kind(), se->toChars());
 646             else
 647                 se->error("cannot infer type from %s %s", se->sds->kind(), se->toChars());
 648             result = new ErrorInitializer();
 649             return;
 650         }
 651
 652         // Give error for overloaded function addresses
 653         bool hasOverloads = false;
 654         if (FuncDeclaration *f = isFuncAddress(init->exp, &hasOverloads))
 655         {
 656             if (f->checkForwardRef(init->loc))
 657             {
 658                 result = new ErrorInitializer();
 659                 return;
 660             }
 661
 662             if (hasOverloads && !f->isUnique())
 663             {
 664                 init->exp->error("cannot infer type from overloaded function symbol %s", init->exp->toChars());
 665                 result = new ErrorInitializer();
 666                 return;
 667             }
 668         }
 669         if (init->exp->op == TOKaddress)
 670         {
 671             AddrExp *ae = (AddrExp *)init->exp;
 672             if (ae->e1->op == TOKoverloadset)
 673             {
 674                 init->exp->error("cannot infer type from overloaded function symbol %s", init->exp->toChars());
 675                 result = new ErrorInitializer();
 676                 return;
 677             }
 678         }
 679
 680         if (init->exp->op == TOKerror)
 681         {
 682             result = new ErrorInitializer();
 683             return;
 684         }
 685         if (!init->exp->type)
 686         {
 687             result = new ErrorInitializer();
 688             return;
 689         }
 690         result = init;
 691     }
 692 };
 693
 694 /* Translates to an expression to infer type.
 695  * Returns ExpInitializer or ErrorInitializer.
 696  */
 697 Initializer *inferType(Initializer *init, Scope *sc)
 698 {
 699     InferTypeVisitor v = InferTypeVisitor(sc);
 700     init->accept(&v);
 701     return v.result;
 702 }
 703
 704 class InitToExpressionVisitor : public Visitor
 705 {
 706 public:
 707     Expression *result;
 708     Type *itype;
 709
 710     InitToExpressionVisitor(Type *itype)
 711     {
 712         this->result = NULL;
 713         this->itype = itype;
 714     }
 715
 716     void visit(ErrorInitializer *)
 717     {
 718         result = new ErrorExp();
 719     }
 720
 721     void visit(VoidInitializer *)
 722     {
 723         result = NULL;
 724     }
 725
 726     /***************************************
 727      * This works by transforming a struct initializer into
 728      * a struct literal. In the future, the two should be the
 729      * same thing.
 730      */
 731     void visit(StructInitializer *)
 732     {
 733         // cannot convert to an expression without target 'ad'
 734         result = NULL;
 735     }
 736
 737     /********************************
 738      * If possible, convert array initializer to array literal.
 739      * Otherwise return NULL.
 740      */
 741
 742     void visit(ArrayInitializer *init)
 743     {
 744         //printf("ArrayInitializer::toExpression(), dim = %d\n", init->dim);
 745         //static int i; if (++i == 2) halt();
 746
 747         Expressions *elements;
 748         unsigned edim;
 749         const unsigned amax = 0x80000000;
 750         Type *t = NULL;
 751         if (init->type)
 752         {
 753             if (init->type == Type::terror)
 754             {
 755                 result = new ErrorExp();
 756                 return;
 757             }
 758
 759             t = init->type->toBasetype();
 760             switch (t->ty)
 761             {
 762                 case Tvector:
 763                     t = ((TypeVector *)t)->basetype;
 764                     /* fall through */
 765
 766                 case Tsarray:
 767                     {
 768                         uinteger_t adim = ((TypeSArray *)t)->dim->toInteger();
 769                         if (adim >= amax)
 770                             goto Lno;
 771                         edim = (unsigned)adim;
 772                         break;
 773                     }
 774
 775                 case Tpointer:
 776                 case Tarray:
 777                     edim = init->dim;
 778                     break;
 779
 780                 default:
 781                     assert(0);
 782             }
 783         }
 784         else
 785         {
 786             edim = (unsigned)init->value.dim;
 787             for (size_t i = 0, j = 0; i < init->value.dim; i++, j++)
 788             {
 789                 if (init->index[i])
 790                 {
 791                     if (init->index[i]->op == TOKint64)
 792                     {
 793                         const uinteger_t idxval = init->index[i]->toInteger();
 794                         if (idxval >= amax)
 795                             goto Lno;
 796                         j = (size_t)idxval;
 797                     }
 798                     else
 799                         goto Lno;
 800                 }
 801                 if (j >= edim)
 802                     edim = (unsigned)(j + 1);
 803             }
 804         }
 805
 806         elements = new Expressions();
 807         elements->setDim(edim);
 808         elements->zero();
 809         for (size_t i = 0, j = 0; i < init->value.dim; i++, j++)
 810         {
 811             if (init->index[i])
 812                 j = (size_t)(init->index[i])->toInteger();
 813             assert(j < edim);
 814             Initializer *iz = init->value[i];
 815             if (!iz)
 816                 goto Lno;
 817             Expression *ex = initializerToExpression(iz);
 818             if (!ex)
 819             {
 820                 goto Lno;
 821             }
 822             (*elements)[j] = ex;
 823         }
 824
 825         /* Fill in any missing elements with the default initializer
 826          */
 827         {
 828             Expression *_init = NULL;
 829             for (size_t i = 0; i < edim; i++)
 830             {
 831                 if (!(*elements)[i])
 832                 {
 833                     if (!init->type)
 834                         goto Lno;
 835                     if (!_init)
 836                         _init = ((TypeNext *)t)->next->defaultInit();
 837                     (*elements)[i] = _init;
 838                 }
 839             }
 840
 841             /* Expand any static array initializers that are a single expression
 842              * into an array of them
 843              */
 844             if (t)
 845             {
 846                 Type *tn = t->nextOf()->toBasetype();
 847                 if (tn->ty == Tsarray)
 848                 {
 849                     size_t dim = ((TypeSArray *)tn)->dim->toInteger();
 850                     Type *te = tn->nextOf()->toBasetype();
 851                     for (size_t i = 0; i < elements->dim; i++)
 852                     {
 853                         Expression *e = (*elements)[i];
 854                         if (te->equals(e->type))
 855                         {
 856                             Expressions *elements2 = new Expressions();
 857                             elements2->setDim(dim);
 858                             for (size_t j = 0; j < dim; j++)
 859                                 (*elements2)[j] = e;
 860                             e = new ArrayLiteralExp(e->loc, elements2);
 861                             e->type = tn;
 862                             (*elements)[i] = e;
 863                         }
 864                     }
 865                 }
 866             }
 867
 868             /* If any elements are errors, then the whole thing is an error
 869              */
 870             for (size_t i = 0; i < edim; i++)
 871             {
 872                 Expression *e = (*elements)[i];
 873                 if (e->op == TOKerror)
 874                 {
 875                     result = e;
 876                     return;
 877                 }
 878             }
 879
 880             Expression *e = new ArrayLiteralExp(init->loc, elements);
 881             e->type = init->type;
 882             result = e;
 883             return;
 884         }
 885
 886     Lno:
 887         result = NULL;
 888     }
 889
 890     void visit(ExpInitializer *i)
 891     {
 892         if (itype)
 893         {
 894             //printf("ExpInitializer::toExpression(t = %s) exp = %s\n", itype->toChars(), i->exp->toChars());
 895             Type *tb = itype->toBasetype();
 896             Expression *e = (i->exp->op == TOKconstruct || i->exp->op == TOKblit) ? ((AssignExp *)i->exp)->e2 : i->exp;
 897             if (tb->ty == Tsarray && e->implicitConvTo(tb->nextOf()))
 898             {
 899                 TypeSArray *tsa = (TypeSArray *)tb;
 900                 size_t d = (size_t)tsa->dim->toInteger();
 901                 Expressions *elements = new Expressions();
 902                 elements->setDim(d);
 903                 for (size_t i = 0; i < d; i++)
 904                     (*elements)[i] = e;
 905                 ArrayLiteralExp *ae = new ArrayLiteralExp(e->loc, elements);
 906                 ae->type = itype;
 907                 result = ae;
 908                 return;
 909             }
 910         }
 911         result = i->exp;
 912     }
 913 };
 914
 915 Expression *initializerToExpression(Initializer *i, Type *t)
 916 {
 917     InitToExpressionVisitor v = InitToExpressionVisitor(t);
 918     i->accept(&v);
 919     return v.result;
 920 }