FuncDeclaration

buildEnsureRequire void buildEnsureRequire(): Rewrite contracts as statements.
buildResultVar void buildResultVar(Scope* sc, Type tret): Declare result variable lazily.
canInferAttributes bool canInferAttributes(Scope* sc): Decide if attributes for this function can be inferred from examining the function body.
checkClosure bool checkClosure(): Check that the function contains any closure. If it's @nogc, report suitable errors. This is mostly consistent with FuncDeclaration::needsClosure().
checkDmain void checkDmain(): Check parameters and return type of D main() function. Issue error messages.
checkForwardRef bool checkForwardRef(Loc loc): Check that this function type is properly resolved. If not, report "forward reference error" and return true.
checkNRVO bool checkNRVO(): Check all return statements for a function to verify that returning using NRVO is possible.
checkNestedReference bool checkNestedReference(Scope* sc, 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.
declareThis void declareThis(Scope* sc): Creates and returns the hidden parameters for this function declaration.
findTemplateDeclRoot TemplateDeclaration findTemplateDeclRoot(): find function template root in overload list
findVtblIndex int findVtblIndex(Dsymbols* vtbl, int dim): Find index of function in vtbl[0..dim] that this function overrides. Prefer an exact match to a covariant one.
functionSemantic bool functionSemantic(): Resolve forward reference of function signature - parameter types, return type, and attributes.
functionSemantic3 bool functionSemantic3(): Resolve forward reference of function body. Returns false if any errors exist in the body.
getLevel int getLevel(FuncDeclaration fd, int intypeof): Determine lexical level difference from this to nested function fd.
getLevelAndCheck int getLevelAndCheck(Loc loc, Scope* sc, FuncDeclaration fd, Declaration decl): Determine lexical level difference from this to nested function fd. Issue error if this cannot call fd.
getParameterList ParameterList getParameterList()
hasNestedFrameRefs bool hasNestedFrameRefs(): Determine if function's variables are referenced by a function nested within it.
inUnittest bool inUnittest(): Returns true if function was declared directly or indirectly in a unittest block
initInferAttributes void initInferAttributes(): Initialize for inferring the attributes of this function.
isAbstract bool isAbstract(): Override so it can work even if semantic() hasn't yet been run.
isNested bool isNested(): Determine if function needs a static frame pointer.
isReturnIsolated bool isReturnIsolated(): See if pointers from function parameters, mutable globals, or uplevel functions could leak into return value.
isThis inout(AggregateDeclaration) isThis(): Determine if function is a non-static member function that has an implicit 'this' expression.
isTypeIsolated bool isTypeIsolated(Type t)
bool isTypeIsolated(Type t, StringTable!Type parentTypes): See if pointers from function parameters, mutable globals, or uplevel functions could leak into type t.
isUnique bool isUnique()
leastAsSpecialized MATCH leastAsSpecialized(FuncDeclaration g): Determine partial specialization order of 'this' vs g. This is very similar to TemplateDeclaration::leastAsSpecialized().
mergeFensure Statement mergeFensure(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.
mergeFrequire Statement mergeFrequire(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.
mergeFrequireInclusivePreview Statement mergeFrequireInclusivePreview(Statement sf, Expressions* params): Merge into this function the 'in' contracts of all it overrides.
needsClosure bool needsClosure(): Look at all the variables in this function that are referenced by nested functions, and determine if a closure needs to be created for them.
overloadExactMatch FuncDeclaration overloadExactMatch(Type t): Find function in overload list that exactly matches t.
overloadInsert bool overloadInsert(Dsymbol s): Overload this FuncDeclaration with the new one f. Return true if successful; i.e. no conflict.
overloadModMatch FuncDeclaration overloadModMatch(Loc loc, Type tthis, bool hasOverloads): Find function in overload list that matches to the 'this' modifier. There's four result types.
overrideInterface BaseClass* overrideInterface(): If function a function in a base class, return that base class.
overrides int overrides(FuncDeclaration fd): Determine if 'this' overrides fd. Return !=0 if it does.
searchLabel LabelDsymbol searchLabel(Identifier ident): Labels are in a separate scope, one per function.
setGC bool setGC(): The function is doing something that may allocate with the GC, so mark it as not nogc (not no-how).
setImpure bool setImpure(): The function is doing something impure, so mark it as impure. If there's a purity error, return true.
setUnsafe bool setUnsafe(): The function is doing something unsafe, so mark it as unsafe. If there's a safe error, return true.
toFullSignature const(char)* toFullSignature(): for diagnostics, e.g. 'int foo(int x, int y) pure'

Static functions

genCfunc FuncDeclaration genCfunc(Parameters* fparams, Type treturn, const(char)* name, StorageClass stc): Generate a FuncDeclaration for a runtime library function.
needsFensure bool needsFensure(FuncDeclaration fd): Determine whether an 'out' contract is declared inside the given function or any of its overrides.

Variables

builtin BUILTIN builtin;: set if this is a known, builtin function we can evaluate at compile time
closureVars VarDeclarations closureVars;: local variables in this function which are referenced by nested functions (They'll get put into the "closure" for this function.)
eh_none bool eh_none;: true if no exception unwinding is needed
endloc Loc endloc;: location of closing curly bracket
fbody Statement fbody;: function body
fdensure FuncDeclaration fdensure;: function that does the out contract
fdensureParams Expressions* fdensureParams;: argument list for __ensure
fdrequire FuncDeclaration fdrequire;: function that does the in contract
fdrequireParams Expressions* fdrequireParams;: argument list for __require
fensure Statement fensure;: lowered out contract
fensures Ensures* fensures;: out contracts
fes ForeachStatement fes;: if foreach body, this is the foreach
flags uint flags;: FUNCFLAG.xxxxx
foverrides FuncDeclarations foverrides;: functions this function overrides
frequire Statement frequire;: lowered in contract
frequires Statements* frequires;: in contracts
generated bool generated;: true if function was generated by the compiler rather than
gotos GotoStatements* gotos;: Gotos with forward references
hasAlwaysInlines bool hasAlwaysInlines;: supplied by the user +//// contains references to functions that must be inline
hasReturnExp int hasReturnExp;: 1 if there's a return exp; statement 2 if there's a throw statement 4 if there's an assert(0) 8 if there's inline asm 16 if there are multiple return statements
inferRetType bool inferRetType;: true if return type is to be inferred
inlineNest int inlineNest;: !=0 if nested inline
inlineStatusStmt ILS inlineStatusStmt;: not set before the glue layer
interfaceVirtual BaseClass* interfaceVirtual;: if virtual, but only appears in base interface vtbl[]
introducing bool introducing;: true if 'introducing' function
isCrtCtorDtor ubyte isCrtCtorDtor;: has attribute pragma(crt_constructor(1)/crt_destructor(2))
isThis2 bool isThis2;: has a dual-context 'this' parameter
labtab DsymbolTable labtab;: statement label symbol table
mangleString const(char)* mangleString;: mangled symbol created from mangleExact()
naked bool naked;: true if naked
nrvo_can bool nrvo_can;: true means we can do NRVO
nrvo_var VarDeclaration nrvo_var;: variable to replace with shidden
objc ObjcFuncDeclaration objc;: Data for a function declaration that is needed for the Objective-C integration.
outerVars VarDeclarations outerVars;: Outer variables which are referenced by this nested function (the inverse of closureVars)
overnext Dsymbol overnext;: next in overload list
overnext0 FuncDeclaration overnext0;: next in overload list (only used during IFTI)
parameters VarDeclarations* parameters;: Array of VarDeclaration's for parameters
returnLabel LabelDsymbol returnLabel;: where the return goes
semantic3Errors bool semantic3Errors;: true if errors in semantic3 this function's frame ptr
shidden Symbol* shidden;: hidden pointer passed to function
siblingCallers FuncDeclarations siblingCallers;: Sibling nested functions which called this one
storage_class2 StorageClass storage_class2;: storage class for template onemember's
tintro Type tintro;: if !=NULL, then this is the type of the 'introducing' function this one is overriding
tookAddressOf int tookAddressOf;: set if someone took the address of this function
v_argptr VarDeclaration v_argptr;: '_argptr' variable
v_arguments VarDeclaration v_arguments;: '_arguments' parameter
vresult VarDeclaration vresult;: result variable for out contracts
vtblIndex int vtblIndex;: for member functions, index into vtbl[]
vthis VarDeclaration vthis;: 'this' parameter (member and nested)

Inherited Members

From Declaration

checkDisabled bool checkDisabled(Loc loc, Scope* sc, bool isAliasedDeclaration): Issue an error if an attempt to call a disabled method is made
checkModify Modifiable checkModify(Loc loc, Scope* sc, Expression e1, int flag): Check to see if declaration can be modified in this context (sc). Issue error if not.