# dmd.expressionsem

Semantic analysis of expressions.

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

#### Authors

Walter Bright

#### License

Boost License 1.0

Source: expressionsem.d

Documentation: https://dlang.org/phobos/dmd_expressionsem.html

Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/expressionsem.d

- `expressionsToString`

  #### Declaration

  `bool `expressionsToString`(ref OutBuffer `buf`, Scope* `sc`, Expressions* `exps`);`

  Perform semantic analysis and CTFE on expressions to produce a string.

  #### Parameters

  `OutBuffer `buf`` | append generated string to buffer
  `Scope* `sc`` | context
  `Expressions* `exps`` | array of Expressions

  #### Return Value

  `true` on error

- `semanticString`

  #### Declaration

  `StringExp `semanticString`(Scope* `sc`, Expression `exp`, const char* `s`);`

  Resolve ``exp`` as a compile-time known string.

  #### Parameters

  `Scope* `sc`` | scope
  `Expression `exp`` | Expression which expected as a string
  `char* `s`` | What the string is expected for, will be used in error diagnostic.

  #### Return Value

  String literal, or `null` if error happens.

- `resolveOpDollar`

  #### Declaration

  `Expression `resolveOpDollar`(Scope* `sc`, ArrayExp `ae`, Expression* `pe0`);`

  Runs semantic on `ae`.arguments. Declares temporary variables if '$' was used.

- `resolveOpDollar`

  #### Declaration

  `Expression `resolveOpDollar`(Scope* `sc`, ArrayExp `ae`, IntervalExp `ie`, Expression* `pe0`);`

  Runs semantic on se.lwr and se.upr. Declares a temporary variable if '$' was used.

  #### Return Value

  `ae`, or ErrorExp if errors occurred

- `arrayExpressionSemantic`

  #### Declaration

  `bool `arrayExpressionSemantic`(Expressions* `exps`, Scope* `sc`, bool `preserveErrors` = false);`

  Perform semantic() on an array of Expressions.

- `resolvePropertiesOnly`

  #### Declaration

  `Expression `resolvePropertiesOnly`(Scope* `sc`, Expression `e1`);`

  If `e1` is a property function (template), resolve it.

- `symbolToExp`

  #### Declaration

  `Expression `symbolToExp`(Dsymbol `s`, const ref Loc `loc`, Scope* `sc`, bool `hasOverloads`);`

  Turn symbol ``s`` into the expression it represents.

  #### Parameters

  `Dsymbol `s`` | symbol to resolve
  `Loc `loc`` | location of use of ``s``
  `Scope* `sc`` | context
  `bool `hasOverloads`` | applies if ``s`` represents a function. `true` means it'`s` overloaded and will be resolved later, `false` means it'`s` the exact function symbol.

  #### Return Value

  ``s`` turned into an expression, `ErrorExp` if an error occurred

