dmd.expression

Defines the bulk of the classes which represent the AST at the expression level.

Specification: ($LINK2 https://dlang.org/spec/expression.html, Expressions)

Authors

Walter Bright

Source: expression.d

  • Declaration

    enum Modifiable: int;

    Return value for checkModifiable

    • no

      Declaration

      no

      Not modifiable

    • yes

      Declaration

      yes

      Modifiable (the type is mutable)

    • Declaration

      initialization

      Modifiable because it is initialization

  • Declaration

    enum ModifyFlags: int;

    Specifies how the checkModify deals with certain situations

    • Declaration

      none

      Issue error messages on invalid modifications of the variable

    • Declaration

      noError

      No errors are emitted for invalid modifications

    • Declaration

      fieldAssign

      The modification occurs for a subfield of the current variable

  • Declaration

    inout(Expression) firstComma(inout Expression e);

    Find the first non-comma expression.

    Parameters

    Expression e

    Expressions connected by commas

    Return Value

    left-most non-comma expression

  • Declaration

    inout(Expression) lastComma(inout Expression e);

    Find the last non-comma expression.

    Parameters

    Expression e

    Expressions connected by commas

    Return Value

    right-most non-comma expression

  • Declaration

    FuncDeclaration hasThis(Scope* sc);

    Determine if this is available by walking up the enclosing scopes until a function is found.

    Parameters

    Scope* sc

    where to start looking for the enclosing function

    Return Value

    Found function if it satisfies isThis(), otherwise null

  • Declaration

    bool isNeedThisScope(Scope* sc, Declaration d);

    Determine if a this is needed to access d.

    Parameters

    Scope* sc

    context

    Declaration d

    declaration to check

    Return Value

    true means a this is needed

  • Declaration

    bool isDotOpDispatch(Expression e);

    check e is exp.opDispatch!(tiargs) or not It's used to switch to UFCS the semantic analysis path

  • Declaration

    void expandTuples(Expressions* exps, Identifiers* names = null);

    Expand tuples in-place.

    Example: When there's a call f(10, pair: AliasSeq!(20, 30), single: 40), the input is: exps = [10, (20, 30), 40] names = [null, "pair", "single"] The arrays will be modified to: exps = [10, 20, 30, 40] names = [null, "pair", null, "single"]

    Parameters

    Expressions* exps

    array of Expressions

    Identifiers* names

    optional array of names corresponding to Expressions

  • Declaration

    TupleDeclaration isAliasThisTuple(Expression e);

    Expand alias this tuples.

  • Declaration

    TemplateDeclaration getFuncTemplateDecl(Dsymbol s);

    If s is a function template, i.e. the only member of a template and that member is a function, return that template.

    Parameters

    Dsymbol s

    symbol that might be a function template

    Return Value

    template for that function, otherwise null

  • Declaration

    Expression valueNoDtor(Expression e);

    If we want the value of this expression, but do not want to call the destructor on it.

  • Declaration

    Expression doCopyOrMove(Scope* sc, Expression e, Type t = null);

    Handle the postblit call on lvalue, or the move of rvalue.

    Parameters

    Scope* sc

    the scope where the expression is encountered

    Expression e

    the expression the needs to be moved or copied (source)

    Type t

    if the struct defines a copy constructor, the type of the destination

    Return Value

    The expression that copy constructs or moves the value.

  • Declaration

    struct UnionExp;

  • Declaration

    bool RealIdentical(real_t x1, real_t x2);

    Test to see if two reals are the same. Regard NaN's as equivalent. Regard +0 and -0 as different.

    Parameters

    real_t x1

    first operand

    real_t x2

    second operand

    Return Value

    true if x1 is x2 else false

  • Declaration

    DotIdExp typeDotIdExp(const ref Loc loc, Type type, Identifier ident);

    TypeDotIdExp

  • Declaration

    VarDeclaration expToVariable(Expression e);

    Given an Expression, find the variable it really is.

    Discussion

    For example, a[index] is really a, and s.f is really s.

    Parameters

    Expression e

    Expression to look at

    Return Value

    variable if there is one, null if not

  • Declaration

    abstract class Expression: dmd.ast_node.ASTNode;

    • Declaration

      final const pure nothrow @nogc @safe size_t size();

      Return Value

      class instance size of this expression (implemented manually because extern(C++))

    • Declaration

      static void deinitialize();

      Deinitializes the global state of the compiler.

      Discussion

      This can be used to restore the state set by _init to its original state.

    • Declaration

      final Expression copy();

      Does not do a deep copy.

    • Declaration

      static Expression combine(Expression e1, Expression e2);

      Combine e1 and e2 by CommaExp if both are not NULL.

    • Declaration

      static Expression extractLast(Expression e, out Expression e0);

      If 'e' is a tree of commas, returns the rightmost expression by stripping off it from the tree. The remained part of the tree is returned via e0. Otherwise 'e' is directly returned and e0 is set to NULL.

    • Declaration

      bool isLvalue();

      Return !=0 if expression is an lvalue.

    • Declaration

      Expression toLvalue(Scope* sc, Expression e);

      Give error if we're not an lvalue. If we can, convert expression to be an lvalue.

    • Declaration

      Expression resolveLoc(const ref Loc loc, Scope* sc);

      Resolve __FILE__, __LINE__, __MODULE__, __FUNCTION__, __PRETTY_FUNCTION__, _FILE_FULL_PATH__ to loc.

    • Declaration

      bool checkType();

      Check that the expression has a valid type. If not, generates an error "... has no type".

      Return Value

      true if the expression is not valid.

      Note: When this function returns true, checkValue() should also return true.

    • Declaration

      bool checkValue();

      Check that the expression has a valid value. If not, generates an error "... has no value".

      Return Value

      true if the expression is not valid or has void type.

    • Declaration

      final bool checkPurity(Scope* sc, FuncDeclaration f);

      Calling function f. Check the purity, i.e. if we're in a pure function we can only call other pure functions. Returns true if error occurs.

    • Declaration

      final void checkOverriddenDtor(Scope* sc, FuncDeclaration f, scope bool function(DtorDeclaration) check, const string checkName);

      Checks whether f is a generated DtorDeclaration that hides a user-defined one which passes check while f doesn't (e.g. when the user defined dtor is pure but the generated dtor is not). In that case the method will identify and print all members causing the attribute missmatch.

      Parameters

      Scope* sc

      scope

      FuncDeclaration f

      potential DtorDeclaration

      bool function(DtorDeclaration) check

      current check (e.g. whether it's pure)

      string checkName

      the kind of check (e.g. "pure")

    • Declaration

      final bool checkPurity(Scope* sc, VarDeclaration v);

      Accessing variable v. Check for purity and safety violations. Returns true if error occurs.

    • Declaration

      final bool checkSafety(Scope* sc, FuncDeclaration f);

      Calling function f. Check the safety, i.e. if we're in a @safe function we can only call @safe or @trusted functions. Returns true if error occurs.

    • Declaration

      final bool checkNogc(Scope* sc, FuncDeclaration f);

      Calling function f. Check the @nogc-ness, i.e. if we're in a @nogc function we can only call other @nogc functions. Returns true if error occurs.

    • Declaration

      final bool checkPostblit(Scope* sc, Type t);

      Check that the postblit is callable if t is an array of structs. Returns true if error happens.

    • Declaration

      final bool checkReadModifyWrite(EXP rmwOp, Expression ex = null);

      Check whether the expression allows RMW operations, error with rmw operator diagnostic if not. ex is the RHS expression, or NULL if ++/-- is used (for diagnostics) Returns true if error occurs.

    • Declaration

      Expression addDtorHook(Scope* sc);

      Destructors are attached to VarDeclarations. Hence, if expression returns a temp that needs a destructor, make sure and create a VarDeclaration for that temp.

    • Declaration

      final Expression addressOf();

      Take address of expression.

    • Declaration

      final Expression deref();

      If this is a reference, dereference it.

    • Declaration

      const bool isIdentical(const Expression e);

      Identical, not just equal. I.e. NaNs with different bit patterns are not identical

    • Declaration

      Optional!bool toBool();

      Statically evaluate this expression to a bool if possible

      Return Value

      an optional thath either contains the value or is empty

  • Declaration

    class IntegerExp: dmd.expression.Expression;

    A compile-time known integer value

    • Declaration

      IntegerExp literal(int v)();

      Use this instead of creating new instances for commonly used literals such as 0 or 1.

      Parameters: v = The value of the expression

      Return Value

      A static instance of the expression, typed as Tint32.

    • Declaration

      static IntegerExp createBool(bool b);

      Use this instead of creating new instances for commonly used bools.

      Parameters: b = The value of the expression

      Return Value

      A static instance of the expression, typed as Type.tbool.

  • Declaration

    class ErrorExp: dmd.expression.Expression;

    Use this expression for error recovery.

    Discussion

    It should behave as a 'sink' to prevent further cascaded error messages.

  • Declaration

    class VoidInitExp: dmd.expression.Expression;

    An uninitialized value, generated from void initializers.

    • var

      Declaration

      VarDeclaration var;

      the variable from where the void value came from, null if not known

    • Declaration

      this(VarDeclaration var);

      Useful for error messages

  • Declaration

    class RealExp: dmd.expression.Expression;

    A compile-time known floating point number

  • Declaration

    class ComplexExp: dmd.expression.Expression;

    A compile-time complex number (deprecated)

  • Declaration

    class IdentifierExp: dmd.expression.Expression;

    An identifier in the context of an expression (as opposed to a declaration)

    Discussion

    1. int x; // VarDeclaration with Identifier x++; // PostExp with IdentifierExp

  • Declaration

    class DollarExp: dmd.expression.IdentifierExp;

    The dollar operator used when indexing or slicing an array. E.g a[$], a[1 .. $] etc.

  • Declaration

    class DsymbolExp: dmd.expression.Expression;

    Won't be generated by parser.

  • Declaration

    class ThisExp: dmd.expression.Expression;

  • Declaration

    class SuperExp: dmd.expression.ThisExp;

  • Declaration

    class NullExp: dmd.expression.Expression;

    A compile-time known null value

  • Declaration

    class StringExp: dmd.expression.Expression;

    • Declaration

      bool committed;

      Whether the string literal's type is fixed

      Example:

      1. wstring x = "abc"; // OK, string literal is flexible wstring y = cast(string) "abc"; // Error: type was committed after cast

    • Declaration

      const size_t numberOfCodeUnits(int tynto = 0);

      Return the number of code units the string would be if it were re-encoded as tynto.

      Parameters

      int tynto

      code unit type of the target encoding

      Return Value

      number of code units

    • Declaration

      const void writeTo(void* dest, bool zero, int tyto = 0);

      Write the contents of the string to dest. Use numberOfCodeUnits() to determine size of result.

      Parameters

      void* dest

      destination

      int tyto

      encoding type of the result

      bool zero

      add terminating 0

    • Declaration

      const pure dchar getCodeUnit(size_t i);

      Get the code unit at index i

      Parameters

      size_t i

      index

      Return Value

      code unit at index i

    • Declaration

      void setCodeUnit(size_t i, dchar c);

      Set the code unit at index i to c

      Parameters

      size_t i

      index

      dchar c

      code unit to set it to

    • Declaration

      StringExp toUTF8(Scope* sc);

      Convert string to char[].

    • Declaration

      const pure nothrow @nogc int compare(const StringExp se2);

      Compare two StringExp by length, then value

      Discussion

      The comparison is not the usual C-style comparison as seen with strcmp or memcmp, but instead first compare based on the length. This allows both faster lookup and sorting when comparing sparse data.

      This ordering scheme is relied on by the string-switching feature. Code in Druntime's core.internal.switch_ relies on this ordering when doing a binary search among case statements.

      Both StringExp should be of the same encoding.

      Parameters

      StringExp se2

      String expression to compare this to

      Return Value

      0 when this is equal to se2, a value greater than 0 if this should be considered greater than se2, and a value less than 0 if this is lesser than se2.

    • Declaration

      const const(char)[] toStringz();

      Convert string contents to a 0 terminated string, allocated by mem.xmalloc().

    • Declaration

      const const(ubyte)[] peekData();

      Get a slice of the data.

    • Declaration

      ubyte[] borrowData();

      Borrow a slice of the data, so the caller can modify it in-place (!)

    • Declaration

      void setData(void* s, size_t len, ubyte sz);

      Set new string data. this becomes the new owner of the data.

  • Declaration

    class TupleExp: dmd.expression.Expression;

    A sequence of expressions

    Discussion

    1. alias AliasSeq(T...) = T; alias Tup = AliasSeq!(3, int, "abc");

  • Declaration

    class ArrayLiteralExp: dmd.expression.Expression;

    [ e1, e2, e3, ... ]

    • Declaration

      Expression basis;

      If !is null, elements[] can be sparse and basis is used for the "default" element value. In other words, non-null elements[i] overrides this 'basis' value.

  • Declaration

    class AssocArrayLiteralExp: dmd.expression.Expression;

    [ key0 : value0, key1 : value1, ... ]

  • Declaration

    enum int stageScrub;

    scrubReturnValue is running

  • Declaration

    enum int stageSearchPointers;

    hasNonConstPointers is running

  • Declaration

    enum int stageOptimize;

    optimize is running

  • Declaration

    enum int stageApply;

    apply is running

  • Declaration

    enum int stageInlineScan;

    inlineScan is running

  • Declaration

    enum int stageToCBuffer;

    toCBuffer is running

  • Declaration

    class StructLiteralExp: dmd.expression.Expression;

    sd( e1, e2, e3, ... )

    • sd

      Declaration

      StructDeclaration sd;

      which aggregate this is for

    • Declaration

      Expressions* elements;

      parallels sd.fields[] with null entries for fields to skip

    • Declaration

      Type stype;

      final type of result (can be different from sd's type)

    • sym

      Declaration

      Symbol* sym;

      back end symbol to initialize with literal

    • Declaration

      StructLiteralExp inlinecopy;

      those fields need to prevent a infinite recursion when one field of struct initialized with 'this' pointer.

    • Declaration

      StructLiteralExp origin;

      pointer to the origin instance of the expression. once a new expression is created, origin is set to 'this'. anytime when an expression copy is created, 'origin' pointer is set to 'origin' pointer value of the original expression.

    • Declaration

      ubyte stageflags;

      anytime when recursive function is calling, 'stageflags' marks with bit flag of current stage and unmarks before return from this function. 'inlinecopy' uses similar 'stageflags' and from multiple evaluation 'doInline' (with infinite recursion) of this expression.

    • Declaration

      bool useStaticInit;

      if this is true, use the StructDeclaration's init symbol

    • Declaration

      bool isOriginal;

      used when moving instances to indicate this is this.origin

    • Declaration

      Expression getField(Type type, uint offset);

      Gets expression at offset of type. Returns NULL if not found.

    • Declaration

      int getFieldIndex(Type type, uint offset);

      Get index of field. Returns -1 if not found.

  • Declaration

    class CompoundLiteralExp: dmd.expression.Expression;

    C11 6.5.2.5 ( type-name ) { initializer-list }

    • Declaration

      Initializer initializer;

      initializer-list

  • Declaration

    class TypeExp: dmd.expression.Expression;

    Mainly just a placeholder

  • Declaration

    class ScopeExp: dmd.expression.Expression;

    Mainly just a placeholder of Package, Module, Nspace, and TemplateInstance (including TemplateMixin)

    Discussion

    A template instance that requires IFTI: foo!tiargs(fargs) // foo!tiargs is left until CallExp::semantic() or resolveProperties()

  • Declaration

    class TemplateExp: dmd.expression.Expression;

    Mainly just a placeholder

  • Declaration

    class NewExp: dmd.expression.Expression;

    newtype(arguments)

    • Declaration

      ArgumentList argumentList();

      Puts the arguments and names into an ArgumentList for easily passing them around. The fields are still separate for backwards compatibility

  • Declaration

    class NewAnonClassExp: dmd.expression.Expression;

    class baseclasses { } (arguments)

  • Declaration

    class SymbolExp: dmd.expression.Expression;

  • Declaration

    class SymOffExp: dmd.expression.SymbolExp;

    Offset from symbol

  • Declaration

    class VarExp: dmd.expression.SymbolExp;

    Variable

  • Declaration

    class OverExp: dmd.expression.Expression;

    Overload Set

  • Declaration

    class FuncExp: dmd.expression.Expression;

    Function/Delegate literal

  • Declaration

    class DeclarationExp: dmd.expression.Expression;

    Declaration of a symbol

    Discussion

    D grammar allows declarations only as statements. However in AST representation it can be part of any expression. This is used, for example, during internal syntax re-writes to inject hidden symbols.

  • Declaration

    class TypeidExp: dmd.expression.Expression;

    typeid(int)

  • Declaration

    class TraitsExp: dmd.expression.Expression;

    _traits(identifier, args...)

  • Declaration

    class HaltExp: dmd.expression.Expression;

    Generates a halt instruction

    Discussion

    assert(0) gets rewritten to this with CHECKACTION.halt

  • Declaration

    class IsExp: dmd.expression.Expression;

    is(targ id tok tspec) is(targ id == tok2)

  • Declaration

    abstract class UnaExp: dmd.expression.Expression;

    Base class for unary operators

    • Declaration

      final Expression incompatibleTypes();

      The type for a unary expression is incompatible. Print error message.

      Return Value

      ErrorExp

    • Declaration

      final void setNoderefOperand();

      Mark the operand as will never be dereferenced, which is useful info for @safe checks. Do before semantic() on operands rewrites them.

  • Declaration

    abstract class BinExp: dmd.expression.Expression;

    Base class for binary operators

    • Declaration

      final Expression incompatibleTypes();

      The types for a binary expression are incompatible. Print error message.

      Return Value

      ErrorExp

    • Declaration

      final void setNoderefOperands();

      Mark the operands as will never be dereferenced, which is useful info for @safe checks. Do before semantic() on operands rewrites them.

  • Declaration

    class BinAssignExp: dmd.expression.BinExp;

    Binary operator assignment, += -= *= etc.

  • Declaration

    class MixinExp: dmd.expression.Expression;

    A string mixin, mixin("x")

  • Declaration

    class ImportExp: dmd.expression.UnaExp;

    An import expression, import("file.txt")

    Discussion

    Not to be confused with module imports, import std.stdio, which is an ImportStatement

    https://dlang.org/spec/expression.html#import_expressions

  • Declaration

    class AssertExp: dmd.expression.UnaExp;

    An assert expression, assert(x == y)

  • Declaration

    class ThrowExp: dmd.expression.UnaExp;

    throw <e1> as proposed by DIP 1034.

    Discussion

    Replacement for the deprecated ThrowStatement that can be nested in other expression.

  • Declaration

    class DotIdExp: dmd.expression.UnaExp;

  • Declaration

    class DotTemplateExp: dmd.expression.UnaExp;

    Mainly just a placeholder

  • Declaration

    class DotVarExp: dmd.expression.UnaExp;

  • Declaration

    class DotTemplateInstanceExp: dmd.expression.UnaExp;

    foo.bar!(args)

  • Declaration

    class DelegateExp: dmd.expression.UnaExp;

  • Declaration

    class DotTypeExp: dmd.expression.UnaExp;

  • Declaration

    struct ArgumentList;

    The arguments of a function call

    Discussion

    Contains a list of expressions. If it is a named argument, the names list has a non-null entry at the same index.

    • Declaration

      const pure nothrow @nogc @safe bool hasNames();

      Return Value

      whether this argument list contains any named arguments

  • Declaration

    class CallExp: dmd.expression.UnaExp;

    • Declaration

      bool inDebugStatement;

      true if this was in a debug statement

    • Declaration

      bool ignoreAttributes;

      don't enforce attributes (e.g. call @gc function in @nogc code)

    • Declaration

      bool isUfcsRewrite;

      the first argument was pushed in here by a UFCS rewrite

    • Declaration

      ArgumentList argumentList();

      Puts the arguments and names into an ArgumentList for easily passing them around. The fields are still separate for backwards compatibility

    • Declaration

      this(const ref Loc loc, FuncDeclaration fd, Expression earg1);

      Instatiates a new function call expression

      Parameters

      Loc loc

      location

      FuncDeclaration fd

      the declaration of the function to call

      Expression earg1

      the function argument

    • Declaration

      static CallExp create(const ref Loc loc, FuncDeclaration fd, Expression earg1);

      Creates a new function call expression

      Parameters

      Loc loc

      location

      FuncDeclaration fd

      the declaration of the function to call

      Expression earg1

      the function argument

  • Declaration

    TypeFunction calledFunctionType(CallExp ce);

    Get the called function type from a call expression

    Parameters

    CallExp ce

    function call expression. Must have had semantic analysis done.

    Return Value

    called function type, or null if error / no semantic analysis done

  • Declaration

    class AddrExp: dmd.expression.UnaExp;

    The 'address of' operator, &p

  • Declaration

    class PtrExp: dmd.expression.UnaExp;

    The pointer dereference operator, *p

  • Declaration

    class NegExp: dmd.expression.UnaExp;

    The negation operator, -x

  • Declaration

    class UAddExp: dmd.expression.UnaExp;

    The unary add operator, +x

  • Declaration

    class ComExp: dmd.expression.UnaExp;

    The bitwise complement operator, ~x

  • Declaration

    class NotExp: dmd.expression.UnaExp;

    The logical not operator, !x

  • Declaration

    class DeleteExp: dmd.expression.UnaExp;

    The delete operator, delete x (deprecated)

  • Declaration

    class CastExp: dmd.expression.UnaExp;

    The type cast operator, cast(T) x

    Discussion

    It's possible to cast to one type while painting to another type

    https://dlang.org/spec/expression.html#cast_expressions

  • Declaration

    class VectorExp: dmd.expression.UnaExp;

  • Declaration

    class VectorArrayExp: dmd.expression.UnaExp;

    e1.array property for vectors.

  • Declaration

    class SliceExp: dmd.expression.UnaExp;

    e1 [lwr .. upr]

    • Declaration

      this(const ref Loc loc, Expression e1, IntervalExp ie);

  • Declaration

    class ArrayLengthExp: dmd.expression.UnaExp;

    The .length property of an array

  • Declaration

    class ArrayExp: dmd.expression.UnaExp;

    e1 [ a0, a1, a2, a3 ,... ]

  • Declaration

    class DotExp: dmd.expression.BinExp;

  • Declaration

    class CommaExp: dmd.expression.BinExp;

    • Declaration

      const bool isGenerated;

      This is needed because AssignExp rewrites CommaExp, hence it needs to trigger the deprecation.

    • Declaration

      bool allowCommaExp;

      Temporary variable to enable / disable deprecation of comma expression depending on the context. Since most constructor calls are rewritting, the only place where false will be passed will be from the parser.

    • Declaration

      static void allow(Expression exp);

      If the argument is a CommaExp, set a flag to prevent deprecation messages

      Discussion

      It's impossible to know from CommaExp.semantic if the result will be used, hence when there is a result (type != void), a deprecation message is always emitted. However, some construct can produce a result but won't use it (ExpStatement and for loop increment). Those should call this function to prevent unwanted deprecations to be emitted.

      Parameters

      Expression exp

      An expression that discards its result. If the argument is null or not a CommaExp, nothing happens.

  • Declaration

    class IntervalExp: dmd.expression.Expression;

    Mainly just a placeholder

  • Declaration

    class DelegatePtrExp: dmd.expression.UnaExp;

    The dg.ptr property, pointing to the delegate's 'context'

    Discussion

    c.f.DelegateFuncptrExp for the delegate's function pointer dg.funcptr

  • Declaration

    class DelegateFuncptrExp: dmd.expression.UnaExp;

    The dg.funcptr property, pointing to the delegate's function

    Discussion

    c.f.DelegatePtrExp for the delegate's function pointer dg.ptr

  • Declaration

    class IndexExp: dmd.expression.BinExp;

    e1 [ e2 ]

  • Declaration

    class PostExp: dmd.expression.BinExp;

    The postfix increment/decrement operator, i++ / i--

  • Declaration

    class PreExp: dmd.expression.UnaExp;

    The prefix increment/decrement operator, ++i / --i

  • Declaration

    class AssignExp: dmd.expression.BinExp;

    The assignment / initialization operator, =

    Note: operator assignment op= has a different base class, BinAssignExp

    • Declaration

      this(const ref Loc loc, Expression e1, Expression e2);

  • Declaration

    class LoweredAssignExp: dmd.expression.AssignExp;

    When an assignment expression is lowered to a druntime call this class is used to store the lowering. It essentially behaves the same as an AssignExp, but it is used to not waste space for other AssignExp that are not lowered to anything.

  • Declaration

    class ConstructExp: dmd.expression.AssignExp;

  • Declaration

    class BlitExp: dmd.expression.AssignExp;

    A bit-for-bit copy from e2 to e1

  • Declaration

    class AddAssignExp: dmd.expression.BinAssignExp;

    x += y

  • Declaration

    class MinAssignExp: dmd.expression.BinAssignExp;

    x -= y

  • Declaration

    class MulAssignExp: dmd.expression.BinAssignExp;

    x *= y

  • Declaration

    class DivAssignExp: dmd.expression.BinAssignExp;

    x /= y

  • Declaration

    class ModAssignExp: dmd.expression.BinAssignExp;

    x %= y

  • Declaration

    class AndAssignExp: dmd.expression.BinAssignExp;

    x &= y

  • Declaration

    class OrAssignExp: dmd.expression.BinAssignExp;

    x |= y

  • Declaration

    class XorAssignExp: dmd.expression.BinAssignExp;

    x ^= y

  • Declaration

    class PowAssignExp: dmd.expression.BinAssignExp;

    x ^^= y

  • Declaration

    class ShlAssignExp: dmd.expression.BinAssignExp;

    x <<= y

  • Declaration

    class ShrAssignExp: dmd.expression.BinAssignExp;

    x >>= y

  • Declaration

    class UshrAssignExp: dmd.expression.BinAssignExp;

    x >>>= y

  • Declaration

    class CatAssignExp: dmd.expression.BinAssignExp;

    The ~= operator.

    Discussion

    It can have one of the following operators:

    EXP.concatenateAssign - appending T[] to T[] EXP.concatenateElemAssign - appending T to T[] EXP.concatenateDcharAssign - appending dchar to T[]

    The parser initially sets it to EXP.concatenateAssign, and semantic() later decides which of the three it will be set to.

  • Declaration

    class CatElemAssignExp: dmd.expression.CatAssignExp;

    The ~= operator when appending a single element

  • Declaration

    class CatDcharAssignExp: dmd.expression.CatAssignExp;

    The ~= operator when appending a single dchar

  • Declaration

    class AddExp: dmd.expression.BinExp;

    The addition operator, x + y

  • Declaration

    class MinExp: dmd.expression.BinExp;

    The minus operator, x - y

  • Declaration

    class CatExp: dmd.expression.BinExp;

    The concatenation operator, x ~ y

  • Declaration

    class MulExp: dmd.expression.BinExp;

    The multiplication operator, x * y

  • Declaration

    class DivExp: dmd.expression.BinExp;

    The division operator, x / y

  • Declaration

    class ModExp: dmd.expression.BinExp;

    The modulo operator, x % y

  • Declaration

    class PowExp: dmd.expression.BinExp;

    The 'power' operator, x ^^ y

  • Declaration

    class ShlExp: dmd.expression.BinExp;

    The 'shift left' operator, x << y

  • Declaration

    class ShrExp: dmd.expression.BinExp;

    The 'shift right' operator, x >> y

  • Declaration

    class UshrExp: dmd.expression.BinExp;

    The 'unsigned shift right' operator, x >>> y

  • Declaration

    class AndExp: dmd.expression.BinExp;

    The bitwise 'and' operator, x & y

  • Declaration

    class OrExp: dmd.expression.BinExp;

    The bitwise 'or' operator, x | y

  • Declaration

    class XorExp: dmd.expression.BinExp;

    The bitwise 'xor' operator, x ^ y

  • Declaration

    class LogicalExp: dmd.expression.BinExp;

  • Declaration

    class CmpExp: dmd.expression.BinExp;

    A comparison operator, < <= > >=

    Discussion

    op is one of: EXP.lessThan, EXP.lessOrEqual, EXP.greaterThan, EXP.greaterOrEqual

    https://dlang.org/spec/expression.html#relation_expressions

  • Declaration

    class InExp: dmd.expression.BinExp;

    The in operator, "a" in ["a": 1]

    Note: x !in y is rewritten to !(x in y) in the parser

    https://dlang.org/spec/expression.html#in_expressions

  • Declaration

    class RemoveExp: dmd.expression.BinExp;

    Associative array removal, aa.remove(arg)

    Discussion

    This deletes the key e1 from the associative array e2

  • Declaration

    class EqualExp: dmd.expression.BinExp;

    == and !=

    Discussion

    EXP.equal and EXP.notEqual

    https://dlang.org/spec/expression.html#equality_expressions

  • Declaration

    class IdentityExp: dmd.expression.BinExp;

    is and !is

    Discussion

    EXP.identity and EXP.notIdentity

    https://dlang.org/spec/expression.html#identity_expressions

  • Declaration

    class CondExp: dmd.expression.BinExp;

    The ternary operator, econd ? e1 : e2

  • Declaration

    pure nothrow @nogc @safe bool isDefaultInitOp(EXP op);

    Return Value

    if this token is the op for a derived DefaultInitExp class.

  • Declaration

    class DefaultInitExp: dmd.expression.Expression;

    A special keyword when used as a function's default argument

    Discussion

    When possible, special keywords are resolved in the parser, but when appearing as a default argument, they result in an expression deriving from this base class that is resolved for each function call.

    1. const x = __LINE__; // resolved in the parser void foo(string file = __FILE__, int line = __LINE__); // DefaultInitExp


    https://dlang.org/spec/expression.html#specialkeywords

  • Declaration

    class FileInitExp: dmd.expression.DefaultInitExp;

    The __FILE__ token as a default argument

  • Declaration

    class LineInitExp: dmd.expression.DefaultInitExp;

    The __LINE__ token as a default argument

  • Declaration

    class ModuleInitExp: dmd.expression.DefaultInitExp;

    The __MODULE__ token as a default argument

  • Declaration

    class FuncInitExp: dmd.expression.DefaultInitExp;

    The __FUNCTION__ token as a default argument

  • Declaration

    class PrettyFuncInitExp: dmd.expression.DefaultInitExp;

    The __PRETTY_FUNCTION__ token as a default argument

  • Declaration

    class ObjcClassReferenceExp: dmd.expression.Expression;

    Objective-C class reference expression.

    Discussion

    Used to get the metaclass of an Objective-C class, NSObject.Class.

  • Declaration

    class GenericExp: dmd.expression.Expression;

    C11 6.5.1.1 Generic Selection For ImportC

    • Declaration

      Expression cntlExp;

      controlling expression of a generic selection (not evaluated)

    • Declaration

      Types* types;

      type-names for generic associations (null entry for default)

    • Declaration

      Expressions* exps;

      1:1 mapping of typeNames to exps

  • Declaration

    Modifiable checkModifiable(Expression exp, Scope* sc, ModifyFlags flag = ModifyFlags.none);

    Parameters: sc: scope flag: 1: do not issue error message for invalid modification 2: the exp is a DotVarExp and a subfield of the leftmost variable is modified

    Return Value

    Whether the type is modifiable

  • Declaration

    bool isArrayConstruction(const Identifier id);

    Verify if the given identifier is d_array{,set}ctor.

    Parameters

    Identifier id

    the identifier to verify

    Return Value

    true if the identifier corresponds to a construction runtime hook, false otherwise.