gcc/d/dmd/init.d

   1 /**
   2  * Defines initializers of variables, e.g. the array literal in `int[3] x = [0, 1, 2]`.
   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/init.d, _init.d)
   8  * Documentation:  https://dlang.org/phobos/dmd_init.html
   9  * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/init.d
  10  */
  11
  12 module dmd.init;
  13
  14 import core.stdc.stdio;
  15 import core.checkedint;
  16
  17 import dmd.arraytypes;
  18 import dmd.astenums;
  19 import dmd.ast_node;
  20 import dmd.dsymbol;
  21 import dmd.expression;
  22 import dmd.globals;
  23 import dmd.hdrgen;
  24 import dmd.identifier;
  25 import dmd.location;
  26 import dmd.mtype;
  27 import dmd.common.outbuffer;
  28 import dmd.rootobject;
  29 import dmd.tokens;
  30 import dmd.visitor;
  31
  32 enum NeedInterpret : int
  33 {
  34     INITnointerpret,
  35     INITinterpret,
  36 }
  37
  38 alias INITnointerpret = NeedInterpret.INITnointerpret;
  39 alias INITinterpret = NeedInterpret.INITinterpret;
  40
  41 /***********************************************************
  42  */
  43 extern (C++) class Initializer : ASTNode
  44 {
  45     Loc loc;
  46     InitKind kind;
  47
  48     override DYNCAST dyncast() const
  49     {
  50         return DYNCAST.initializer;
  51     }
  52
  53
  54     extern (D) this(const ref Loc loc, InitKind kind) @safe
  55     {
  56         this.loc = loc;
  57         this.kind = kind;
  58     }
  59
  60     final inout(ErrorInitializer) isErrorInitializer() inout @nogc nothrow pure
  61     {
  62         // Use void* cast to skip dynamic casting call
  63         return kind == InitKind.error ? cast(inout ErrorInitializer)cast(void*)this : null;
  64     }
  65
  66     final inout(VoidInitializer) isVoidInitializer() inout @nogc nothrow pure
  67     {
  68         return kind == InitKind.void_ ? cast(inout VoidInitializer)cast(void*)this : null;
  69     }
  70
  71     final inout(DefaultInitializer) isDefaultInitializer() inout @nogc nothrow pure
  72     {
  73         return kind == InitKind.default_ ? cast(inout DefaultInitializer)cast(void*)this : null;
  74     }
  75
  76     final inout(StructInitializer) isStructInitializer() inout @nogc nothrow pure
  77     {
  78         return kind == InitKind.struct_ ? cast(inout StructInitializer)cast(void*)this : null;
  79     }
  80
  81     final inout(ArrayInitializer) isArrayInitializer() inout @nogc nothrow pure
  82     {
  83         return kind == InitKind.array ? cast(inout ArrayInitializer)cast(void*)this : null;
  84     }
  85
  86     final inout(ExpInitializer) isExpInitializer() inout @nogc nothrow pure
  87     {
  88         return kind == InitKind.exp ? cast(inout ExpInitializer)cast(void*)this : null;
  89     }
  90
  91     final inout(CInitializer) isCInitializer() inout @nogc nothrow pure
  92     {
  93         return kind == InitKind.C_ ? cast(inout CInitializer)cast(void*)this : null;
  94     }
  95
  96     override void accept(Visitor v)
  97     {
  98         v.visit(this);
  99     }
 100 }
 101
 102 /***********************************************************
 103  */
 104 extern (C++) final class VoidInitializer : Initializer
 105 {
 106     Type type;      // type that this will initialize to
 107
 108     extern (D) this(const ref Loc loc) @safe
 109     {
 110         super(loc, InitKind.void_);
 111     }
 112
 113     override void accept(Visitor v)
 114     {
 115         v.visit(this);
 116     }
 117 }
 118
 119 /***********************************************************
 120  * The C23 default initializer `{ }`
 121  */
 122 extern (C++) final class DefaultInitializer : Initializer
 123 {
 124     Type type;      // type that this will initialize to
 125
 126     extern (D) this(const ref Loc loc) @safe
 127     {
 128         super(loc, InitKind.default_);
 129     }
 130
 131     override void accept(Visitor v)
 132     {
 133         v.visit(this);
 134     }
 135 }
 136
 137 /***********************************************************
 138  */
 139 extern (C++) final class ErrorInitializer : Initializer
 140 {
 141     extern (D) this() @safe
 142     {
 143         super(Loc.initial, InitKind.error);
 144     }
 145
 146     override void accept(Visitor v)
 147     {
 148         v.visit(this);
 149     }
 150 }
 151
 152 /***********************************************************
 153  */
 154 extern (C++) final class StructInitializer : Initializer
 155 {
 156     Identifiers field;      // of Identifier *'s
 157     Initializers value;     // parallel array of Initializer *'s
 158
 159     extern (D) this(const ref Loc loc)
 160     {
 161         super(loc, InitKind.struct_);
 162     }
 163
 164     extern (D) void addInit(Identifier field, Initializer value)
 165     {
 166         //printf("StructInitializer::addInit(field = %p, value = %p)\n", field, value);
 167         this.field.push(field);
 168         this.value.push(value);
 169     }
 170
 171     override void accept(Visitor v)
 172     {
 173         v.visit(this);
 174     }
 175 }
 176
 177 /***********************************************************
 178  */
 179 extern (C++) final class ArrayInitializer : Initializer
 180 {
 181     Expressions index;      // indices
 182     Initializers value;     // of Initializer *'s
 183     uint dim;               // length of array being initialized
 184     Type type;              // type that array will be used to initialize
 185     bool sem;               // true if semantic() is run
 186     bool isCarray;          // C array semantics
 187
 188     extern (D) this(const ref Loc loc)
 189     {
 190         super(loc, InitKind.array);
 191     }
 192
 193     extern (D) void addInit(Expression index, Initializer value)
 194     {
 195         this.index.push(index);
 196         this.value.push(value);
 197         dim = 0;
 198         type = null;
 199     }
 200
 201     bool isAssociativeArray() const pure
 202     {
 203         foreach (idx; index)
 204         {
 205             if (idx)
 206                 return true;
 207         }
 208         return false;
 209     }
 210
 211     override void accept(Visitor v)
 212     {
 213         v.visit(this);
 214     }
 215 }
 216
 217 /***********************************************************
 218  */
 219 extern (C++) final class ExpInitializer : Initializer
 220 {
 221     bool expandTuples;
 222     Expression exp;
 223
 224     extern (D) this(const ref Loc loc, Expression exp) @safe
 225     {
 226         super(loc, InitKind.exp);
 227         this.exp = exp;
 228     }
 229
 230     override void accept(Visitor v)
 231     {
 232         v.visit(this);
 233     }
 234 }
 235
 236 /*********************************************
 237  * Holds the `designator` for C initializers
 238  */
 239 struct Designator
 240 {
 241     Expression exp;     /// [ constant-expression ]
 242     Identifier ident;   /// . identifier
 243
 244     this(Expression exp) @safe { this.exp = exp; }
 245     this(Identifier ident) @safe  { this.ident = ident; }
 246 }
 247
 248 /*********************************************
 249  * Holds the `designation (opt) initializer` for C initializers
 250  */
 251 struct DesigInit
 252 {
 253     Designators* designatorList; /// designation (opt)
 254     Initializer initializer;     /// initializer
 255 }
 256
 257 /********************************
 258  * C11 6.7.9 Initialization
 259  * Represents the C initializer-list
 260  */
 261 extern (C++) final class CInitializer : Initializer
 262 {
 263     DesigInits initializerList; /// initializer-list
 264     Type type;              /// type that array will be used to initialize
 265     bool sem;               /// true if semantic() is run
 266
 267     extern (D) this(const ref Loc loc)
 268     {
 269         super(loc, InitKind.C_);
 270     }
 271
 272     override void accept(Visitor v)
 273     {
 274         v.visit(this);
 275     }
 276 }
 277
 278 /****************************************
 279  * Copy the AST for Initializer.
 280  * Params:
 281  *      inx = Initializer AST to copy
 282  * Returns:
 283  *      the copy
 284  */
 285 Initializer syntaxCopy(Initializer inx)
 286 {
 287     static Initializer visitVoid(VoidInitializer vi)
 288     {
 289         return new VoidInitializer(vi.loc);
 290     }
 291
 292     static Initializer visitDefault(DefaultInitializer vi)
 293     {
 294         return new DefaultInitializer(vi.loc);
 295     }
 296
 297     static Initializer visitError(ErrorInitializer vi)
 298     {
 299         return vi;
 300     }
 301
 302     static Initializer visitExp(ExpInitializer vi)
 303     {
 304         return new ExpInitializer(vi.loc, vi.exp.syntaxCopy());
 305     }
 306
 307     static Initializer visitStruct(StructInitializer vi)
 308     {
 309         auto si = new StructInitializer(vi.loc);
 310         assert(vi.field.length == vi.value.length);
 311         si.field.setDim(vi.field.length);
 312         si.value.setDim(vi.value.length);
 313         foreach (const i; 0 .. vi.field.length)
 314         {
 315             si.field[i] = vi.field[i];
 316             si.value[i] = vi.value[i].syntaxCopy();
 317         }
 318         return si;
 319     }
 320
 321     static Initializer visitArray(ArrayInitializer vi)
 322     {
 323         auto ai = new ArrayInitializer(vi.loc);
 324         assert(vi.index.length == vi.value.length);
 325         ai.index.setDim(vi.index.length);
 326         ai.value.setDim(vi.value.length);
 327         foreach (const i; 0 .. vi.value.length)
 328         {
 329             ai.index[i] = vi.index[i] ? vi.index[i].syntaxCopy() : null;
 330             ai.value[i] = vi.value[i].syntaxCopy();
 331         }
 332         return ai;
 333     }
 334
 335     static Initializer visitC(CInitializer vi)
 336     {
 337         auto ci = new CInitializer(vi.loc);
 338         ci.initializerList.setDim(vi.initializerList.length);
 339         foreach (const i; 0 .. vi.initializerList.length)
 340         {
 341             DesigInit* cdi = &ci.initializerList[i];
 342             DesigInit* vdi = &ci.initializerList[i];
 343             cdi.initializer = vdi.initializer.syntaxCopy();
 344             if (vdi.designatorList)
 345             {
 346                 cdi.designatorList = new Designators();
 347                 cdi.designatorList.setDim(vdi.designatorList.length);
 348                 foreach (const j; 0 .. vdi.designatorList.length)
 349                 {
 350                     Designator* cdid = &(*cdi.designatorList)[j];
 351                     Designator* vdid = &(*vdi.designatorList)[j];
 352                     cdid.exp = vdid.exp ? vdid.exp.syntaxCopy() : null;
 353                     cdid.ident = vdid.ident;
 354                 }
 355             }
 356         }
 357         return ci;
 358     }
 359
 360     mixin VisitInitializer!Initializer visit;
 361     return visit.VisitInitializer(inx);
 362 }
 363
 364 /***********************************************************
 365  * Visit each Initializer in init. Call a function visit%s(init) for
 366  * each node, where %s is the op of the node. Otherwise call visitDefault(init)
 367  * for that node. If the visit function returns R.init, continue
 368  * visiting each node, otherwise return the value of R.
 369  * Params:
 370  *      Result = return type
 371  *      init = Initializer tree to traverse
 372  * Returns:
 373  *      Result.init for continue, value of type Result for early exit
 374  */
 375
 376 mixin template VisitInitializer(Result)
 377 {
 378     Result VisitInitializer(Initializer init)
 379     {
 380         final switch (init.kind)
 381         {
 382             case InitKind.void_:    mixin(visitCase("Void"));    break;
 383             case InitKind.default_: mixin(visitCase("Default")); break;
 384             case InitKind.error:    mixin(visitCase("Error"));   break;
 385             case InitKind.struct_:  mixin(visitCase("Struct"));  break;
 386             case InitKind.array:    mixin(visitCase("Array"));   break;
 387             case InitKind.exp:      mixin(visitCase("Exp"));     break;
 388             case InitKind.C_:       mixin(visitCase("C"));       break;
 389         }
 390         static if (is(Result == void)) { } else
 391             return Result.init;
 392     }
 393 }
 394
 395 /****************************************
 396  * CTFE-only helper function for VisitInitializer.
 397  * Params:
 398  *      handler = string for the name of the visit handler
 399  * Returns: boilerplate code for a case
 400  */
 401 string visitCase(string handler) pure @safe
 402 {
 403     if (__ctfe)
 404     {
 405         return
 406             "
 407             auto ix = init.is"~handler~"Initializer();
 408             static if (is(Result == void))
 409                 visit"~handler~"(ix);
 410             else
 411             {
 412                 Result r = visit"~handler~"(ix);
 413                 if (r !is Result.init)
 414                     return r;
 415             }
 416             ";
 417     }
 418     assert(0);
 419 }