- `resolveIsPackage`

  #### Declaration

  `Package `resolveIsPackage`(Dsymbol `sym`);`

  Determines whether a symbol represents a module or package (Used as a helper for is(type == module) and is(type == package))

  #### Parameters

  `Dsymbol `sym`` | the symbol to be checked

  #### Return Value

  the symbol which ``sym`` represents (or `null` if it doesn't represent a `Package`)

- `trySemantic`

  #### Declaration

  `Expression `trySemantic`(Expression `exp`, Scope* `sc`);`

  Try to run semantic routines. If they fail, return NULL.

- `unaSemantic`

  #### Declaration

  `Expression `unaSemantic`(UnaExp `e`, Scope* `sc`);`

  Helper function for easy error propagation. If error occurs, returns ErrorExp. Otherwise returns NULL.

- `binSemantic`

  #### Declaration

  `Expression `binSemantic`(BinExp `e`, Scope* `sc`);`

  Helper function for easy error propagation. If error occurs, returns ErrorExp. Otherwise returns NULL.

- `semanticY`

  #### Declaration

  `Expression `semanticY`(DotIdExp `exp`, Scope* `sc`, int `flag`);`

  Resolve properties, i.e. `e1.ident`, without seeing UFCS.

  #### Parameters

  `DotIdExp `exp`` | expression to resolve
  `Scope* `sc`` | context
  `int `flag`` | if 1 then do not emit error messages, just return `null`

  #### Return Value

  resolved expression, `null` if error

- `checkSharedAccess`

  #### Declaration

  `bool `checkSharedAccess`(Expression `e`, Scope* `sc`, bool `returnRef` = false);`

  If expression is shared, check that we can access it. Give error message if not.

  #### Parameters

  `Expression `e`` | expression to check
  `Scope* `sc`` | context
  `bool `returnRef`` | Whether this expression is for a `return` statement off a `ref` function, in which case a single level of dereference is allowed (`e`.g. `shared(int)*`).

  #### Return Value

  `true` on error

- `checkAddressVar`

  #### Declaration

  `bool `checkAddressVar`(Scope* `sc`, Expression `exp`, VarDeclaration `v`);`

  Determine if ``exp``, which gets its address taken, can do so safely.

  #### Parameters

  `Scope* `sc`` | context
  `Expression `exp`` | expression having its address taken
  `VarDeclaration `v`` | the variable getting its address taken

  #### Return Value

  `true` if ok, `false` for error

- `getThisSkipNestedFuncs`

  #### Declaration

  `Expression `getThisSkipNestedFuncs`(const ref Loc `loc`, Scope* `sc`, Dsymbol `s`, AggregateDeclaration `ad`, Expression `e1`, Type `t`, Dsymbol `var`, bool `flag` = false);`

  Helper function for `getRightThis()`. Gets `this` of the next outer aggregate.

  #### Parameters

  `Loc `loc`` | location to use for error messages
  `Scope* `sc`` | context
  `Dsymbol `s`` | the parent symbol of the existing `this`
  `AggregateDeclaration `ad`` | struct or class we need the correct `this` for
  `Expression `e1`` | existing `this`
  `Type `t`` | type of the existing `this`
  `Dsymbol `var`` | the specific member of `ad` we're accessing
  `bool `flag`` | if `true`, return `null` instead of throwing an error

  #### Return Value

  Expression representing the `this` for the `var`

- `makeThis2Argument`

  #### Declaration

  `VarDeclaration `makeThis2Argument`(const ref Loc `loc`, Scope* `sc`, FuncDeclaration `fd`);`

  Make a dual-context container for use as a `this` argument.

  #### Parameters

  `Loc `loc`` | location to use for error messages
  `Scope* `sc`` | current scope
  `FuncDeclaration `fd`` | target function that will take the `this` argument

  #### Return Value

  Temporary closure variable.

  Note: The function ``fd`` is added to the nested references of the newly created variable such that a closure is made for the variable when the address of ``fd`` is taken.

- `verifyHookExist`

  #### Declaration

  `bool `verifyHookExist`(const ref Loc `loc`, ref Scope `sc`, Identifier `id`, string `description`, Identifier `module_` = Id.object);`

  Make sure that the runtime hook ``id`` exists.

  #### Parameters

  `Loc `loc`` | location to use for error messages
  `Scope `sc`` | current scope
  `Identifier `id`` | the hook identifier
  `string `description`` | what the hook does
  `Identifier `module_`` | what module the hook is located in

  #### Return Value

  a `bool` indicating if the hook is present.

- `getVarExp`

  #### Declaration

  `Expression `getVarExp`(EnumMember `em`, const ref Loc `loc`, Scope* `sc`);`

  Returns ``em`` as a VariableExp

  #### Parameters

  `EnumMember `em`` | the EnumMember to wrap
  `Loc `loc`` | location of use of `em`
  `Scope* `sc`` | scope of use of `em`

  #### Return Value

  VarExp referenceing ``em`` or ErrorExp if ``em`` if disabled/deprecated

- `toBoolean`

  #### Declaration

  `Expression `toBoolean`(Expression `exp`, Scope* `sc`);`

  Try to treat ``exp`` as a boolean,

  #### Parameters

  `Expression `exp`` | the expression
  `Scope* `sc`` | scope to evalute ``exp`` in

  #### Return Value

  Modified expression on success, ErrorExp on error