PostBlitDeclaration

extern (C++) final
class PostBlitDeclaration : FuncDeclaration {}

Inherited Members

From FuncDeclaration

fbody
Statement fbody;

function body

foverrides
FuncDeclarations foverrides;

functions this function overrides

mangleString
const(char)* mangleString;

mangled symbol created from mangleExact()

vresult
VarDeclaration vresult;

result variable for out contracts

returnLabel
LabelDsymbol returnLabel;

where the return goes

isTypeIsolatedCache
bool[size_t] isTypeIsolatedCache;

cache for the potentially very expensive isTypeIsolated check

vthis
VarDeclaration vthis;

'this' parameter (member and nested)

v_arguments
VarDeclaration v_arguments;

'_arguments' parameter

v_argptr
VarDeclaration v_argptr;

'_argptr' variable

parameters
VarDeclarations* parameters;

Array of VarDeclaration's for parameters

labtab
DsymbolTable labtab;

statement label symbol table

overnext
Dsymbol overnext;

next in overload list

overnext0
FuncDeclaration overnext0;

next in overload list (only used during IFTI)

endloc
Loc endloc;

location of closing curly bracket

vtblIndex
int vtblIndex;

for member functions, index into vtbl[]

inlineNest
int inlineNest;

!=0 if nested inline

fes
ForeachStatement fes;

if foreach body, this is the foreach

interfaceVirtual
BaseClass* interfaceVirtual;

if virtual, but only appears in base interface vtbl[]

tintro
Type tintro;

if !=NULL, then this is the type of the 'introducing' function this one is overriding

storage_class2
StorageClass storage_class2;

storage class for template onemember's

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

nrvo_var
VarDeclaration nrvo_var;

variable to replace with shidden

shidden
Symbol* shidden;

hidden pointer passed to function

gotos
GotoStatements* gotos;

Gotos with forward references

alignSectionVars
VarDeclarations* alignSectionVars;

local variables with alignment needs larger than stackAlign

salignSection
Symbol* salignSection;

pointer to aligned section, if any

builtin
BUILTIN builtin;

set if this is a known, builtin function we can evaluate at compile time

tookAddressOf
int tookAddressOf;

set if someone took the address of this function

closureVars
VarDeclarations closureVars;

local variables in this function which are referenced by nested functions (They'll get put into the "closure" for this function.)

outerVars
VarDeclarations outerVars;

Outer variables which are referenced by this nested function (the inverse of closureVars)

siblingCallers
FuncDeclarations siblingCallers;

Sibling nested functions which called this one

safetyViolation
AttributeViolation* safetyViolation;

In case of failed @safe inference, store the error that made the function @system for better diagnostics

objc
ObjcFuncDeclaration objc;

Data for a function declaration that is needed for the Objective-C integration.

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.

checkForwardRef
bool checkForwardRef(Loc loc)

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

declareThis
void declareThis(Scope* sc)

Creates and returns the hidden parameters for this function declaration.

overrides
int overrides(FuncDeclaration fd)

Determine if 'this' overrides fd. Return !=0 if it does.

findVtblIndex
int findVtblIndex(Dsymbols* vtbl, int dim)

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

overrideInterface
BaseClass* overrideInterface()

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

overloadInsert
bool overloadInsert(Dsymbol s)

Overload this FuncDeclaration with the new one f. Return true if successful; i.e. no conflict.

overloadExactMatch
FuncDeclaration overloadExactMatch(Type t)

Find function in overload list that exactly matches t.

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.

findTemplateDeclRoot
TemplateDeclaration findTemplateDeclRoot()

find function template root in overload list

inUnittest
bool inUnittest()

Returns true if function was declared directly or indirectly in a unittest block

leastAsSpecialized
MATCH leastAsSpecialized(FuncDeclaration g, Identifiers* names)

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

searchLabel
LabelDsymbol searchLabel(Identifier ident, Loc loc)

Searches for a label with the given identifier. This function will insert a new LabelDsymbol into labtab if it does not contain a mapping for ident.

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.

toFullSignature
const(char)* toFullSignature()

for diagnostics, e.g. 'int foo(int x, int y) pure'

isAbstract
bool isAbstract()

Override so it can work even if semantic() hasn't yet been run.

canInferAttributes
bool canInferAttributes(Scope* sc)

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

initInferAttributes
void initInferAttributes()

Initialize for inferring the attributes of this function.

setImpure
bool setImpure(Loc loc, const(char)* fmt, RootObject arg0)

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

setUnsafe
bool setUnsafe(bool gag, Loc loc, const(char)* fmt, RootObject arg0, RootObject arg1, RootObject arg2)

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

setUnsafeCall
bool setUnsafeCall(FuncDeclaration f)

The function is calling @system function f, so mark it as unsafe.

setGC
bool setGC(Loc loc, const(char)* fmt, RootObject arg0)

The function is doing something that may allocate with the GC, so mark it as not nogc (not no-how).

setGCCall
bool setGCCall(FuncDeclaration f)

The function calls non-@nogc function f, mark it as not nogc.

setThrow
void setThrow(Loc loc, const(char)* fmt, RootObject arg0)

The function is doing something that may throw an exception, register that in case nothrow is being inferred

setThrowCall
void setThrowCall(Loc loc, FuncDeclaration f)

The function calls non-nothrow function f, register that in case nothrow is being inferred

isReturnIsolated
bool isReturnIsolated()

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

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.

isNested
bool isNested()

Determine if function needs a static frame pointer.

isThis
inout(AggregateDeclaration) isThis()

Determine if function is a non-static member function that has an implicit 'this' expression.

isUnique
bool isUnique()
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.

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.

checkClosure
bool checkClosure()

Check that the function contains any closure. If it's @nogc, report suitable errors. This is mostly consistent with FuncDeclaration::needsClosure().

hasNestedFrameRefs
bool hasNestedFrameRefs()

Determine if function's variables are referenced by a function nested within it.

buildResultVar
void buildResultVar(Scope* sc, Type tret)

Declare result variable lazily.

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.

needsFensure
bool needsFensure(FuncDeclaration fd)

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

buildEnsureRequire
void buildEnsureRequire()

Rewrite contracts as statements.

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.

getParameterList
ParameterList getParameterList()
genCfunc
FuncDeclaration genCfunc(Parameters* fparams, Type treturn, const(char)* name, StorageClass stc)

Generate a FuncDeclaration for a runtime library function.

checkNRVO
bool checkNRVO()

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

Meta