dmd.expressionsem

Compiler implementation of the D programming language.

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

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

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.

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(Expressions* exps, Scope* sc, bool preserveErrors = false);

Perform semantic() on an array of Expressions.

Expression resolvePropertiesOnly(Scope* sc, Expression e1);

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

Expression symbolToExp(Dsymbol s, ref const 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

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.

bool checkSharedAccess(Expression e, Scope* sc);

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

Parameters:

Expression e	expression to check
Scope* sc	context

Returns:

true on error

Expression getThisSkipNestedFuncs(ref const 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(ref const 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(ref const 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.