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