/** * Defines a function declaration. * * Includes: * - function/delegate literals * - function aliases * - (static/shared) constructors/destructors/post-blits * - `invariant` * - `unittest` * * Copyright: Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved * Authors: $(LINK2 https://www.digitalmars.com, Walter Bright) * License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/func.d, _func.d) * Documentation: https://dlang.org/phobos/dmd_func.html * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/func.d */ module dmd.func; import core.stdc.stdio; import core.stdc.string; import dmd.aggregate; import dmd.arraytypes; import dmd.astenums; import dmd.blockexit; import dmd.gluelayer; import dmd.dcast; import dmd.dclass; import dmd.declaration; import dmd.delegatize; import dmd.dmodule; import dmd.dscope; import dmd.dstruct; import dmd.dsymbol; import dmd.dtemplate; import dmd.escape; import dmd.expression; import dmd.funcsem : overloadApply; import dmd.globals; import dmd.hdrgen; import dmd.id; import dmd.identifier; import dmd.init; import dmd.location; import dmd.mtype; import dmd.objc; import dmd.common.outbuffer; import dmd.rootobject; import dmd.root.string; import dmd.root.stringtable; import dmd.statement; import dmd.tokens; import dmd.visitor; version (IN_GCC) {} else version (IN_LLVM) {} else version = MARS; /// Inline Status enum ILS : ubyte { uninitialized, /// not computed yet no, /// cannot inline yes, /// can inline } enum BUILTIN : ubyte { unknown = 255, /// not known if this is a builtin unimp = 0, /// this is not a builtin gcc, /// this is a GCC builtin llvm, /// this is an LLVM builtin sin, cos, tan, sqrt, fabs, ldexp, log, log2, log10, exp, expm1, exp2, round, floor, ceil, trunc, copysign, pow, fmin, fmax, fma, isnan, isinfinity, isfinite, bsf, bsr, bswap, popcnt, yl2x, yl2xp1, toPrecFloat, toPrecDouble, toPrecReal, ctfeWrite, } private struct FUNCFLAG { bool purityInprocess; /// working on determining purity bool safetyInprocess; /// working on determining safety bool nothrowInprocess; /// working on determining nothrow bool nogcInprocess; /// working on determining @nogc bool saferD; /// do -preview=safer checks if this function has default safety bool scopeInprocess; /// infer `return` and `scope` for parameters bool inlineScanned; /// function has been scanned for inline possibilities bool hasCatches; /// function has try-catch statements bool skipCodegen; /// do not generate code for this function. bool printf; /// is a printf-like function bool scanf; /// is a scanf-like function bool noreturn; /// the function does not return bool isNRVO = true; /// Support for named return value optimization bool isNaked; /// The function is 'naked' (see inline ASM) bool isGenerated; /// The function is compiler generated (e.g. `opCmp`) bool isIntroducing; /// If this function introduces the overload set bool hasSemantic3Errors; /// If errors in semantic3 this function's frame ptr bool hasNoEH; /// No exception unwinding is needed bool inferRetType; /// Return type is to be inferred bool hasDualContext; /// has a dual-context 'this' parameter bool hasAlwaysInlines; /// Contains references to functions that must be inlined bool isCrtCtor; /// Has attribute pragma(crt_constructor) bool isCrtDtor; /// Has attribute pragma(crt_destructor) bool hasEscapingSiblings;/// Has sibling functions that escape bool computedEscapingSiblings; /// `hasEscapingSiblings` has been computed bool dllImport; /// __declspec(dllimport) bool dllExport; /// __declspec(dllexport) bool hasReturnExp; /// Has return exp; statement bool hasInlineAsm; /// Has asm{} statement bool hasMultipleReturnExp; /// Has multiple return exp; statements } /*********************************************************** * Tuple of result identifier (possibly null) and statement. * This is used to store out contracts: out(id){ ensure } */ extern (C++) struct Ensure { Identifier id; Statement ensure; Ensure syntaxCopy() { return Ensure(id, ensure.syntaxCopy()); } /***************************************** * Do syntax copy of an array of Ensure's. */ static Ensures* arraySyntaxCopy(Ensures* a) { if (!a) return null; Ensures* b = a.copy(); foreach (i, e; *a) (*b)[i] = e.syntaxCopy(); return b; } } /*********************************************************** * Most functions don't have contracts, so save memory by grouping * this information into a separate struct */ private struct ContractInfo { Statements* frequires; /// in contracts Ensures* fensures; /// out contracts Statement frequire; /// lowered in contract Statement fensure; /// lowered out contract FuncDeclaration fdrequire; /// function that does the in contract FuncDeclaration fdensure; /// function that does the out contract Expressions* fdrequireParams; /// argument list for __require Expressions* fdensureParams; /// argument list for __ensure } /*********************************************************** */ extern (C++) class FuncDeclaration : Declaration { Statement fbody; /// function body FuncDeclarations foverrides; /// functions this function overrides private ContractInfo* contracts; /// contract information const(char)* mangleString; /// mangled symbol created from mangleExact() VarDeclaration vresult; /// result variable for out contracts LabelDsymbol returnLabel; /// where the return goes bool[size_t] isTypeIsolatedCache; /// cache for the potentially very expensive isTypeIsolated check // used to prevent symbols in different // scopes from having the same name DsymbolTable localsymtab; VarDeclaration vthis; /// 'this' parameter (member and nested) VarDeclaration v_arguments; /// '_arguments' parameter VarDeclaration v_argptr; /// '_argptr' variable VarDeclarations* parameters; /// Array of VarDeclaration's for parameters DsymbolTable labtab; /// statement label symbol table Dsymbol overnext; /// next in overload list FuncDeclaration overnext0; /// next in overload list (only used during IFTI) Loc endloc; /// location of closing curly bracket int vtblIndex = -1; /// for member functions, index into vtbl[] ILS inlineStatusStmt = ILS.uninitialized; ILS inlineStatusExp = ILS.uninitialized; PINLINE inlining = PINLINE.default_; int inlineNest; /// !=0 if nested inline ForeachStatement fes; /// if foreach body, this is the foreach BaseClass* interfaceVirtual; /// if virtual, but only appears in base interface vtbl[] /** if !=NULL, then this is the type of the 'introducing' function this one is overriding */ Type tintro; StorageClass storage_class2; /// storage class for template onemember's // Things that should really go into Scope VarDeclaration nrvo_var; /// variable to replace with shidden Symbol* shidden; /// hidden pointer passed to function ReturnStatements* returns; GotoStatements* gotos; /// Gotos with forward references version (MARS) { VarDeclarations* alignSectionVars; /// local variables with alignment needs larger than stackAlign Symbol* salignSection; /// pointer to aligned section, if any } /// set if this is a known, builtin function we can evaluate at compile time BUILTIN builtin = BUILTIN.unknown; /// set if someone took the address of this function int tookAddressOf; bool requiresClosure; // this function needs a closure /** local variables in this function which are referenced by nested functions * (They'll get put into the "closure" for this function.) */ VarDeclarations closureVars; /** Outer variables which are referenced by this nested function * (the inverse of closureVars) */ VarDeclarations outerVars; // Most recent encountered `main` (`WinMain` or `DllMain`) function. // Track it to give error messages for multiple entrypoints __gshared FuncDeclaration lastMain; /// Sibling nested functions which called this one FuncDeclarations siblingCallers; FuncDeclarations *inlinedNestedCallees; /// In case of failed `@safe` inference, store the error that made the function `@system` for /// better diagnostics AttributeViolation* safetyViolation; AttributeViolation* nogcViolation; AttributeViolation* pureViolation; AttributeViolation* nothrowViolation; /// See the `FUNCFLAG` struct import dmd.common.bitfields; mixin(generateBitFields!(FUNCFLAG, uint)); /** * Data for a function declaration that is needed for the Objective-C * integration. */ ObjcFuncDeclaration objc; extern (D) this(const ref Loc loc, const ref Loc endloc, Identifier ident, StorageClass storage_class, Type type, bool noreturn = false) { super(loc, ident); //.printf("FuncDeclaration(id = '%s', type = %s)\n", ident.toChars(), type.toChars()); //.printf("storage_class = x%llx\n", storage_class); this.storage_class = storage_class; this.type = type; if (type) { // Normalize storage_class, because function-type related attributes // are already set in the 'type' in parsing phase. this.storage_class &= ~(STC.TYPECTOR | STC.FUNCATTR); } this.endloc = endloc; if (noreturn) this.noreturn = true; /* The type given for "infer the return type" is a TypeFunction with * NULL for the return type. */ if (type && type.nextOf() is null) this.inferRetType = true; } static FuncDeclaration create(const ref Loc loc, const ref Loc endloc, Identifier id, StorageClass storage_class, Type type, bool noreturn = false) { return new FuncDeclaration(loc, endloc, id, storage_class, type, noreturn); } final nothrow pure @safe { private ref ContractInfo getContracts() { if (!contracts) contracts = new ContractInfo(); return *contracts; } // getters inout(Statements*) frequires() inout { return contracts ? contracts.frequires : null; } inout(Ensures*) fensures() inout { return contracts ? contracts.fensures : null; } inout(Statement) frequire() inout { return contracts ? contracts.frequire: null; } inout(Statement) fensure() inout { return contracts ? contracts.fensure : null; } inout(FuncDeclaration) fdrequire() inout { return contracts ? contracts.fdrequire : null; } inout(FuncDeclaration) fdensure() inout { return contracts ? contracts.fdensure: null; } inout(Expressions*) fdrequireParams() inout { return contracts ? contracts.fdrequireParams: null; } inout(Expressions*) fdensureParams() inout { return contracts ? contracts.fdensureParams: null; } extern (D) private static string generateContractSetter(string field, string type) { return type ~ " " ~ field ~ "(" ~ type ~ " param)" ~ "{ if (!param && !contracts) return null; return getContracts()." ~ field ~ " = param; }"; } mixin(generateContractSetter("frequires", "Statements*")); mixin(generateContractSetter("fensures", "Ensures*")); mixin(generateContractSetter("frequire", "Statement")); mixin(generateContractSetter("fensure", "Statement")); mixin(generateContractSetter("fdrequire", "FuncDeclaration")); mixin(generateContractSetter("fdensure", "FuncDeclaration")); mixin(generateContractSetter("fdrequireParams", "Expressions*")); mixin(generateContractSetter("fdensureParams", "Expressions*")); } override FuncDeclaration syntaxCopy(Dsymbol s) { //printf("FuncDeclaration::syntaxCopy('%s')\n", toChars()); FuncDeclaration f = s ? cast(FuncDeclaration)s : new FuncDeclaration(loc, endloc, ident, storage_class, type.syntaxCopy(), this.noreturn != 0); f.frequires = frequires ? Statement.arraySyntaxCopy(frequires) : null; f.fensures = fensures ? Ensure.arraySyntaxCopy(fensures) : null; f.fbody = fbody ? fbody.syntaxCopy() : null; return f; } override final bool equals(const RootObject o) const { if (this == o) return true; auto s = isDsymbol(o); if (!s) return false; auto fd1 = this; auto fd2 = s.isFuncDeclaration(); if (!fd2) return false; auto fa1 = fd1.isFuncAliasDeclaration(); auto faf1 = fa1 ? fa1.toAliasFunc() : fd1; auto fa2 = fd2.isFuncAliasDeclaration(); auto faf2 = fa2 ? fa2.toAliasFunc() : fd2; if (fa1 && fa2) return faf1.equals(faf2) && fa1.hasOverloads == fa2.hasOverloads; bool b1 = fa1 !is null; if (b1 && faf1.isUnique() && !fa1.hasOverloads) b1 = false; bool b2 = fa2 !is null; if (b2 && faf2.isUnique() && !fa2.hasOverloads) b2 = false; if (b1 != b2) return false; return faf1.toParent().equals(faf2.toParent()) && faf1.ident.equals(faf2.ident) && faf1.type.equals(faf2.type); } /**************************************************** * Overload this FuncDeclaration with the new one f. * Return true if successful; i.e. no conflict. */ override bool overloadInsert(Dsymbol s) { //printf("FuncDeclaration::overloadInsert(s = %s) this = %s\n", s.toChars(), toChars()); assert(s != this); if (AliasDeclaration ad = s.isAliasDeclaration()) { if (overnext) return overnext.overloadInsert(ad); if (!ad.aliassym && ad.type.ty != Tident && ad.type.ty != Tinstance && ad.type.ty != Ttypeof) { //printf("\tad = '%s'\n", ad.type.toChars()); return false; } overnext = ad; //printf("\ttrue: no conflict\n"); return true; } TemplateDeclaration td = s.isTemplateDeclaration(); if (td) { if (!td.funcroot) td.funcroot = this; if (overnext) return overnext.overloadInsert(td); overnext = td; return true; } FuncDeclaration fd = s.isFuncDeclaration(); if (!fd) return false; if (overnext) { td = overnext.isTemplateDeclaration(); if (td) fd.overloadInsert(td); else return overnext.overloadInsert(fd); } overnext = fd; //printf("\ttrue: no conflict\n"); return true; } /******************************************** * find function template root in overload list */ extern (D) final TemplateDeclaration findTemplateDeclRoot() { FuncDeclaration f = this; while (f && f.overnext) { //printf("f.overnext = %p %s\n", f.overnext, f.overnext.toChars()); if (TemplateDeclaration td = f.overnext.isTemplateDeclaration()) return td; f = f.overnext.isFuncDeclaration(); } return null; } /******************************************** * Returns true if function was declared * directly or indirectly in a unittest block */ final bool inUnittest() { Dsymbol f = this; do { if (f.isUnitTestDeclaration()) return true; f = f.toParent(); } while (f); return false; } /******************************** * 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`. * * Params: * ident = identifier of the requested label * loc = location used when creating a new `LabelDsymbol` * * Returns: the `LabelDsymbol` for `ident` */ final LabelDsymbol searchLabel(Identifier ident, const ref Loc loc) { Dsymbol s; if (!labtab) labtab = new DsymbolTable(); // guess we need one s = labtab.lookup(ident); if (!s) { s = new LabelDsymbol(ident, loc); labtab.insert(s); } return cast(LabelDsymbol)s; } /***************************************** * Determine lexical level difference from `this` to nested function `fd`. * Params: * fd = target of call * intypeof = !=0 if inside typeof * Returns: * 0 same level * >0 decrease nesting by number * -1 increase nesting by 1 (`fd` is nested within `this`) * LevelError error, `this` cannot call `fd` */ extern (D) final int getLevel(FuncDeclaration fd, int intypeof) { //printf("FuncDeclaration::getLevel(fd = '%s')\n", fd.toChars()); Dsymbol fdparent = fd.toParent2(); if (fdparent == this) return -1; Dsymbol s = this; int level = 0; while (fd != s && fdparent != s.toParent2()) { //printf("\ts = %s, '%s'\n", s.kind(), s.toChars()); if (auto thisfd = s.isFuncDeclaration()) { if (!thisfd.isNested() && !thisfd.vthis && !intypeof) return LevelError; } else { if (auto thiscd = s.isAggregateDeclaration()) { /* AggregateDeclaration::isNested returns true only when * it has a hidden pointer. * But, calling the function belongs unrelated lexical scope * is still allowed inside typeof. * * struct Map(alias fun) { * typeof({ return fun(); }) RetType; * // No member function makes Map struct 'not nested'. * } */ if (!thiscd.isNested() && !intypeof) return LevelError; } else return LevelError; } s = s.toParentP(fd); assert(s); level++; } return level; } enum LevelError = -2; override const(char)* toPrettyChars(bool QualifyTypes = false) { if (isMain()) return "D main"; else return Dsymbol.toPrettyChars(QualifyTypes); } /** for diagnostics, e.g. 'int foo(int x, int y) pure' */ final const(char)* toFullSignature() { OutBuffer buf; functionToBufferWithIdent(type.toTypeFunction(), buf, toChars(), isStatic); return buf.extractChars(); } final bool isMain() const { return ident == Id.main && resolvedLinkage() != LINK.c && !isMember() && !isNested(); } final bool isCMain() const { return ident == Id.main && resolvedLinkage() == LINK.c && !isMember() && !isNested(); } final bool isWinMain() const { //printf("FuncDeclaration::isWinMain() %s\n", toChars()); version (none) { bool x = ident == Id.WinMain && resolvedLinkage() != LINK.c && !isMember(); printf("%s\n", x ? "yes" : "no"); return x; } else { return ident == Id.WinMain && resolvedLinkage() != LINK.c && !isMember(); } } final bool isDllMain() const { return ident == Id.DllMain && resolvedLinkage() != LINK.c && !isMember(); } final bool isRtInit() const { return ident == Id.rt_init && resolvedLinkage() == LINK.c && !isMember() && !isNested(); } override final bool isExport() const { return visibility.kind == Visibility.Kind.export_ || dllExport; } override final bool isImportedSymbol() const { //printf("isImportedSymbol()\n"); //printf("protection = %d\n", visibility); return (visibility.kind == Visibility.Kind.export_ || dllImport) && !fbody; } override final bool isCodeseg() const pure nothrow @nogc @safe { return true; // functions are always in the code segment } override final bool isOverloadable() const { return true; // functions can be overloaded } /*********************************** * Override so it can work even if semantic() hasn't yet * been run. */ override final bool isAbstract() { if (storage_class & STC.abstract_) return true; if (semanticRun >= PASS.semanticdone) return false; if (_scope) { if (_scope.stc & STC.abstract_) return true; parent = _scope.parent; Dsymbol parent = toParent(); if (parent.isInterfaceDeclaration()) return true; } return false; } extern (D) final uint saveFlags() { return bitFields; } extern (D) final uint restoreFlags(uint f) { bitFields = f; return bitFields; } /************************************** * The function is doing something that may throw an exception, register that in case nothrow is being inferred * * Params: * loc = location of action * format = format string for error message * arg0 = (optional) argument to format string */ extern (D) final void setThrow(Loc loc, const(char)* format, RootObject arg0 = null) { if (nothrowInprocess && !nothrowViolation) { assert(format); nothrowViolation = new AttributeViolation(loc, format, arg0); // action that requires GC } } /************************************** * The function calls non-`nothrow` function f, register that in case nothrow is being inferred * Params: * loc = location of call * fd = function being called */ extern (D) final void setThrowCall(Loc loc, FuncDeclaration fd) { if (nothrowInprocess && !nothrowViolation) { nothrowViolation = new AttributeViolation(loc, fd); // action that requires GC } } /**************************************** * Determine if function needs a static frame pointer. * Returns: * `true` if function is really nested within other function. * Contracts: * If isNested() returns true, isThis() should return false, * unless the function needs a dual-context pointer. */ bool isNested() const { auto f = toAliasFunc(); //printf("\ttoParent2() = '%s'\n", f.toParent2().toChars()); return ((f.storage_class & STC.static_) == 0) && (f._linkage == LINK.d) && (f.toParent2().isFuncDeclaration() !is null || f.toParent2() !is f.toParentLocal()); } /**************************************** * Determine if function is a non-static member function * that has an implicit 'this' expression. * Returns: * The aggregate it is a member of, or null. * Contracts: * Both isThis() and isNested() should return true if function needs a dual-context pointer, * otherwise if isThis() returns true, isNested() should return false. */ override inout(AggregateDeclaration) isThis() inout { //printf("+FuncDeclaration::isThis() '%s'\n", toChars()); auto ad = (storage_class & STC.static_) ? .objc.isThis(this) : isMemberLocal(); //printf("-FuncDeclaration::isThis() %p\n", ad); return ad; } override final bool needThis() { //printf("FuncDeclaration::needThis() '%s'\n", toChars()); return toAliasFunc().isThis() !is null; } // Determine if a function is pedantically virtual final bool isVirtualMethod() { if (toAliasFunc() != this) return toAliasFunc().isVirtualMethod(); //printf("FuncDeclaration::isVirtualMethod() %s\n", toChars()); if (!isVirtual()) return false; // If it's a final method, and does not override anything, then it is not virtual if (isFinalFunc() && foverrides.length == 0) { return false; } return true; } // Determine if function goes into virtual function pointer table bool isVirtual() const { if (toAliasFunc() != this) return toAliasFunc().isVirtual(); auto p = toParent(); if (!isMember || !p.isClassDeclaration) return false; if (p.isClassDeclaration.classKind == ClassKind.objc) return .objc.isVirtual(this); version (none) { printf("FuncDeclaration::isVirtual(%s)\n", toChars()); printf("isMember:%p isStatic:%d private:%d ctor:%d !Dlinkage:%d\n", isMember(), isStatic(), visibility == Visibility.Kind.private_, isCtorDeclaration(), linkage != LINK.d); printf("result is %d\n", isMember() && !(isStatic() || visibility == Visibility.Kind.private_ || visibility == Visibility.Kind.package_) && p.isClassDeclaration() && !(p.isInterfaceDeclaration() && isFinalFunc())); } return !(isStatic() || visibility.kind == Visibility.Kind.private_ || visibility.kind == Visibility.Kind.package_) && !(p.isInterfaceDeclaration() && isFinalFunc()); } final bool isFinalFunc() const { if (toAliasFunc() != this) return toAliasFunc().isFinalFunc(); version (none) {{ auto cd = toParent().isClassDeclaration(); printf("FuncDeclaration::isFinalFunc(%s), %x\n", toChars(), Declaration.isFinal()); printf("%p %d %d %d\n", isMember(), isStatic(), Declaration.isFinal(), ((cd = toParent().isClassDeclaration()) !is null && cd.storage_class & STC.final_)); printf("result is %d\n", isMember() && (Declaration.isFinal() || (cd !is null && cd.storage_class & STC.final_))); if (cd) printf("\tmember of %s\n", cd.toChars()); }} if (!isMember()) return false; if (Declaration.isFinal()) return true; auto cd = toParent().isClassDeclaration(); return (cd !is null) && (cd.storage_class & STC.final_); } bool addPreInvariant() { auto ad = isThis(); ClassDeclaration cd = ad ? ad.isClassDeclaration() : null; return (ad && !(cd && cd.isCPPclass()) && global.params.useInvariants == CHECKENABLE.on && (visibility.kind == Visibility.Kind.protected_ || visibility.kind == Visibility.Kind.public_ || visibility.kind == Visibility.Kind.export_) && !this.isNaked()); } bool addPostInvariant() { auto ad = isThis(); ClassDeclaration cd = ad ? ad.isClassDeclaration() : null; return (ad && !(cd && cd.isCPPclass()) && ad.inv && global.params.useInvariants == CHECKENABLE.on && (visibility.kind == Visibility.Kind.protected_ || visibility.kind == Visibility.Kind.public_ || visibility.kind == Visibility.Kind.export_) && !this.isNaked()); } override const(char)* kind() const { return this.isGenerated() ? "generated function" : "function"; } /******************************************** * Returns: * true if there are no overloads of this function */ final bool isUnique() const { bool result = false; overloadApply(cast() this, (Dsymbol s) { auto f = s.isFuncDeclaration(); auto td = s.isTemplateDeclaration(); if (!f && !td) return 0; if (result) { result = false; return 1; // ambiguous, done } else { result = true; return 0; } }); return result; } /******************************* * 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. */ final bool needsClosure() { /* Need a closure for all the closureVars[] if any of the * closureVars[] are accessed by a * function that escapes the scope of this function. * We take the conservative approach and decide that a function needs * a closure if it: * 1) is a virtual function * 2) has its address taken * 3) has a parent that escapes * 4) calls another nested function that needs a closure * * Note that since a non-virtual function can be called by * a virtual one, if that non-virtual function accesses a closure * var, the closure still has to be taken. Hence, we check for isThis() * instead of isVirtual(). (thanks to David Friedman) * * When the function returns a local struct or class, `requiresClosure` * is already set to `true` upon entering this function when the * struct/class refers to a local variable and a closure is needed. */ //printf("FuncDeclaration::needsClosure() %s\n", toPrettyChars()); if (requiresClosure) goto Lyes; for (size_t i = 0; i < closureVars.length; i++) { VarDeclaration v = closureVars[i]; //printf("\tv = %s\n", v.toChars()); for (size_t j = 0; j < v.nestedrefs.length; j++) { FuncDeclaration f = v.nestedrefs[j]; assert(f != this); /* __require and __ensure will always get called directly, * so they never make outer functions closure. */ if (f.ident == Id.require || f.ident == Id.ensure) continue; //printf("\t\tf = %p, %s, isVirtual=%d, isThis=%p, tookAddressOf=%d\n", f, f.toChars(), f.isVirtual(), f.isThis(), f.tookAddressOf); /* Look to see if f escapes. We consider all parents of f within * this, and also all siblings which call f; if any of them escape, * so does f. * Mark all affected functions as requiring closures. */ for (Dsymbol s = f; s && s != this; s = s.toParentP(this)) { FuncDeclaration fx = s.isFuncDeclaration(); if (!fx) continue; if (fx.isThis() || fx.tookAddressOf) { //printf("\t\tfx = %s, isVirtual=%d, isThis=%p, tookAddressOf=%d\n", fx.toChars(), fx.isVirtual(), fx.isThis(), fx.tookAddressOf); /* Mark as needing closure any functions between this and f */ markAsNeedingClosure((fx == f) ? fx.toParentP(this) : fx, this); requiresClosure = true; } /* We also need to check if any sibling functions that * called us, have escaped. This is recursive: we need * to check the callers of our siblings. */ if (checkEscapingSiblings(fx, this)) requiresClosure = true; /* https://issues.dlang.org/show_bug.cgi?id=12406 * Iterate all closureVars to mark all descendant * nested functions that access to the closing context of this function. */ } } } if (requiresClosure) goto Lyes; return false; Lyes: return true; } /*********************************************** * Determine if function's variables are referenced by a function * nested within it. */ final bool hasNestedFrameRefs() { if (closureVars.length) return true; /* If a virtual function has contracts, assume its variables are referenced * by those contracts, even if they aren't. Because they might be referenced * by the overridden or overriding function's contracts. * This can happen because frequire and fensure are implemented as nested functions, * and they can be called directly by an overriding function and the overriding function's * context had better match, or * https://issues.dlang.org/show_bug.cgi?id=7335 will bite. */ if (fdrequire || fdensure) return true; if (foverrides.length && isVirtualMethod()) { for (size_t i = 0; i < foverrides.length; i++) { FuncDeclaration fdv = foverrides[i]; if (fdv.hasNestedFrameRefs()) return true; } } return false; } /********************************************* * Returns: the function's parameter list, and whether * it is variadic or not. */ final ParameterList getParameterList() { if (type) { if (TypeFunction fdtype = type.isTypeFunction()) // Could also be TypeError return fdtype.parameterList; } return ParameterList(null, VarArg.none); } /********************************** * Generate a FuncDeclaration for a runtime library function. */ static FuncDeclaration genCfunc(Parameters* fparams, Type treturn, const(char)* name, StorageClass stc = 0) { return genCfunc(fparams, treturn, Identifier.idPool(name[0 .. strlen(name)]), stc); } static FuncDeclaration genCfunc(Parameters* fparams, Type treturn, Identifier id, StorageClass stc = 0) { FuncDeclaration fd; TypeFunction tf; Dsymbol s; __gshared DsymbolTable st = null; //printf("genCfunc(name = '%s')\n", id.toChars()); //printf("treturn\n\t"); treturn.print(); // See if already in table if (!st) st = new DsymbolTable(); s = st.lookup(id); if (s) { fd = s.isFuncDeclaration(); assert(fd); assert(fd.type.nextOf().equals(treturn)); } else { tf = new TypeFunction(ParameterList(fparams), treturn, LINK.c, stc); fd = new FuncDeclaration(Loc.initial, Loc.initial, id, STC.static_, tf); fd.visibility = Visibility(Visibility.Kind.public_); fd._linkage = LINK.c; st.insert(fd); } return fd; } override final inout(FuncDeclaration) isFuncDeclaration() inout { return this; } inout(FuncDeclaration) toAliasFunc() inout @safe { return this; } override void accept(Visitor v) { v.visit(this); } } /** Checks for mismatching modifiers between `lhsMod` and `rhsMod` and prints the mismatching modifiers to `buf`. The modifiers of the `lhsMod` mismatching the ones with the `rhsMod` are printed, i.e. lhs(shared) vs. rhs() prints "`shared`", wheras lhs() vs rhs(shared) prints "non-shared". Params: buf = output buffer to write to lhsMod = modifier on the left-hand side lhsMod = modifier on the right-hand side Returns: A tuple with `isMutable` and `isNotShared` set if the `lhsMod` is missing those modifiers (compared to rhs). */ auto MODMatchToBuffer(OutBuffer* buf, ubyte lhsMod, ubyte rhsMod) { static struct Mismatches { bool isNotShared; bool isMutable; } Mismatches mismatches; bool bothMutable = ((lhsMod & rhsMod) == 0); bool sharedMismatch = ((lhsMod ^ rhsMod) & MODFlags.shared_) != 0; bool sharedMismatchOnly = ((lhsMod ^ rhsMod) == MODFlags.shared_); if (lhsMod & MODFlags.shared_) buf.writestring("`shared` "); else if (sharedMismatch && !(lhsMod & MODFlags.immutable_)) { buf.writestring("non-shared "); mismatches.isNotShared = true; } if (bothMutable && sharedMismatchOnly) { } else if (lhsMod & MODFlags.immutable_) buf.writestring("`immutable` "); else if (lhsMod & MODFlags.const_) buf.writestring("`const` "); else if (lhsMod & MODFlags.wild) buf.writestring("`inout` "); else { buf.writestring("mutable "); mismatches.isMutable = true; } return mismatches; } /// unittest { OutBuffer buf; auto mismatches = MODMatchToBuffer(&buf, MODFlags.shared_, 0); assert(buf[] == "`shared` "); assert(!mismatches.isNotShared); buf.setsize(0); mismatches = MODMatchToBuffer(&buf, 0, MODFlags.shared_); assert(buf[] == "non-shared "); assert(mismatches.isNotShared); buf.setsize(0); mismatches = MODMatchToBuffer(&buf, MODFlags.const_, 0); assert(buf[] == "`const` "); assert(!mismatches.isMutable); buf.setsize(0); mismatches = MODMatchToBuffer(&buf, 0, MODFlags.const_); assert(buf[] == "mutable "); assert(mismatches.isMutable); } /* For all functions between outerFunc and f, mark them as needing * a closure. */ private void markAsNeedingClosure(Dsymbol f, FuncDeclaration outerFunc) { for (Dsymbol sx = f; sx && sx != outerFunc; sx = sx.toParentP(outerFunc)) { FuncDeclaration fy = sx.isFuncDeclaration(); if (fy && fy.closureVars.length) { /* fy needs a closure if it has closureVars[], * because the frame pointer in the closure will be accessed. */ fy.requiresClosure = true; } } } /******** * Given a nested function f inside a function outerFunc, check * if any sibling callers of f have escaped. If so, mark * all the enclosing functions as needing closures. * This is recursive: we need to check the callers of our siblings. * Note that nested functions can only call lexically earlier nested * functions, so loops are impossible. * Params: * f = inner function (nested within outerFunc) * outerFunc = outer function * p = for internal recursion use * Returns: * true if any closures were needed */ bool checkEscapingSiblings(FuncDeclaration f, FuncDeclaration outerFunc, void* p = null) { static struct PrevSibling { PrevSibling* p; FuncDeclaration f; } if (f.computedEscapingSiblings) return f.hasEscapingSiblings; PrevSibling ps; ps.p = cast(PrevSibling*)p; ps.f = f; //printf("checkEscapingSiblings(f = %s, outerfunc = %s)\n", f.toChars(), outerFunc.toChars()); bool bAnyClosures = false; for (size_t i = 0; i < f.siblingCallers.length; ++i) { FuncDeclaration g = f.siblingCallers[i]; if (g.isThis() || g.tookAddressOf) { markAsNeedingClosure(g, outerFunc); bAnyClosures = true; } for (auto parent = g.toParentP(outerFunc); parent && parent !is outerFunc; parent = parent.toParentP(outerFunc)) { // A parent of the sibling had its address taken. // Assume escaping of parent affects its children, so needs propagating. // see https://issues.dlang.org/show_bug.cgi?id=19679 FuncDeclaration parentFunc = parent.isFuncDeclaration; if (parentFunc && parentFunc.tookAddressOf) { markAsNeedingClosure(parentFunc, outerFunc); bAnyClosures = true; } } PrevSibling* prev = cast(PrevSibling*)p; while (1) { if (!prev) { bAnyClosures |= checkEscapingSiblings(g, outerFunc, &ps); break; } if (prev.f == g) break; prev = prev.p; } } f.hasEscapingSiblings = bAnyClosures; f.computedEscapingSiblings = true; //printf("\t%d\n", bAnyClosures); return bAnyClosures; } /*********************************************************** * Used as a way to import a set of functions from another scope into this one. */ extern (C++) final class FuncAliasDeclaration : FuncDeclaration { FuncDeclaration funcalias; bool hasOverloads; extern (D) this(Identifier ident, FuncDeclaration funcalias, bool hasOverloads = true) { super(funcalias.loc, funcalias.endloc, ident, funcalias.storage_class, funcalias.type); assert(funcalias != this); this.funcalias = funcalias; this.hasOverloads = hasOverloads; if (hasOverloads) { if (FuncAliasDeclaration fad = funcalias.isFuncAliasDeclaration()) this.hasOverloads = fad.hasOverloads; } else { // for internal use assert(!funcalias.isFuncAliasDeclaration()); this.hasOverloads = false; } userAttribDecl = funcalias.userAttribDecl; } override inout(FuncAliasDeclaration) isFuncAliasDeclaration() inout { return this; } override const(char)* kind() const { return "function alias"; } override inout(FuncDeclaration) toAliasFunc() inout { return funcalias.toAliasFunc(); } override void accept(Visitor v) { v.visit(this); } } /*********************************************************** */ extern (C++) final class FuncLiteralDeclaration : FuncDeclaration { TOK tok; // TOK.function_ or TOK.delegate_ Type treq; // target of return type inference // backend bool deferToObj; extern (D) this(const ref Loc loc, const ref Loc endloc, Type type, TOK tok, ForeachStatement fes, Identifier id = null, StorageClass storage_class = STC.undefined_) { super(loc, endloc, null, storage_class, type); this.ident = id ? id : Id.empty; this.tok = tok; this.fes = fes; // Always infer scope for function literals // See https://issues.dlang.org/show_bug.cgi?id=20362 this.scopeInprocess = true; //printf("FuncLiteralDeclaration() id = '%s', type = '%s'\n", this.ident.toChars(), type.toChars()); } override FuncLiteralDeclaration syntaxCopy(Dsymbol s) { //printf("FuncLiteralDeclaration::syntaxCopy('%s')\n", toChars()); assert(!s); auto f = new FuncLiteralDeclaration(loc, endloc, type.syntaxCopy(), tok, fes, ident, storage_class & STC.auto_); f.treq = treq; // don't need to copy FuncDeclaration.syntaxCopy(f); return f; } override bool isNested() const { //printf("FuncLiteralDeclaration::isNested() '%s'\n", toChars()); return (tok != TOK.function_) && !isThis(); } override inout(AggregateDeclaration) isThis() inout { return tok == TOK.delegate_ ? super.isThis() : null; } override bool isVirtual() const { return false; } override bool addPreInvariant() { return false; } override bool addPostInvariant() { return false; } override inout(FuncLiteralDeclaration) isFuncLiteralDeclaration() inout { return this; } override const(char)* kind() const { // GCC requires the (char*) casts return (tok != TOK.function_) ? "delegate" : "function"; } override const(char)* toPrettyChars(bool QualifyTypes = false) { if (parent) { if (TemplateInstance ti = parent.isTemplateInstance()) return ti.tempdecl.toPrettyChars(QualifyTypes); } return Dsymbol.toPrettyChars(QualifyTypes); } override void accept(Visitor v) { v.visit(this); } } /*********************************************************** */ extern (C++) final class CtorDeclaration : FuncDeclaration { bool isCpCtor; // copy constructor bool isMoveCtor; // move constructor (aka rvalue constructor) extern (D) this(const ref Loc loc, const ref Loc endloc, StorageClass stc, Type type) { super(loc, endloc, Id.ctor, stc, type); //printf("CtorDeclaration(loc = %s) %s %p\n", loc.toChars(), toChars(), this); } override CtorDeclaration syntaxCopy(Dsymbol s) { assert(!s); auto f = new CtorDeclaration(loc, endloc, storage_class, type.syntaxCopy()); FuncDeclaration.syntaxCopy(f); return f; } override const(char)* kind() const { return isCpCtor ? "copy constructor" : "constructor"; } override const(char)* toChars() const { return "this"; } override bool isVirtual() const { return false; } override bool addPreInvariant() { return false; } override bool addPostInvariant() { return (isThis() && vthis && global.params.useInvariants == CHECKENABLE.on); } override inout(CtorDeclaration) isCtorDeclaration() inout { return this; } override void accept(Visitor v) { v.visit(this); } } /*********************************************************** */ extern (C++) final class PostBlitDeclaration : FuncDeclaration { extern (D) this(const ref Loc loc, const ref Loc endloc, StorageClass stc, Identifier id) { super(loc, endloc, id, stc, null); } override PostBlitDeclaration syntaxCopy(Dsymbol s) { assert(!s); auto dd = new PostBlitDeclaration(loc, endloc, storage_class, ident); FuncDeclaration.syntaxCopy(dd); return dd; } override bool isVirtual() const { return false; } override bool addPreInvariant() { return false; } override bool addPostInvariant() { return (isThis() && vthis && global.params.useInvariants == CHECKENABLE.on); } override bool overloadInsert(Dsymbol s) { return false; // cannot overload postblits } override inout(PostBlitDeclaration) isPostBlitDeclaration() inout { return this; } override void accept(Visitor v) { v.visit(this); } } /*********************************************************** */ extern (C++) final class DtorDeclaration : FuncDeclaration { extern (D) this(const ref Loc loc, const ref Loc endloc) { super(loc, endloc, Id.dtor, STC.undefined_, null); } extern (D) this(const ref Loc loc, const ref Loc endloc, StorageClass stc, Identifier id) { super(loc, endloc, id, stc, null); } override DtorDeclaration syntaxCopy(Dsymbol s) { assert(!s); auto dd = new DtorDeclaration(loc, endloc, storage_class, ident); FuncDeclaration.syntaxCopy(dd); return dd; } override const(char)* kind() const { return "destructor"; } override const(char)* toChars() const { return "~this"; } override bool isVirtual() const { // D dtor's don't get put into the vtbl[] // this is a hack so that extern(C++) destructors report as virtual, which are manually added to the vtable return vtblIndex != -1; } override bool addPreInvariant() { return (isThis() && vthis && global.params.useInvariants == CHECKENABLE.on); } override bool addPostInvariant() { return false; } override bool overloadInsert(Dsymbol s) { return false; // cannot overload destructors } override inout(DtorDeclaration) isDtorDeclaration() inout { return this; } override void accept(Visitor v) { v.visit(this); } } /*********************************************************** */ extern (C++) class StaticCtorDeclaration : FuncDeclaration { extern (D) this(const ref Loc loc, const ref Loc endloc, StorageClass stc) { super(loc, endloc, Identifier.generateIdWithLoc("_staticCtor", loc), STC.static_ | stc, null); } extern (D) this(const ref Loc loc, const ref Loc endloc, string name, StorageClass stc) { super(loc, endloc, Identifier.generateIdWithLoc(name, loc), STC.static_ | stc, null); } override StaticCtorDeclaration syntaxCopy(Dsymbol s) { assert(!s); auto scd = new StaticCtorDeclaration(loc, endloc, storage_class); FuncDeclaration.syntaxCopy(scd); return scd; } override final inout(AggregateDeclaration) isThis() inout @nogc nothrow pure @safe { return null; } override final bool isVirtual() const @nogc nothrow pure @safe { return false; } override final bool addPreInvariant() @nogc nothrow pure @safe { return false; } override final bool addPostInvariant() @nogc nothrow pure @safe { return false; } override final bool hasStaticCtorOrDtor() @nogc nothrow pure @safe { return true; } override final inout(StaticCtorDeclaration) isStaticCtorDeclaration() inout @nogc nothrow pure @safe { return this; } override void accept(Visitor v) { v.visit(this); } } /*********************************************************** */ extern (C++) final class SharedStaticCtorDeclaration : StaticCtorDeclaration { /// Exclude this constructor from cyclic dependency check bool standalone; extern (D) this(const ref Loc loc, const ref Loc endloc, StorageClass stc) { super(loc, endloc, "_sharedStaticCtor", stc); } override SharedStaticCtorDeclaration syntaxCopy(Dsymbol s) { assert(!s); auto scd = new SharedStaticCtorDeclaration(loc, endloc, storage_class); FuncDeclaration.syntaxCopy(scd); return scd; } override inout(SharedStaticCtorDeclaration) isSharedStaticCtorDeclaration() inout { return this; } override void accept(Visitor v) { v.visit(this); } } /*********************************************************** */ extern (C++) class StaticDtorDeclaration : FuncDeclaration { VarDeclaration vgate; // 'gate' variable extern (D) this(const ref Loc loc, const ref Loc endloc, StorageClass stc) { super(loc, endloc, Identifier.generateIdWithLoc("_staticDtor", loc), STC.static_ | stc, null); } extern (D) this(const ref Loc loc, const ref Loc endloc, string name, StorageClass stc) { super(loc, endloc, Identifier.generateIdWithLoc(name, loc), STC.static_ | stc, null); } override StaticDtorDeclaration syntaxCopy(Dsymbol s) { assert(!s); auto sdd = new StaticDtorDeclaration(loc, endloc, storage_class); FuncDeclaration.syntaxCopy(sdd); return sdd; } override final inout(AggregateDeclaration) isThis() inout { return null; } override final bool isVirtual() const { return false; } override final bool hasStaticCtorOrDtor() { return true; } override final bool addPreInvariant() { return false; } override final bool addPostInvariant() { return false; } override final inout(StaticDtorDeclaration) isStaticDtorDeclaration() inout { return this; } override void accept(Visitor v) { v.visit(this); } } /*********************************************************** */ extern (C++) final class SharedStaticDtorDeclaration : StaticDtorDeclaration { extern (D) this(const ref Loc loc, const ref Loc endloc, StorageClass stc) { super(loc, endloc, "_sharedStaticDtor", stc); } override SharedStaticDtorDeclaration syntaxCopy(Dsymbol s) { assert(!s); auto sdd = new SharedStaticDtorDeclaration(loc, endloc, storage_class); FuncDeclaration.syntaxCopy(sdd); return sdd; } override inout(SharedStaticDtorDeclaration) isSharedStaticDtorDeclaration() inout { return this; } override void accept(Visitor v) { v.visit(this); } } /*********************************************************** */ extern (C++) final class InvariantDeclaration : FuncDeclaration { extern (D) this(const ref Loc loc, const ref Loc endloc, StorageClass stc, Identifier id, Statement fbody) { // Make a unique invariant for now; we'll fix it up as we add it to the aggregate invariant list. super(loc, endloc, id ? id : Identifier.generateId("__invariant"), stc, null); this.fbody = fbody; } override InvariantDeclaration syntaxCopy(Dsymbol s) { assert(!s); auto id = new InvariantDeclaration(loc, endloc, storage_class, null, null); FuncDeclaration.syntaxCopy(id); return id; } override bool isVirtual() const { return false; } override bool addPreInvariant() { return false; } override bool addPostInvariant() { return false; } override inout(InvariantDeclaration) isInvariantDeclaration() inout { return this; } override void accept(Visitor v) { v.visit(this); } extern (D) void fixupInvariantIdent(size_t offset) { OutBuffer idBuf; idBuf.writestring("__invariant"); idBuf.print(offset); ident = Identifier.idPool(idBuf[]); } } /*********************************************************** */ extern (C++) final class UnitTestDeclaration : FuncDeclaration { char* codedoc; // for documented unittest // toObjFile() these nested functions after this one FuncDeclarations deferredNested; extern (D) this(const ref Loc loc, const ref Loc endloc, StorageClass stc, char* codedoc) { super(loc, endloc, Identifier.generateIdWithLoc("__unittest", loc), stc, null); this.codedoc = codedoc; } override UnitTestDeclaration syntaxCopy(Dsymbol s) { assert(!s); auto utd = new UnitTestDeclaration(loc, endloc, storage_class, codedoc); FuncDeclaration.syntaxCopy(utd); return utd; } override inout(AggregateDeclaration) isThis() inout { return null; } override bool isVirtual() const { return false; } override bool addPreInvariant() { return false; } override bool addPostInvariant() { return false; } override inout(UnitTestDeclaration) isUnitTestDeclaration() inout { return this; } override void accept(Visitor v) { v.visit(this); } } /*********************************************************** */ extern (C++) final class NewDeclaration : FuncDeclaration { extern (D) this(const ref Loc loc, StorageClass stc) { super(loc, Loc.initial, Id.classNew, STC.static_ | stc, null); } override NewDeclaration syntaxCopy(Dsymbol s) { assert(!s); auto f = new NewDeclaration(loc, storage_class); FuncDeclaration.syntaxCopy(f); return f; } override const(char)* kind() const { return "allocator"; } override bool isVirtual() const { return false; } override bool addPreInvariant() { return false; } override bool addPostInvariant() { return false; } override inout(NewDeclaration) isNewDeclaration() inout { return this; } override void accept(Visitor v) { v.visit(this); } } /// Stores a reason why a function failed to infer a function attribute like `@safe` or `pure` /// /// Has two modes: /// - a regular safety error, stored in (fmtStr, arg0, arg1) /// - a call to a function without the attribute, which is a special case, because in that case, /// that function might recursively also have a `AttributeViolation`. This way, in case /// of a big call stack, the error can go down all the way to the root cause. /// The `FunctionDeclaration` is then stored in `arg0` and `fmtStr` must be `null`. struct AttributeViolation { Loc loc; /// location of error FuncDeclaration fd; /// function is the focus of the violation // -- OR -- const(char)* format; /// printf-style format string RootObject arg0; /// Arguments for up to two `%s` format specifiers in format string RootObject arg1; /// ditto RootObject arg2; /// ditto this(ref Loc loc, FuncDeclaration fd) { this.loc = loc; this.fd = fd; } this(ref Loc loc, const(char)* format, RootObject arg0 = null, RootObject arg1 = null, RootObject arg2 = null) { assert(format); this.loc = loc; this.format = format; this.arg0 = arg0; this.arg1 = arg1; this.arg2 = arg2; } }