Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

dmd.expressionsem

Compiler implementation of the D programming language.
Authors:
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.