dmd.funcsem

bool onlyOneMain(FuncDeclaration fd);

Only one entry point function is allowed. Print error if more than one.

Parameters:

FuncDeclaration fd

a "main" function

Returns:

true if haven't seen "main" before

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, 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(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.

int overrides(FuncDeclaration fd1, FuncDeclaration fd2);

Determine if fd1 overrides fd2. Return !=0 if it does.

MATCH leastAsSpecialized(FuncDeclaration f, FuncDeclaration g, Identifiers* names);

Determine partial specialization order of functions f vs g. This is very similar to TemplateDeclaration::leastAsSpecialized().

Parameters:

FuncDeclaration f	first function
FuncDeclaration g	second function
Identifiers* names	names of parameters

Returns:

match 'this' is at least as specialized as g 0 g is more specialized than 'this'

FuncDeclaration overloadModMatch(FuncDeclaration thisfd, 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, 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.

Parameters:

FuncDeclaration fd	function to infer attributes for
Scope* sc	context

Returns:

true if can

bool checkNestedFuncReference(FuncDeclaration fd, Scope* sc, Loc loc);

In the current function 'sc.func', we are calling 'fd'.

1. Check to see if the current function can call 'fd' , issue error if not.
2. If the current function is not the parent of 'fd' , then add the current function to the list of siblings of 'fd' .
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.

@safe bool needsFensure(FuncDeclaration fd);

Determine whether an 'out' contract is declared inside the given function or any of its overrides.

Parameters:

FuncDeclaration fd

the function to search

Returns:

true found an 'out' contract

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.

@safe 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 checkNRVO(FuncDeclaration fd);

Check all return statements for a function to verify that returning using NRVO is possible.

Returns:

false if the result cannot be returned by hidden reference.

bool setImpure(FuncDeclaration fd, Loc loc, const(char)* fmt, RootObject[] args...);

The function is doing something impure, so mark it as impure.

Parameters:

FuncDeclaration fd	function declaration to mark
Loc loc	location of impure action
const(char)* fmt	format string for error message
RootObject[] args	argument to format string

Returns:

true if there's a purity error

bool traverseIndirections(Type ta, Type tb);

Performs type-based alias analysis between a newly created value and a pre- existing memory reference:

Assuming that a reference A to a value of type ta was available to the code that created a reference B to a value of type tb, it returns whether B might alias memory reachable from A based on the types involved (either directly or via any number of indirections in either A or B).

This relation is not symmetric in the two arguments. For example, a a const(int) reference can point to a pre-existing int, but not the other way round.

Examples:

ta, tb, result const(int), int, false int, const(int), true int, immutable(int), false const(immutable(int), immutable(int)), false // BUG: returns true

Parameters:

Type ta	value type being referred to
Type tb	referred to value type that could be constructed from ta

Returns:

true if reference to tb is isolated from reference to ta

bool isTypeIsolatedIndirect(FuncDeclaration fd, Type t);

Parameters:

FuncDeclaration fd	function declaration to check
Type t	type of object to test one level of indirection down

Returns:

true if an object typed t has no indirections which could have come from the function's parameters, mutable globals, or uplevel functions.

bool isReturnIsolated(FuncDeclaration fd);

See if pointers from function parameters, mutable globals, or uplevel functions could leak into return value.

Returns:

true if the function return value is isolated from any inputs to the function

bool isTypeIsolated(FuncDeclaration fd, Type t);

bool isTypeIsolated(FuncDeclaration fd, Type t, ref StringTable!Type parentTypes);

See if pointers from function parameters, mutable globals, or uplevel functions could leak into type t.

Parameters:

Type t

type to check if it is isolated

Returns:

true if t is isolated from any inputs to the function

int overloadApply(Dsymbol fstart, scope int delegate(Dsymbol) dg, Scope* sc = null);

Visit each overloaded function/template in turn, and call dg(s) on it. Exit when no more, or dg(s) returns nonzero.

Parameters:

Dsymbol fstart	symbol to start from
int delegate(Dsymbol) dg	the delegate to be called on the overload
Scope* sc	context used to check if symbol is accessible (and therefore visible), can be null

Returns:

==0 continue !=0 done (and the return value from the last dg() call)