gcc/d/dmd/expression.h

   1
   2 /* Compiler implementation of the D programming language
   3  * Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved
   4  * written by Walter Bright
   5  * https://www.digitalmars.com
   6  * Distributed under the Boost Software License, Version 1.0.
   7  * https://www.boost.org/LICENSE_1_0.txt
   8  * https://github.com/dlang/dmd/blob/master/src/dmd/expression.h
   9  */
  10
  11 #pragma once
  12
  13 #include "ast_node.h"
  14 #include "globals.h"
  15 #include "arraytypes.h"
  16 #include "visitor.h"
  17 #include "tokens.h"
  18
  19 #include "root/complex_t.h"
  20 #include "root/dcompat.h"
  21 #include "root/optional.h"
  22
  23 class Type;
  24 class TypeVector;
  25 struct Scope;
  26 class TupleDeclaration;
  27 class VarDeclaration;
  28 class FuncDeclaration;
  29 class FuncLiteralDeclaration;
  30 class CtorDeclaration;
  31 class Dsymbol;
  32 class ScopeDsymbol;
  33 class Expression;
  34 class Declaration;
  35 class StructDeclaration;
  36 class TemplateInstance;
  37 class TemplateDeclaration;
  38 class ClassDeclaration;
  39 class OverloadSet;
  40 class StringExp;
  41 class LoweredAssignExp;
  42 struct UnionExp;
  43 #ifdef IN_GCC
  44 typedef union tree_node Symbol;
  45 #else
  46 struct Symbol;          // back end symbol
  47 #endif
  48
  49 void expandTuples(Expressions *exps, Identifiers *names = nullptr);
  50 bool isTrivialExp(Expression *e);
  51 bool hasSideEffect(Expression *e, bool assumeImpureCalls = false);
  52
  53 enum BE : int32_t;
  54 BE canThrow(Expression *e, FuncDeclaration *func, ErrorSink *eSink);
  55
  56 typedef unsigned char OwnedBy;
  57 enum
  58 {
  59     OWNEDcode,      // normal code expression in AST
  60     OWNEDctfe,      // value expression for CTFE
  61     OWNEDcache      // constant value cached for CTFE
  62 };
  63
  64 #define WANTvalue  0 // default
  65 #define WANTexpand 1 // expand const/immutable variables if possible
  66
  67 /**
  68  * Specifies how the checkModify deals with certain situations
  69  */
  70 enum class ModifyFlags
  71 {
  72     /// Issue error messages on invalid modifications of the variable
  73     none,
  74     /// No errors are emitted for invalid modifications
  75     noError = 0x1,
  76     /// The modification occurs for a subfield of the current variable
  77     fieldAssign = 0x2,
  78 };
  79
  80 class Expression : public ASTNode
  81 {
  82 public:
  83     Type *type;                 // !=NULL means that semantic() has been run
  84     Loc loc;                    // file location
  85     EXP op;                     // to minimize use of dynamic_cast
  86
  87     size_t size() const;
  88     static void _init();
  89     Expression *copy();
  90     virtual Expression *syntaxCopy();
  91
  92     // kludge for template.isExpression()
  93     DYNCAST dyncast() const override final { return DYNCAST_EXPRESSION; }
  94
  95     const char *toChars() const override;
  96
  97     virtual dinteger_t toInteger();
  98     virtual uinteger_t toUInteger();
  99     virtual real_t toReal();
 100     virtual real_t toImaginary();
 101     virtual complex_t toComplex();
 102     virtual StringExp *toStringExp();
 103     virtual bool isLvalue();
 104     virtual Expression *toLvalue(Scope *sc, Expression *e);
 105     virtual Expression *modifiableLvalue(Scope *sc, Expression *e);
 106     Expression *implicitCastTo(Scope *sc, Type *t);
 107     MATCH implicitConvTo(Type *t);
 108     Expression *castTo(Scope *sc, Type *t);
 109     virtual Expression *resolveLoc(const Loc &loc, Scope *sc);
 110     virtual bool checkType();
 111     virtual bool checkValue();
 112     bool checkDeprecated(Scope *sc, Dsymbol *s);
 113     virtual Expression *addDtorHook(Scope *sc);
 114     Expression *addressOf();
 115     Expression *deref();
 116
 117     Expression *optimize(int result, bool keepLvalue = false);
 118
 119     // Entry point for CTFE.
 120     // A compile-time result is required. Give an error if not possible
 121     Expression *ctfeInterpret();
 122     int isConst();
 123     virtual bool isIdentical(const Expression *e) const;
 124     virtual Optional<bool> toBool();
 125     virtual bool hasCode()
 126     {
 127         return true;
 128     }
 129
 130     IntegerExp* isIntegerExp();
 131     ErrorExp* isErrorExp();
 132     VoidInitExp* isVoidInitExp();
 133     RealExp* isRealExp();
 134     ComplexExp* isComplexExp();
 135     IdentifierExp* isIdentifierExp();
 136     DollarExp* isDollarExp();
 137     DsymbolExp* isDsymbolExp();
 138     ThisExp* isThisExp();
 139     SuperExp* isSuperExp();
 140     NullExp* isNullExp();
 141     StringExp* isStringExp();
 142     TupleExp* isTupleExp();
 143     ArrayLiteralExp* isArrayLiteralExp();
 144     AssocArrayLiteralExp* isAssocArrayLiteralExp();
 145     StructLiteralExp* isStructLiteralExp();
 146     TypeExp* isTypeExp();
 147     ScopeExp* isScopeExp();
 148     TemplateExp* isTemplateExp();
 149     NewExp* isNewExp();
 150     NewAnonClassExp* isNewAnonClassExp();
 151     SymOffExp* isSymOffExp();
 152     VarExp* isVarExp();
 153     OverExp* isOverExp();
 154     FuncExp* isFuncExp();
 155     DeclarationExp* isDeclarationExp();
 156     TypeidExp* isTypeidExp();
 157     TraitsExp* isTraitsExp();
 158     HaltExp* isHaltExp();
 159     IsExp* isExp();
 160     MixinExp* isMixinExp();
 161     ImportExp* isImportExp();
 162     AssertExp* isAssertExp();
 163     DotIdExp* isDotIdExp();
 164     DotTemplateExp* isDotTemplateExp();
 165     DotVarExp* isDotVarExp();
 166     DotTemplateInstanceExp* isDotTemplateInstanceExp();
 167     DelegateExp* isDelegateExp();
 168     DotTypeExp* isDotTypeExp();
 169     CallExp* isCallExp();
 170     AddrExp* isAddrExp();
 171     PtrExp* isPtrExp();
 172     NegExp* isNegExp();
 173     UAddExp* isUAddExp();
 174     ComExp* isComExp();
 175     NotExp* isNotExp();
 176     DeleteExp* isDeleteExp();
 177     CastExp* isCastExp();
 178     VectorExp* isVectorExp();
 179     VectorArrayExp* isVectorArrayExp();
 180     SliceExp* isSliceExp();
 181     ArrayLengthExp* isArrayLengthExp();
 182     ArrayExp* isArrayExp();
 183     DotExp* isDotExp();
 184     CommaExp* isCommaExp();
 185     IntervalExp* isIntervalExp();
 186     DelegatePtrExp* isDelegatePtrExp();
 187     DelegateFuncptrExp* isDelegateFuncptrExp();
 188     IndexExp* isIndexExp();
 189     PostExp* isPostExp();
 190     PreExp* isPreExp();
 191     AssignExp* isAssignExp();
 192     ConstructExp* isConstructExp();
 193     BlitExp* isBlitExp();
 194     AddAssignExp* isAddAssignExp();
 195     MinAssignExp* isMinAssignExp();
 196     MulAssignExp* isMulAssignExp();
 197     DivAssignExp* isDivAssignExp();
 198     ModAssignExp* isModAssignExp();
 199     AndAssignExp* isAndAssignExp();
 200     OrAssignExp* isOrAssignExp();
 201     XorAssignExp* isXorAssignExp();
 202     PowAssignExp* isPowAssignExp();
 203     ShlAssignExp* isShlAssignExp();
 204     ShrAssignExp* isShrAssignExp();
 205     UshrAssignExp* isUshrAssignExp();
 206     CatAssignExp* isCatAssignExp();
 207     CatElemAssignExp* isCatElemAssignExp();
 208     CatDcharAssignExp* isCatDcharAssignExp();
 209     AddExp* isAddExp();
 210     MinExp* isMinExp();
 211     CatExp* isCatExp();
 212     MulExp* isMulExp();
 213     DivExp* isDivExp();
 214     ModExp* isModExp();
 215     PowExp* isPowExp();
 216     ShlExp* isShlExp();
 217     ShrExp* isShrExp();
 218     UshrExp* isUshrExp();
 219     AndExp* isAndExp();
 220     OrExp* isOrExp();
 221     XorExp* isXorExp();
 222     LogicalExp* isLogicalExp();
 223     InExp* isInExp();
 224     RemoveExp* isRemoveExp();
 225     EqualExp* isEqualExp();
 226     IdentityExp* isIdentityExp();
 227     CondExp* isCondExp();
 228     GenericExp* isGenericExp();
 229     DefaultInitExp* isDefaultInitExp();
 230     FileInitExp* isFileInitExp();
 231     LineInitExp* isLineInitExp();
 232     ModuleInitExp* isModuleInitExp();
 233     FuncInitExp* isFuncInitExp();
 234     PrettyFuncInitExp* isPrettyFuncInitExp();
 235     ClassReferenceExp* isClassReferenceExp();
 236     ThrownExceptionExp* isThrownExceptionExp();
 237     UnaExp* isUnaExp();
 238     BinExp* isBinExp();
 239     BinAssignExp* isBinAssignExp();
 240     LoweredAssignExp* isLoweredAssignExp();
 241
 242     void accept(Visitor *v) override { v->visit(this); }
 243 };
 244
 245 class IntegerExp final : public Expression
 246 {
 247 public:
 248     dinteger_t value;
 249
 250     static IntegerExp *create(const Loc &loc, dinteger_t value, Type *type);
 251     static void emplace(UnionExp *pue, const Loc &loc, dinteger_t value, Type *type);
 252     bool equals(const RootObject * const o) const override;
 253     dinteger_t toInteger() override;
 254     real_t toReal() override;
 255     real_t toImaginary() override;
 256     complex_t toComplex() override;
 257     Optional<bool> toBool() override;
 258     Expression *toLvalue(Scope *sc, Expression *e) override;
 259     void accept(Visitor *v) override { v->visit(this); }
 260     dinteger_t getInteger() { return value; }
 261     void setInteger(dinteger_t value);
 262     template<int v>
 263     static IntegerExp literal();
 264 };
 265
 266 class ErrorExp final : public Expression
 267 {
 268 public:
 269     Expression *toLvalue(Scope *sc, Expression *e) override;
 270     void accept(Visitor *v) override { v->visit(this); }
 271
 272     static ErrorExp *errorexp; // handy shared value
 273 };
 274
 275 class RealExp final : public Expression
 276 {
 277 public:
 278     real_t value;
 279
 280     static RealExp *create(const Loc &loc, real_t value, Type *type);
 281     static void emplace(UnionExp *pue, const Loc &loc, real_t value, Type *type);
 282     bool equals(const RootObject * const o) const override;
 283     bool isIdentical(const Expression *e) const override;
 284     dinteger_t toInteger() override;
 285     uinteger_t toUInteger() override;
 286     real_t toReal() override;
 287     real_t toImaginary() override;
 288     complex_t toComplex() override;
 289     Optional<bool> toBool() override;
 290     void accept(Visitor *v) override { v->visit(this); }
 291 };
 292
 293 class ComplexExp final : public Expression
 294 {
 295 public:
 296     complex_t value;
 297
 298     static ComplexExp *create(const Loc &loc, complex_t value, Type *type);
 299     static void emplace(UnionExp *pue, const Loc &loc, complex_t value, Type *type);
 300     bool equals(const RootObject * const o) const override;
 301     bool isIdentical(const Expression *e) const override;
 302     dinteger_t toInteger() override;
 303     uinteger_t toUInteger() override;
 304     real_t toReal() override;
 305     real_t toImaginary() override;
 306     complex_t toComplex() override;
 307     Optional<bool> toBool() override;
 308     void accept(Visitor *v) override { v->visit(this); }
 309 };
 310
 311 class IdentifierExp : public Expression
 312 {
 313 public:
 314     Identifier *ident;
 315     d_bool parens;
 316
 317     static IdentifierExp *create(const Loc &loc, Identifier *ident);
 318     bool isLvalue() override final;
 319     Expression *toLvalue(Scope *sc, Expression *e) override final;
 320     void accept(Visitor *v) override { v->visit(this); }
 321 };
 322
 323 class DollarExp final : public IdentifierExp
 324 {
 325 public:
 326     void accept(Visitor *v) override { v->visit(this); }
 327 };
 328
 329 class DsymbolExp final : public Expression
 330 {
 331 public:
 332     Dsymbol *s;
 333     d_bool hasOverloads;
 334
 335     DsymbolExp *syntaxCopy() override;
 336     bool isLvalue() override;
 337     Expression *toLvalue(Scope *sc, Expression *e) override;
 338     void accept(Visitor *v) override { v->visit(this); }
 339 };
 340
 341 class ThisExp : public Expression
 342 {
 343 public:
 344     VarDeclaration *var;
 345
 346     ThisExp *syntaxCopy() override;
 347     Optional<bool> toBool() override;
 348     bool isLvalue() override;
 349     Expression *toLvalue(Scope *sc, Expression *e) override;
 350
 351     void accept(Visitor *v) override { v->visit(this); }
 352 };
 353
 354 class SuperExp final : public ThisExp
 355 {
 356 public:
 357     bool isLvalue() override;
 358     Expression* toLvalue(Scope* sc, Expression* e) final override;
 359     void accept(Visitor *v) override { v->visit(this); }
 360 };
 361
 362 class NullExp final : public Expression
 363 {
 364 public:
 365     bool equals(const RootObject * const o) const override;
 366     Optional<bool> toBool() override;
 367     StringExp *toStringExp() override;
 368     void accept(Visitor *v) override { v->visit(this); }
 369 };
 370
 371 class StringExp final : public Expression
 372 {
 373 public:
 374     utf8_t postfix;      // 'c', 'w', 'd'
 375     OwnedBy ownedByCtfe;
 376     void *string;       // char, wchar, or dchar data
 377     size_t len;         // number of chars, wchars, or dchars
 378     unsigned char sz;   // 1: char, 2: wchar, 4: dchar
 379     bool committed;     // if type is committed
 380     bool hexString;     // if string is parsed from a hex string literal
 381
 382     static StringExp *create(const Loc &loc, const char *s);
 383     static StringExp *create(const Loc &loc, const void *s, d_size_t len);
 384     static void emplace(UnionExp *pue, const Loc &loc, const char *s);
 385     bool equals(const RootObject * const o) const override;
 386     char32_t getCodeUnit(d_size_t i) const;
 387     void setCodeUnit(d_size_t i, char32_t c);
 388     StringExp *toStringExp() override;
 389     StringExp *toUTF8(Scope *sc);
 390     Optional<bool> toBool() override;
 391     bool isLvalue() override;
 392     Expression *toLvalue(Scope *sc, Expression *e) override;
 393     Expression *modifiableLvalue(Scope *sc, Expression *e) override;
 394     void accept(Visitor *v) override { v->visit(this); }
 395     size_t numberOfCodeUnits(int tynto = 0) const;
 396     void writeTo(void* dest, bool zero, int tyto = 0) const;
 397 };
 398
 399 // Tuple
 400
 401 class TupleExp final : public Expression
 402 {
 403 public:
 404     Expression *e0;     // side-effect part
 405     /* Tuple-field access may need to take out its side effect part.
 406      * For example:
 407      *      foo().tupleof
 408      * is rewritten as:
 409      *      (ref __tup = foo(); tuple(__tup.field0, __tup.field1, ...))
 410      * The declaration of temporary variable __tup will be stored in TupleExp::e0.
 411      */
 412     Expressions *exps;
 413
 414     static TupleExp *create(const Loc &loc, Expressions *exps);
 415     TupleExp *syntaxCopy() override;
 416     bool equals(const RootObject * const o) const override;
 417
 418     void accept(Visitor *v) override { v->visit(this); }
 419 };
 420
 421 class ArrayLiteralExp final : public Expression
 422 {
 423 public:
 424     OwnedBy ownedByCtfe;
 425     d_bool onstack;
 426     Expression *basis;
 427     Expressions *elements;
 428
 429     static ArrayLiteralExp *create(const Loc &loc, Expressions *elements);
 430     static void emplace(UnionExp *pue, const Loc &loc, Expressions *elements);
 431     ArrayLiteralExp *syntaxCopy() override;
 432     bool equals(const RootObject * const o) const override;
 433     Expression *getElement(d_size_t i); // use opIndex instead
 434     Expression *opIndex(d_size_t i);
 435     Optional<bool> toBool() override;
 436     StringExp *toStringExp() override;
 437
 438     void accept(Visitor *v) override { v->visit(this); }
 439 };
 440
 441 class AssocArrayLiteralExp final : public Expression
 442 {
 443 public:
 444     OwnedBy ownedByCtfe;
 445     Expressions *keys;
 446     Expressions *values;
 447     Expression* lowering;
 448
 449     bool equals(const RootObject * const o) const override;
 450     AssocArrayLiteralExp *syntaxCopy() override;
 451     Optional<bool> toBool() override;
 452
 453     void accept(Visitor *v) override { v->visit(this); }
 454 };
 455
 456 class StructLiteralExp final : public Expression
 457 {
 458 public:
 459     StructDeclaration *sd;      // which aggregate this is for
 460     Expressions *elements;      // parallels sd->fields[] with NULL entries for fields to skip
 461     Type *stype;                // final type of result (can be different from sd's type)
 462
 463     union
 464     {
 465         Symbol *sym;                // back end symbol to initialize with literal
 466
 467         // those fields need to prevent a infinite recursion when one field of struct initialized with 'this' pointer.
 468         StructLiteralExp *inlinecopy;
 469     };
 470
 471     /** pointer to the origin instance of the expression.
 472      * once a new expression is created, origin is set to 'this'.
 473      * anytime when an expression copy is created, 'origin' pointer is set to
 474      * 'origin' pointer value of the original expression.
 475      */
 476     StructLiteralExp *origin;
 477
 478
 479     /** anytime when recursive function is calling, 'stageflags' marks with bit flag of
 480      * current stage and unmarks before return from this function.
 481      * 'inlinecopy' uses similar 'stageflags' and from multiple evaluation 'doInline'
 482      * (with infinite recursion) of this expression.
 483      */
 484     uint8_t stageflags;
 485
 486     d_bool useStaticInit;         // if this is true, use the StructDeclaration's init symbol
 487     d_bool isOriginal;            // used when moving instances to indicate `this is this.origin`
 488     OwnedBy ownedByCtfe;
 489
 490     static StructLiteralExp *create(const Loc &loc, StructDeclaration *sd, void *elements, Type *stype = NULL);
 491     bool equals(const RootObject * const o) const override;
 492     StructLiteralExp *syntaxCopy() override;
 493     Expression *getField(Type *type, unsigned offset);
 494     int getFieldIndex(Type *type, unsigned offset);
 495     Expression *addDtorHook(Scope *sc) override;
 496     Expression *toLvalue(Scope *sc, Expression *e) override;
 497
 498     void accept(Visitor *v) override { v->visit(this); }
 499 };
 500
 501 class TypeExp final : public Expression
 502 {
 503 public:
 504     TypeExp *syntaxCopy() override;
 505     bool checkType() override;
 506     bool checkValue() override;
 507     void accept(Visitor *v) override { v->visit(this); }
 508 };
 509
 510 class ScopeExp final : public Expression
 511 {
 512 public:
 513     ScopeDsymbol *sds;
 514
 515     ScopeExp *syntaxCopy() override;
 516     bool checkType() override;
 517     bool checkValue() override;
 518     void accept(Visitor *v) override { v->visit(this); }
 519 };
 520
 521 class TemplateExp final : public Expression
 522 {
 523 public:
 524     TemplateDeclaration *td;
 525     FuncDeclaration *fd;
 526
 527     bool isLvalue() override;
 528     Expression *toLvalue(Scope *sc, Expression *e) override;
 529     bool checkType() override;
 530     bool checkValue() override;
 531     void accept(Visitor *v) override { v->visit(this); }
 532 };
 533
 534 class NewExp final : public Expression
 535 {
 536 public:
 537     /* newtype(arguments)
 538      */
 539     Expression *thisexp;        // if !NULL, 'this' for class being allocated
 540     Type *newtype;
 541     Expressions *arguments;     // Array of Expression's
 542     Identifiers *names;         // Array of names corresponding to expressions
 543
 544     Expression *argprefix;      // expression to be evaluated just before arguments[]
 545
 546     CtorDeclaration *member;    // constructor function
 547     d_bool onstack;               // allocate on stack
 548     d_bool thrownew;              // this NewExp is the expression of a ThrowStatement
 549
 550     Expression *lowering;       // lowered druntime hook: `_d_newclass`
 551
 552     static NewExp *create(const Loc &loc, Expression *thisexp, Type *newtype, Expressions *arguments);
 553     NewExp *syntaxCopy() override;
 554
 555     void accept(Visitor *v) override { v->visit(this); }
 556 };
 557
 558 class NewAnonClassExp final : public Expression
 559 {
 560 public:
 561     /* class baseclasses { } (arguments)
 562      */
 563     Expression *thisexp;        // if !NULL, 'this' for class being allocated
 564     ClassDeclaration *cd;       // class being instantiated
 565     Expressions *arguments;     // Array of Expression's to call class constructor
 566
 567     NewAnonClassExp *syntaxCopy() override;
 568     void accept(Visitor *v) override { v->visit(this); }
 569 };
 570
 571 class SymbolExp : public Expression
 572 {
 573 public:
 574     Declaration *var;
 575     Dsymbol *originalScope;
 576     d_bool hasOverloads;
 577
 578     void accept(Visitor *v) override { v->visit(this); }
 579 };
 580
 581 // Offset from symbol
 582
 583 class SymOffExp final : public SymbolExp
 584 {
 585 public:
 586     dinteger_t offset;
 587
 588     Optional<bool> toBool() override;
 589
 590     void accept(Visitor *v) override { v->visit(this); }
 591 };
 592
 593 // Variable
 594
 595 class VarExp final : public SymbolExp
 596 {
 597 public:
 598     d_bool delegateWasExtracted;
 599     static VarExp *create(const Loc &loc, Declaration *var, bool hasOverloads = true);
 600     bool equals(const RootObject * const o) const override;
 601     bool isLvalue() override;
 602     Expression *toLvalue(Scope *sc, Expression *e) override;
 603     Expression *modifiableLvalue(Scope *sc, Expression *e) override;
 604
 605     void accept(Visitor *v) override { v->visit(this); }
 606 };
 607
 608 // Overload Set
 609
 610 class OverExp final : public Expression
 611 {
 612 public:
 613     OverloadSet *vars;
 614
 615     bool isLvalue() override;
 616     Expression *toLvalue(Scope *sc, Expression *e) override;
 617     void accept(Visitor *v) override { v->visit(this); }
 618 };
 619
 620 // Function/Delegate literal
 621
 622 class FuncExp final : public Expression
 623 {
 624 public:
 625     FuncLiteralDeclaration *fd;
 626     TemplateDeclaration *td;
 627     TOK tok;
 628
 629     bool equals(const RootObject * const o) const override;
 630     FuncExp *syntaxCopy() override;
 631     const char *toChars() const override;
 632     bool checkType() override;
 633     bool checkValue() override;
 634
 635     void accept(Visitor *v) override { v->visit(this); }
 636 };
 637
 638 // Declaration of a symbol
 639
 640 // D grammar allows declarations only as statements. However in AST representation
 641 // it can be part of any expression. This is used, for example, during internal
 642 // syntax re-writes to inject hidden symbols.
 643 class DeclarationExp final : public Expression
 644 {
 645 public:
 646     Dsymbol *declaration;
 647
 648     DeclarationExp *syntaxCopy() override;
 649
 650     bool hasCode() override;
 651
 652     void accept(Visitor *v) override { v->visit(this); }
 653 };
 654
 655 class TypeidExp final : public Expression
 656 {
 657 public:
 658     RootObject *obj;
 659
 660     TypeidExp *syntaxCopy() override;
 661     void accept(Visitor *v) override { v->visit(this); }
 662 };
 663
 664 class TraitsExp final : public Expression
 665 {
 666 public:
 667     Identifier *ident;
 668     Objects *args;
 669
 670     TraitsExp *syntaxCopy() override;
 671     void accept(Visitor *v) override { v->visit(this); }
 672 };
 673
 674 class HaltExp final : public Expression
 675 {
 676 public:
 677     void accept(Visitor *v) override { v->visit(this); }
 678 };
 679
 680 class IsExp final : public Expression
 681 {
 682 public:
 683     /* is(targ id tok tspec)
 684      * is(targ id == tok2)
 685      */
 686     Type *targ;
 687     Identifier *id;     // can be NULL
 688     Type *tspec;        // can be NULL
 689     TemplateParameters *parameters;
 690     TOK tok;       // ':' or '=='
 691     TOK tok2;      // 'struct', 'union', etc.
 692
 693     IsExp *syntaxCopy() override;
 694     void accept(Visitor *v) override { v->visit(this); }
 695 };
 696
 697 /****************************************************************/
 698
 699 class UnaExp : public Expression
 700 {
 701 public:
 702     Expression *e1;
 703
 704     UnaExp *syntaxCopy() override;
 705     Expression *incompatibleTypes();
 706     Expression *resolveLoc(const Loc &loc, Scope *sc) override final;
 707
 708     void accept(Visitor *v) override { v->visit(this); }
 709 };
 710
 711 class BinExp : public Expression
 712 {
 713 public:
 714     Expression *e1;
 715     Expression *e2;
 716
 717     Type *att1; // Save alias this type to detect recursion
 718     Type *att2; // Save alias this type to detect recursion
 719
 720     BinExp *syntaxCopy() override;
 721     Expression *incompatibleTypes();
 722
 723     Expression *reorderSettingAAElem(Scope *sc);
 724
 725     void accept(Visitor *v) override { v->visit(this); }
 726 };
 727
 728 class BinAssignExp : public BinExp
 729 {
 730 public:
 731     bool isLvalue() override final;
 732     Expression *toLvalue(Scope *sc, Expression *ex) override final;
 733     Expression *modifiableLvalue(Scope *sc, Expression *e) override final;
 734     void accept(Visitor *v) override { v->visit(this); }
 735 };
 736
 737 /****************************************************************/
 738
 739 class MixinExp final : public UnaExp
 740 {
 741 public:
 742     void accept(Visitor *v) override { v->visit(this); }
 743 };
 744
 745 class ImportExp final : public UnaExp
 746 {
 747 public:
 748     void accept(Visitor *v) override { v->visit(this); }
 749 };
 750
 751 class AssertExp final : public UnaExp
 752 {
 753 public:
 754     Expression *msg;
 755
 756     AssertExp *syntaxCopy() override;
 757
 758     void accept(Visitor *v) override { v->visit(this); }
 759 };
 760
 761 class ThrowExp final : public UnaExp
 762 {
 763 public:
 764     ThrowExp *syntaxCopy() override;
 765
 766     void accept(Visitor *v) override { v->visit(this); }
 767 };
 768
 769 class DotIdExp final : public UnaExp
 770 {
 771 public:
 772     Identifier *ident;
 773     d_bool noderef;       // true if the result of the expression will never be dereferenced
 774     d_bool wantsym;       // do not replace Symbol with its initializer during semantic()
 775     d_bool arrow;         // ImportC: if -> instead of .
 776
 777     static DotIdExp *create(const Loc &loc, Expression *e, Identifier *ident);
 778     void accept(Visitor *v) override { v->visit(this); }
 779 };
 780
 781 class DotTemplateExp final : public UnaExp
 782 {
 783 public:
 784     TemplateDeclaration *td;
 785
 786     bool checkType() override;
 787     bool checkValue() override;
 788     void accept(Visitor *v) override { v->visit(this); }
 789 };
 790
 791 class DotVarExp final : public UnaExp
 792 {
 793 public:
 794     Declaration *var;
 795     d_bool hasOverloads;
 796
 797     bool isLvalue() override;
 798     Expression *toLvalue(Scope *sc, Expression *e) override;
 799     Expression *modifiableLvalue(Scope *sc, Expression *e) override;
 800     void accept(Visitor *v) override { v->visit(this); }
 801 };
 802
 803 class DotTemplateInstanceExp final : public UnaExp
 804 {
 805 public:
 806     TemplateInstance *ti;
 807
 808     DotTemplateInstanceExp *syntaxCopy() override;
 809     bool findTempDecl(Scope *sc);
 810     bool checkType() override;
 811     bool checkValue() override;
 812     void accept(Visitor *v) override { v->visit(this); }
 813 };
 814
 815 class DelegateExp final : public UnaExp
 816 {
 817 public:
 818     FuncDeclaration *func;
 819     d_bool hasOverloads;
 820     VarDeclaration *vthis2;  // container for multi-context
 821
 822
 823     void accept(Visitor *v) override { v->visit(this); }
 824 };
 825
 826 class DotTypeExp final : public UnaExp
 827 {
 828 public:
 829     Dsymbol *sym;               // symbol that represents a type
 830
 831     void accept(Visitor *v) override { v->visit(this); }
 832 };
 833
 834 class CallExp final : public UnaExp
 835 {
 836 public:
 837     Expressions *arguments;     // function arguments
 838     Identifiers *names;
 839     FuncDeclaration *f;         // symbol to call
 840     d_bool directcall;            // true if a virtual call is devirtualized
 841     d_bool inDebugStatement;      // true if this was in a debug statement
 842     d_bool ignoreAttributes;      // don't enforce attributes (e.g. call @gc function in @nogc code)
 843     d_bool isUfcsRewrite;       // the first argument was pushed in here by a UFCS rewrite
 844     VarDeclaration *vthis2;     // container for multi-context
 845
 846     static CallExp *create(const Loc &loc, Expression *e, Expressions *exps);
 847     static CallExp *create(const Loc &loc, Expression *e);
 848     static CallExp *create(const Loc &loc, Expression *e, Expression *earg1);
 849     static CallExp *create(const Loc &loc, FuncDeclaration *fd, Expression *earg1);
 850
 851     CallExp *syntaxCopy() override;
 852     bool isLvalue() override;
 853     Expression *toLvalue(Scope *sc, Expression *e) override;
 854     Expression *addDtorHook(Scope *sc) override;
 855
 856     void accept(Visitor *v) override { v->visit(this); }
 857 };
 858
 859 class AddrExp final : public UnaExp
 860 {
 861 public:
 862     void accept(Visitor *v) override { v->visit(this); }
 863 };
 864
 865 class PtrExp final : public UnaExp
 866 {
 867 public:
 868     bool isLvalue() override;
 869     Expression *toLvalue(Scope *sc, Expression *e) override;
 870     Expression *modifiableLvalue(Scope *sc, Expression *e) override;
 871
 872     void accept(Visitor *v) override { v->visit(this); }
 873 };
 874
 875 class NegExp final : public UnaExp
 876 {
 877 public:
 878     void accept(Visitor *v) override { v->visit(this); }
 879 };
 880
 881 class UAddExp final : public UnaExp
 882 {
 883 public:
 884     void accept(Visitor *v) override { v->visit(this); }
 885 };
 886
 887 class ComExp final : public UnaExp
 888 {
 889 public:
 890     void accept(Visitor *v) override { v->visit(this); }
 891 };
 892
 893 class NotExp final : public UnaExp
 894 {
 895 public:
 896     void accept(Visitor *v) override { v->visit(this); }
 897 };
 898
 899 class DeleteExp final : public UnaExp
 900 {
 901 public:
 902     d_bool isRAII;
 903     void accept(Visitor *v) override { v->visit(this); }
 904 };
 905
 906 class CastExp final : public UnaExp
 907 {
 908 public:
 909     // Possible to cast to one type while painting to another type
 910     Type *to;                   // type to cast to
 911     unsigned char mod;          // MODxxxxx
 912
 913     CastExp *syntaxCopy() override;
 914     bool isLvalue() override;
 915     Expression *toLvalue(Scope *sc, Expression *e) override;
 916
 917     void accept(Visitor *v) override { v->visit(this); }
 918 };
 919
 920 class VectorExp final : public UnaExp
 921 {
 922 public:
 923     TypeVector *to;             // the target vector type before semantic()
 924     unsigned dim;               // number of elements in the vector
 925     OwnedBy ownedByCtfe;
 926
 927     static VectorExp *create(const Loc &loc, Expression *e, Type *t);
 928     static void emplace(UnionExp *pue, const Loc &loc, Expression *e, Type *t);
 929     VectorExp *syntaxCopy() override;
 930     void accept(Visitor *v) override { v->visit(this); }
 931 };
 932
 933 class VectorArrayExp final : public UnaExp
 934 {
 935 public:
 936     bool isLvalue() override;
 937     Expression *toLvalue(Scope *sc, Expression *e) override;
 938     void accept(Visitor *v) override { v->visit(this); }
 939 };
 940
 941 class SliceExp final : public UnaExp
 942 {
 943 public:
 944     Expression *upr;            // NULL if implicit 0
 945     Expression *lwr;            // NULL if implicit [length - 1]
 946     VarDeclaration *lengthVar;
 947
 948     bool upperIsInBounds() const; // true if upr <= e1.length
 949     bool upperIsInBounds(bool v);
 950     bool lowerIsLessThanUpper() const; // true if lwr <= upr
 951     bool lowerIsLessThanUpper(bool v);
 952     bool arrayop() const; // an array operation, rather than a slice
 953     bool arrayop(bool v);
 954 private:
 955     uint8_t bitFields;
 956
 957 public:
 958     SliceExp *syntaxCopy() override;
 959     bool isLvalue() override;
 960     Expression *toLvalue(Scope *sc, Expression *e) override;
 961     Expression *modifiableLvalue(Scope *sc, Expression *e) override;
 962     Optional<bool> toBool() override;
 963
 964     void accept(Visitor *v) override { v->visit(this); }
 965 };
 966
 967 class ArrayLengthExp final : public UnaExp
 968 {
 969 public:
 970     void accept(Visitor *v) override { v->visit(this); }
 971 };
 972
 973 class IntervalExp final : public Expression
 974 {
 975 public:
 976     Expression *lwr;
 977     Expression *upr;
 978
 979     IntervalExp *syntaxCopy() override;
 980     void accept(Visitor *v) override { v->visit(this); }
 981 };
 982
 983 class DelegatePtrExp final : public UnaExp
 984 {
 985 public:
 986     bool isLvalue() override;
 987     Expression *toLvalue(Scope *sc, Expression *e) override;
 988     Expression *modifiableLvalue(Scope *sc, Expression *e) override;
 989     void accept(Visitor *v) override { v->visit(this); }
 990 };
 991
 992 class DelegateFuncptrExp final : public UnaExp
 993 {
 994 public:
 995     bool isLvalue() override;
 996     Expression *toLvalue(Scope *sc, Expression *e) override;
 997     Expression *modifiableLvalue(Scope *sc, Expression *e) override;
 998     void accept(Visitor *v) override { v->visit(this); }
 999 };
