dmd.expressionsem

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

Returns:

true on error

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

Returns:

Found function if it satisfies isThis(), otherwise null

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.

Returns:

String literal, or null if error happens.

StringExp toUTF8(StringExp se, Scope* sc);

Convert string to char[].

TupleDeclaration isAliasThisTuple(Expression e);

Expand alias this tuples.

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

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

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.

Returns:

ae, or ErrorExp if errors occurred

bool arrayExpressionSemantic(Expression[] exps, Scope* sc, bool preserveErrors = false);

Perform semantic() on an array of Expressions.

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

Returns:

The expression that copy constructs or moves the value.

Expression valueNoDtor(Expression e);

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

Expression resolvePropertiesOnly(Scope* sc, Expression e1);

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

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.

Returns:

s turned into an expression, ErrorExp if an error occurred

void checkOverriddenDtor(FuncDeclaration f, Scope* sc, const ref Loc loc, 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:

FuncDeclaration f	potential DtorDeclaration
Scope* sc	scope
Loc loc	location
bool function(DtorDeclaration) check	current check (e.g. whether it's pure)
string checkName	the kind of check (e.g. "pure")

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

Returns:

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

Expression trySemantic(Expression exp, Scope* sc);

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

Expression unaSemantic(UnaExp e, Scope* sc);

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

Expression binSemantic(BinExp e, Scope* sc);

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

Expression dotIdSemanticProp(DotIdExp exp, Scope* sc, bool gag);

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

Parameters:

DotIdExp exp	expression to resolve
Scope* sc	context
bool gag	do not emit error messages, just return null

Returns:

resolved expression, null if error

Expression dotTemplateSemanticProp(DotTemplateInstanceExp exp, Scope* sc, bool gag);

Resolve e1.ident!tiargs without seeing UFCS.

Parameters:

DotTemplateInstanceExp exp	the DotTemplateInstanceExp to resolve
Scope* sc	the semantic scope
bool gag	stop "not a property" error and return null.

Returns:

null if error or not found, or the resolved expression.

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)*).

Returns:

true on error

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

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

Expression addDtorHook(Expression e, 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.

Expression toLvalue(Expression _this, Scope* sc, const(char)* action);

Try to convert an expression to be an lvalue.

Give error if we're not an lvalue.

Parameters:

Expression _this	expression to convert
Scope* sc	scope
const(char)* action	for error messages, what the lvalue is needed for (e.g. take address of for &x, modify for x++)

Returns:

converted expression, or ErrorExp on error

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

Returns:

Whether the type is modifiable

Expression modifiableLvalue(Expression _this, Scope* sc);

Similar to toLvalue, but also enforce it is mutable or raise an error.

Parameters:

Expression _this	Expression to convert
Scope* sc	scope

Returns:

_this converted to an lvalue, or an ErrorExp

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

Returns:

true if ok, false for error

bool checkAddressable(Expression e, Scope* sc);

This check ensures that the object in exp can have its address taken, or issue a diagnostic error.

Parameters:

Expression e	expression to check
Scope* sc	context

Returns:

true if the expression is addressable

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

Returns:

Expression representing the this for the var

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

Returns:

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.

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

Returns:

a bool indicating if the hook is present.

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

Returns:

VarExp referenceing em or ErrorExp if em if disabled/deprecated

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

Returns:

Modified expression on success, ErrorExp on error

bool evalStaticCondition(Scope* sc, Expression original, Expression e, out bool errors, Expressions* negatives = null);

Semantically analyze and then evaluate a static condition at compile time. This is special because short circuit operators &&, || and ?: at the top level are not semantically analyzed if the result of the expression is not necessary.

Parameters:

Scope* sc	instantiating scope
Expression original	original expression, for error messages
Expression e	resulting expression
bool errors	set to true if errors occurred
Expressions* negatives	array to store negative clauses

Returns:

true if evaluates to true