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.funcsem
Does semantic analysis for functions.
Specification Functions
Authors: 
License: 
Source funcsem.d
Documentation https://dlang.org/phobos/dmd_funcsem.html
- boolonlyOneMain(FuncDeclarationfd);
- Only one entry point function is allowed. Print error if more than one.Parameters:FuncDeclaration fda "main" function Returns:true if haven't seen "main" before
- voidfuncDeclarationSemantic(Scope*sc, FuncDeclarationfuncdecl);
- Main semantic routine for functions.
- boolfunctionSemantic(FuncDeclarationfd);
- Resolve forward reference of function signature - parameter types, return type, and attributes.Parameters:FuncDeclaration fdfunction declaration Returns:false if any errors exist in the signature.
- boolfunctionSemantic3(FuncDeclarationfd);
- Resolve forward reference of function body. Returns false if any errors exist in the body.
- voiddeclareThis(FuncDeclarationfd, 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.
- boolcheckForwardRef(FuncDeclarationfd, Locloc);
- Check that this function type is properly resolved. If not, report "forward reference error" and return true.
- intfindVtblIndex(FuncDeclarationfd, Dsymbol[]vtbl);
- Find index of function in vtbl[0..length] that this function overrides. Prefer an exact match to a covariant one.Parameters:FuncDeclaration fdfunction Dsymbol[] vtblvtable to use Returns:-1 didn't find one -2 can't determine because of forward references
- BaseClass*overrideInterface(FuncDeclarationfd);
- If function is a function in a base class, return that base class.Parameters:FuncDeclaration fdfunction Returns:base class if overriding, null if not
- enumFuncResolveFlag: 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
 
- FuncDeclarationresolveFuncCall(Locloc, Scope*sc, Dsymbols, Objects*tiargs, Typetthis, ArgumentListargumentList, FuncResolveFlagflags);
- Given a symbol that could be either a FuncDeclaration or a function template, resolve it to a function symbol.Parameters:Loc locinstantiation location Scope* scinstantiation scope Dsymbol sinstantiation symbol Objects* tiargsinitial list of template arguments Type tthisif !NULL, the this argument type ArgumentList argumentListarguments to function FuncResolveFlag flagssee FuncResolveFlag. Returns:if match is found, then function symbol, else null
- ExpressionaddInvariant(AggregateDeclarationad, VarDeclarationvthis);
- Generate Expression to call the invariant.Input ad aggregate with the invariant vthis variable with 'this' Returns:void expression that calls the invariant
- FuncDeclarationoverloadExactMatch(FuncDeclarationthisfd, Typet);
- Find function in overload list that exactly matches t.
- intoverrides(FuncDeclarationfd1, FuncDeclarationfd2);
- Determine if fd1 overrides fd2. Return !=0 if it does.
- MATCHleastAsSpecialized(FuncDeclarationf, FuncDeclarationg, Identifiers*names);
- Determine partial specialization order of functionsfvsg. This is very similar to TemplateDeclaration::leastAsSpecialized().Parameters:FuncDeclaration ffirst function FuncDeclaration gsecond function Identifiers* namesnames of parameters Returns:match 'this' is at least as specialized as g 0 g is more specialized than 'this'
- FuncDeclarationoverloadModMatch(FuncDeclarationthisfd, Locloc, Typetthis, ref boolhasOverloads);
- Find function in overload list that matches to the 'this' modifier. There's four result types.- 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.
- 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.
- 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.
- 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.
 
- intgetLevelAndCheck(FuncDeclarationfd, Locloc, Scope*sc, FuncDeclarationtarget, Declarationdecl);
- Determine lexical level difference fromfdto nested functiontarget. Issue error iffdcannot calltarget.Parameters:FuncDeclaration fdfunction Loc loclocation for error messages Scope* sccontext FuncDeclaration targettarget of call Declaration declThe Declaration that triggered this check. Used to provide a better error message only. Returns:0 same level0 decrease nesting by number -1 increase nesting by 1 ( targetis nested within 'fd') LevelError error
- boolcanInferAttributes(FuncDeclarationfd, Scope*sc);
- Decide if attributes for this function can be inferred from examining the function body.Parameters:FuncDeclaration fdfunction to infer attributes for Scope* sccontext Returns:true if can
- boolcheckNestedFuncReference(FuncDeclarationfd, Scope*sc, Locloc);
- In the current function 'sc.func', we are calling 'fd'.- Check to see if the current function can call 'fd' , issue error if not.
- If the current function is not the parent of 'fd' , then add the current function to the list of siblings of 'fd' .
- If the current function is a literal, and it's accessing an uplevel scope, then mark it as a delegate.
 
- voidbuildResultVar(FuncDeclarationfd, Scope*sc, Typetret);
- Declare result variable lazily.
- StatementmergeFrequire(FuncDeclarationfd, Statementsf, 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.
- StatementmergeFrequireInclusivePreview(FuncDeclarationfd, Statementsf, Expressions*params);
- Merge into this function the 'in' contracts of all it overrides.
- voidbuildEnsureRequire(FuncDeclarationthisfd);
- Rewrite contracts as statements.
- @safe boolneedsFensure(FuncDeclarationfd);
- Determine whether an 'out' contract is declared inside the given function or any of its overrides.Parameters:FuncDeclaration fdthe function to search Returns:true found an 'out' contract
- StatementmergeFensure(FuncDeclarationfd, Statementsf, Identifieroid, 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.
- voidmodifyReturns(FuncLiteralDeclarationfld, Scope*sc, Typetret);
- 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 boolisRootTraitsCompilesScope(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* scscope to be checked for Returns:true if the provided scope is the root of the traits compiles list of scopes.
- boolcheckNRVO(FuncDeclarationfd);
- 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.
- boolsetImpure(FuncDeclarationfd, Locloc, const(char)*fmt, RootObject[]args...);
- The function is doing something impure, so mark it as impure.Parameters:FuncDeclaration fdfunction declaration to mark Loc loclocation of impure action const(char)* fmtformat string for error message RootObject[] argsargument to format string Returns:true if there's a purity error
- booltraverseIndirections(Typeta, Typetb);
- 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 typetawas available to the code that created a reference B to a value of typetb, 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 trueParameters:Type tavalue type being referred to Type tbreferred to value type that could be constructed from ta Returns:true if reference totbis isolated from reference tota
- boolisTypeIsolatedIndirect(FuncDeclarationfd, Typet);
- Parameters:FuncDeclaration fdfunction declaration to check Type ttype of object to test one level of indirection down Returns:true if an object typedthas no indirections which could have come from the function's parameters, mutable globals, or uplevel functions.
- boolisReturnIsolated(FuncDeclarationfd);
- 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
- boolisTypeIsolated(FuncDeclarationfd, Typet);
 boolisTypeIsolated(FuncDeclarationfd, Typet, ref StringTable!TypeparentTypes);
- See if pointers from function parameters, mutable globals, or uplevel functions could leak into typet.Parameters:Type ttype to check if it is isolated Returns:true iftis isolated from any inputs to the function
- intoverloadApply(Dsymbolfstart, 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 fstartsymbol to start from int delegate(Dsymbol) dgthe delegate to be called on the overload Scope* sccontext 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)
Copyright © 1999-2025 by the D Language Foundation | Page generated by
Ddoc on Mon Mar 31 10:27:54 2025