1000
1001 // e1[a0,a1,a2,a3,...]
1002
1003 class ArrayExp final : public UnaExp
1004 {
1005 public:
1006     Expressions *arguments;             // Array of Expression's
1007     size_t currentDimension;            // for opDollar
1008     VarDeclaration *lengthVar;
1009
1010     ArrayExp *syntaxCopy() override;
1011     bool isLvalue() override;
1012     Expression *toLvalue(Scope *sc, Expression *e) override;
1013
1014     void accept(Visitor *v) override { v->visit(this); }
1015 };
1016
1017 /****************************************************************/
1018
1019 class DotExp final : public BinExp
1020 {
1021 public:
1022     void accept(Visitor *v) override { v->visit(this); }
1023 };
1024
1025 class CommaExp final : public BinExp
1026 {
1027 public:
1028     d_bool isGenerated;
1029     d_bool allowCommaExp;
1030     bool isLvalue() override;
1031     Expression *toLvalue(Scope *sc, Expression *e) override;
1032     Expression *modifiableLvalue(Scope *sc, Expression *e) override;
1033     Optional<bool> toBool() override;
1034     Expression *addDtorHook(Scope *sc) override;
1035     void accept(Visitor *v) override { v->visit(this); }
1036 };
1037
1038 class IndexExp final : public BinExp
1039 {
1040 public:
1041     VarDeclaration *lengthVar;
1042     d_bool modifiable;
1043     d_bool indexIsInBounds;       // true if 0 <= e2 && e2 <= e1.length - 1
1044
1045     IndexExp *syntaxCopy() override;
1046     bool isLvalue() override;
1047     Expression *toLvalue(Scope *sc, Expression *e) override;
1048     Expression *modifiableLvalue(Scope *sc, Expression *e) override;
1049
1050     void accept(Visitor *v) override { v->visit(this); }
1051 };
1052
1053 /* For both i++ and i--
1054  */
1055 class PostExp final : public BinExp
1056 {
1057 public:
1058     void accept(Visitor *v) override { v->visit(this); }
1059 };
1060
1061 /* For both ++i and --i
1062  */
1063 class PreExp final : public UnaExp
1064 {
1065 public:
1066     void accept(Visitor *v) override { v->visit(this); }
1067 };
1068
1069 enum class MemorySet
1070 {
1071     none            = 0,    // simple assignment
1072     blockAssign     = 1,    // setting the contents of an array
1073     referenceInit   = 2     // setting the reference of STCref variable
1074 };
1075
1076 class AssignExp : public BinExp
1077 {
1078 public:
1079     MemorySet memset;
1080
1081     bool isLvalue() override final;
1082     Expression *toLvalue(Scope *sc, Expression *ex) override final;
1083
1084     void accept(Visitor *v) override { v->visit(this); }
1085 };
1086
1087 class ConstructExp final : public AssignExp
1088 {
1089 public:
1090     void accept(Visitor *v) override { v->visit(this); }
1091 };
1092
1093 class LoweredAssignExp final : public AssignExp
1094 {
1095 public:
1096     Expression *lowering;
1097
1098     const char *toChars() const override;
1099     void accept(Visitor *v) override { v->visit(this); }
1100 };
1101
1102 class BlitExp final : public AssignExp
1103 {
1104 public:
1105     void accept(Visitor *v) override { v->visit(this); }
1106 };
1107
1108 class AddAssignExp final : public BinAssignExp
1109 {
1110 public:
1111     void accept(Visitor *v) override { v->visit(this); }
1112 };
1113
1114 class MinAssignExp final : public BinAssignExp
1115 {
1116 public:
1117     void accept(Visitor *v) override { v->visit(this); }
1118 };
1119
1120 class MulAssignExp final : public BinAssignExp
1121 {
1122 public:
1123     void accept(Visitor *v) override { v->visit(this); }
1124 };
1125
1126 class DivAssignExp final : public BinAssignExp
1127 {
1128 public:
1129     void accept(Visitor *v) override { v->visit(this); }
1130 };
1131
1132 class ModAssignExp final : public BinAssignExp
1133 {
1134 public:
1135     void accept(Visitor *v) override { v->visit(this); }
1136 };
1137
1138 class AndAssignExp final : public BinAssignExp
1139 {
1140 public:
1141     void accept(Visitor *v) override { v->visit(this); }
1142 };
1143
1144 class OrAssignExp final : public BinAssignExp
1145 {
1146 public:
1147     void accept(Visitor *v) override { v->visit(this); }
1148 };
1149
1150 class XorAssignExp final : public BinAssignExp
1151 {
1152 public:
1153     void accept(Visitor *v) override { v->visit(this); }
1154 };
1155
1156 class PowAssignExp final : public BinAssignExp
1157 {
1158 public:
1159     void accept(Visitor *v) override { v->visit(this); }
1160 };
1161
1162 class ShlAssignExp final : public BinAssignExp
1163 {
1164 public:
1165     void accept(Visitor *v) override { v->visit(this); }
1166 };
1167
1168 class ShrAssignExp final : public BinAssignExp
1169 {
1170 public:
1171     void accept(Visitor *v) override { v->visit(this); }
1172 };
1173
1174 class UshrAssignExp final : public BinAssignExp
1175 {
1176 public:
1177     void accept(Visitor *v) override { v->visit(this); }
1178 };
1179
1180 class CatAssignExp : public BinAssignExp
1181 {
1182 public:
1183     void accept(Visitor *v) override { v->visit(this); }
1184 };
1185
1186 class CatElemAssignExp final : public CatAssignExp
1187 {
1188 public:
1189     void accept(Visitor *v) override { v->visit(this); }
1190 };
1191
1192 class CatDcharAssignExp final : public CatAssignExp
1193 {
1194 public:
1195     void accept(Visitor *v) override { v->visit(this); }
1196 };
1197
1198 class AddExp final : public BinExp
1199 {
1200 public:
1201     void accept(Visitor *v) override { v->visit(this); }
1202 };
1203
1204 class MinExp final : public BinExp
1205 {
1206 public:
1207     void accept(Visitor *v) override { v->visit(this); }
1208 };
1209
1210 class CatExp final : public BinExp
1211 {
1212 public:
1213     Expression *lowering;  // call to druntime hook `_d_arraycatnTX`
1214
1215     void accept(Visitor *v) override { v->visit(this); }
1216 };
1217
1218 class MulExp final : public BinExp
1219 {
1220 public:
1221     void accept(Visitor *v) override { v->visit(this); }
1222 };
1223
1224 class DivExp final : public BinExp
1225 {
1226 public:
1227     void accept(Visitor *v) override { v->visit(this); }
1228 };
1229
1230 class ModExp final : public BinExp
1231 {
1232 public:
1233     void accept(Visitor *v) override { v->visit(this); }
1234 };
1235
1236 class PowExp final : public BinExp
1237 {
1238 public:
1239     void accept(Visitor *v) override { v->visit(this); }
1240 };
1241
1242 class ShlExp final : public BinExp
1243 {
1244 public:
1245     void accept(Visitor *v) override { v->visit(this); }
1246 };
1247
1248 class ShrExp final : public BinExp
1249 {
1250 public:
1251     void accept(Visitor *v) override { v->visit(this); }
1252 };
1253
1254 class UshrExp final : public BinExp
1255 {
1256 public:
1257     void accept(Visitor *v) override { v->visit(this); }
1258 };
1259
1260 class AndExp final : public BinExp
1261 {
1262 public:
1263     void accept(Visitor *v) override { v->visit(this); }
1264 };
1265
1266 class OrExp final : public BinExp
1267 {
1268 public:
1269     void accept(Visitor *v) override { v->visit(this); }
1270 };
1271
1272 class XorExp final : public BinExp
1273 {
1274 public:
1275     void accept(Visitor *v) override { v->visit(this); }
1276 };
1277
1278 class LogicalExp final : public BinExp
1279 {
1280 public:
1281     void accept(Visitor *v) override { v->visit(this); }
1282 };
1283
1284 class CmpExp final : public BinExp
1285 {
1286 public:
1287     void accept(Visitor *v) override { v->visit(this); }
1288 };
1289
1290 class InExp final : public BinExp
1291 {
1292 public:
1293     void accept(Visitor *v) override { v->visit(this); }
1294 };
1295
1296 class RemoveExp final : public BinExp
1297 {
1298 public:
1299     void accept(Visitor *v) override { v->visit(this); }
1300 };
1301
1302 // == and !=
1303
1304 class EqualExp final : public BinExp
1305 {
1306 public:
1307     void accept(Visitor *v) override { v->visit(this); }
1308 };
1309
1310 // is and !is
1311
1312 class IdentityExp final : public BinExp
1313 {
1314 public:
1315     void accept(Visitor *v) override { v->visit(this); }
1316 };
1317
1318 /****************************************************************/
1319
1320 class CondExp final : public BinExp
1321 {
1322 public:
1323     Expression *econd;
1324
1325     CondExp *syntaxCopy() override;
1326     bool isLvalue() override;
1327     Expression *toLvalue(Scope *sc, Expression *e) override;
1328     Expression *modifiableLvalue(Scope *sc, Expression *e) override;
1329     void hookDtors(Scope *sc);
1330
1331     void accept(Visitor *v) override { v->visit(this); }
1332 };
1333
1334 class GenericExp final : Expression
1335 {
1336     Expression *cntlExp;
1337     Types *types;
1338     Expressions *exps;
1339
1340     GenericExp *syntaxCopy() override;
1341
1342     void accept(Visitor *v) override { v->visit(this); }
1343 };
1344
1345 /****************************************************************/
1346
1347 class DefaultInitExp : public Expression
1348 {
1349 public:
1350     void accept(Visitor *v) override { v->visit(this); }
1351 };
1352
1353 class FileInitExp final : public DefaultInitExp
1354 {
1355 public:
1356     Expression *resolveLoc(const Loc &loc, Scope *sc) override;
1357     void accept(Visitor *v) override { v->visit(this); }
1358 };
1359
1360 class LineInitExp final : public DefaultInitExp
1361 {
1362 public:
1363     Expression *resolveLoc(const Loc &loc, Scope *sc) override;
1364     void accept(Visitor *v) override { v->visit(this); }
1365 };
1366
1367 class ModuleInitExp final : public DefaultInitExp
1368 {
1369 public:
1370     Expression *resolveLoc(const Loc &loc, Scope *sc) override;
1371     void accept(Visitor *v) override { v->visit(this); }
1372 };
1373
1374 class FuncInitExp final : public DefaultInitExp
1375 {
1376 public:
1377     Expression *resolveLoc(const Loc &loc, Scope *sc) override;
1378     void accept(Visitor *v) override { v->visit(this); }
1379 };
1380
1381 class PrettyFuncInitExp final : public DefaultInitExp
1382 {
1383 public:
1384     Expression *resolveLoc(const Loc &loc, Scope *sc) override;
1385     void accept(Visitor *v) override { v->visit(this); }
1386 };
1387
1388 /****************************************************************/
1389
1390 /* A type meant as a union of all the Expression types,
1391  * to serve essentially as a Variant that will sit on the stack
1392  * during CTFE to reduce memory consumption.
1393  */
1394 struct UnionExp
1395 {
1396     UnionExp() { }  // yes, default constructor does nothing
1397
1398     UnionExp(Expression *e)
1399     {
1400         memcpy(this, (void *)e, e->size());
1401     }
1402
1403     /* Extract pointer to Expression
1404      */
1405     Expression *exp() { return (Expression *)&u; }
1406
1407     /* Convert to an allocated Expression
1408      */
1409     Expression *copy();
1410
1411 private:
1412     // Ensure that the union is suitably aligned.
1413 #if defined(__GNUC__) || defined(__clang__)
1414     __attribute__((aligned(8)))
1415 #elif defined(_MSC_VER)
1416     __declspec(align(8))
1417 #elif defined(__DMC__)
1418     #pragma pack(8)
1419 #endif
1420     union
1421     {
1422         char exp       [sizeof(Expression)];
1423         char integerexp[sizeof(IntegerExp)];
1424         char errorexp  [sizeof(ErrorExp)];
1425         char realexp   [sizeof(RealExp)];
1426         char complexexp[sizeof(ComplexExp)];
1427         char symoffexp [sizeof(SymOffExp)];
1428         char stringexp [sizeof(StringExp)];
1429         char arrayliteralexp [sizeof(ArrayLiteralExp)];
1430         char assocarrayliteralexp [sizeof(AssocArrayLiteralExp)];
1431         char structliteralexp [sizeof(StructLiteralExp)];
1432         char nullexp   [sizeof(NullExp)];
1433         char dotvarexp [sizeof(DotVarExp)];
1434         char addrexp   [sizeof(AddrExp)];
1435         char indexexp  [sizeof(IndexExp)];
1436         char sliceexp  [sizeof(SliceExp)];
1437         char vectorexp [sizeof(VectorExp)];
1438     } u;
1439 #if defined(__DMC__)
1440     #pragma pack()
1441 #endif
1442 };
1443
1444 /****************************************************************/
1445
1446 class ObjcClassReferenceExp final : public Expression
1447 {
1448 public:
1449     ClassDeclaration* classDeclaration;
1450
1451     void accept(Visitor *v) override { v->visit(this); }
1452 };