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

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

`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.

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

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

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

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