dmd.funcsem

void funcDeclarationSemantic(Scope* sc, FuncDeclaration funcdecl);

Main semantic routine for functions.

bool functionSemantic(FuncDeclaration fd);

Resolve forward reference of function signature - parameter types, return type, and attributes.

Parameters:

FuncDeclaration fd

function declaration

Returns:

false if any errors exist in the signature.

bool functionSemantic3(FuncDeclaration fd);

Resolve forward reference of function body. Returns false if any errors exist in the body.

void declareThis(FuncDeclaration fd, Scope* sc);

Creates and returns the hidden parameters for this function declaration.

Hidden parameters include the this parameter of a class, struct or nested function and the selector parameter for Objective-C methods.

bool checkForwardRef(FuncDeclaration fd, const ref Loc loc);

Check that this function type is properly resolved. If not, report "forward reference error" and return true.

int findVtblIndex(FuncDeclaration fd, Dsymbol[] vtbl);

Find index of function in vtbl[0..length] that this function overrides. Prefer an exact match to a covariant one.

Parameters:

FuncDeclaration fd	function
Dsymbol[] vtbl	vtable to use

Returns:

-1 didn't find one -2 can't determine because of forward references

BaseClass* overrideInterface(FuncDeclaration fd);

If function is a function in a base class, return that base class.

Parameters:

FuncDeclaration fd

function

Returns:

base class if overriding, null if not

enum FuncResolveFlag: ubyte;

Flag used by resolveFuncCall.

standard

issue error messages, solve the call.

quiet

do not issue error message on no match, just return null.

overloadOnly

only resolve overloads, i.e. do not issue error on ambiguous

ufcs

matches and need explicit this.

trying to resolve UFCS call

FuncDeclaration resolveFuncCall(const ref Loc loc, Scope* sc, Dsymbol s, Objects* tiargs, Type tthis, ArgumentList argumentList, FuncResolveFlag flags);

Given a symbol that could be either a FuncDeclaration or a function template, resolve it to a function symbol.

Parameters:

Loc loc	instantiation location
Scope* sc	instantiation scope
Dsymbol s	instantiation symbol
Objects* tiargs	initial list of template arguments
Type tthis	if !NULL, the this argument type
ArgumentList argumentList	arguments to function
FuncResolveFlag flags	see FuncResolveFlag.

Returns:

if match is found, then function symbol, else null

Expression addInvariant(AggregateDeclaration ad, VarDeclaration vthis);

Generate Expression to call the invariant.

Input ad aggregate with the invariant vthis variable with 'this'

Returns:

void expression that calls the invariant

FuncDeclaration overloadExactMatch(FuncDeclaration thisfd, Type t);

Find function in overload list that exactly matches t.

FuncDeclaration overloadModMatch(FuncDeclaration thisfd, const ref Loc loc, Type tthis, ref bool hasOverloads);

Find function in overload list that matches to the 'this' modifier. There's four result types.

1. If the 'tthis' matches only one candidate, it's an "exact match". Returns the function and 'hasOverloads' is set to false. eg. If 'tthis" is mutable and there's only one mutable method.
2. If there's two or more match candidates, but a candidate function will be a "better match". Returns the better match function but 'hasOverloads' is set to true. eg. If 'tthis' is mutable, and there's both mutable and const methods, the mutable method will be a better match.
3. If there's two or more match candidates, but there's no better match, Returns null and 'hasOverloads' is set to true to represent "ambiguous match". eg. If 'tthis' is mutable, and there's two or more mutable methods.
4. If there's no candidates, it's "no match" and returns null with error report. e.g. If 'tthis' is const but there's no const methods.

int getLevelAndCheck(FuncDeclaration fd, const ref Loc loc, Scope* sc, FuncDeclaration target, Declaration decl);

Determine lexical level difference from fd to nested function target. Issue error if fd cannot call target.

Parameters:

FuncDeclaration fd	function
Loc loc	location for error messages
Scope* sc	context
FuncDeclaration target	target of call
Declaration decl	The Declaration that triggered this check. Used to provide a better error message only.

Returns:

0 same level

0 decrease nesting by number -1 increase nesting by 1 (target is nested within 'fd') LevelError error

bool canInferAttributes(FuncDeclaration fd, Scope* sc);

Decide if attributes for this function can be inferred from examining the function body.

Returns:

true if can

bool checkNestedReference(FuncDeclaration fd, Scope* sc, const ref Loc loc);

In the current function, we are calling 'this' function.

1. Check to see if the current function can call 'this' function, issue error if not.
2. If the current function is not the parent of 'this' function, then add the current function to the list of siblings of 'this' function.
3. If the current function is a literal, and it's accessing an uplevel scope, then mark it as a delegate.

Returns true if error occurs.

void buildResultVar(FuncDeclaration fd, Scope* sc, Type tret);

Declare result variable lazily.

Statement mergeFrequire(FuncDeclaration fd, Statement sf, Expressions* params);

Merge into this function the 'in' contracts of all it overrides. 'in's are OR'd together, i.e. only one of them needs to pass.

Statement mergeFrequireInclusivePreview(FuncDeclaration fd, Statement sf, Expressions* params);

Merge into this function the 'in' contracts of all it overrides.

void buildEnsureRequire(FuncDeclaration thisfd);

Rewrite contracts as statements.

Statement mergeFensure(FuncDeclaration fd, Statement sf, Identifier oid, Expressions* params);

Merge into this function the 'out' contracts of all it overrides. 'out's are AND'd together, i.e. all of them need to pass.

void modifyReturns(FuncLiteralDeclaration fld, Scope* sc, Type tret);

Modify all expression type of return statements to tret.

On function literals, return type may be modified based on the context type after its semantic3 is done, in FuncExp::implicitCastTo.

A function() dg = (){ return new B(); } // OK if is(B : A) == true

If B to A conversion is convariant that requires offseet adjusting, all return statements should be adjusted to return expressions typed A.

bool isRootTraitsCompilesScope(Scope* sc);

When a traits(compiles) is used on a function literal call we need to take into account if the body of the function violates any attributes, however, we must not affect the attribute inference on the outer function. The attributes of the function literal still need to be inferred, therefore we need a way to check for the scope that the traits compiles introduces.

Parameters:

Scope* sc

scope to be checked for

Returns:

true if the provided scope is the root of the traits compiles list of scopes.

bool setUnsafe(Scope* sc, bool gag = false, Loc loc = Loc.init, const(char)* fmt = null, RootObject arg0 = null, RootObject arg1 = null, RootObject arg2 = null);

A statement / expression in this scope is not @safe, so mark the enclosing function as @system

Parameters:

Scope* sc	scope that the unsafe statement / expression is in
bool gag	surpress error message (used in escape.d)
Loc loc	location of error
const(char)* fmt	printf-style format string
RootObject arg0	(optional) argument for first %s format specifier
RootObject arg1	(optional) argument for second %s format specifier
RootObject arg2	(optional) argument for third %s format specifier

Returns:

whether there's a safe error

bool setUnsafePreview(Scope* sc, FeatureState fs, bool gag, Loc loc, const(char)* msg, RootObject arg0 = null, RootObject arg1 = null, RootObject arg2 = null);

Like setUnsafe, but for safety errors still behind preview switches

Given a FeatureState fs, for example dip1000 / dip25 / systemVariables, the behavior changes based on the setting:

• In case of -revert=fs, it does nothing.
• In case of -preview=fs, it's the same as setUnsafe
• By default, print a deprecation in @safe functions, or store an attribute violation in inferred functions.

Parameters:

Scope* sc	used to find affected function/variable, and for checking whether we are in a deprecated / speculative scope
FeatureState fs	feature state from the preview flag
bool gag	surpress error message
Loc loc	location of error
const(char)* msg	printf-style format string
RootObject arg0	(optional) argument for first %s format specifier
RootObject arg1	(optional) argument for second %s format specifier
RootObject arg2	(optional) argument for third %s format specifier

Returns:

whether an actual safe error (not deprecation) occured