| |
| /* Compiler implementation of the D programming language |
| * Copyright (C) 1999-2022 by The D Language Foundation, All Rights Reserved |
| * written by Walter Bright |
| * https://www.digitalmars.com |
| * Distributed under the Boost Software License, Version 1.0. |
| * https://www.boost.org/LICENSE_1_0.txt |
| * https://github.com/dlang/dmd/blob/master/src/dmd/declaration.h |
| */ |
| |
| #pragma once |
| |
| #include "dsymbol.h" |
| #include "mtype.h" |
| #include "objc.h" |
| #include "tokens.h" |
| |
| class Expression; |
| class Statement; |
| class LabelDsymbol; |
| class Initializer; |
| class ForeachStatement; |
| struct Ensure |
| { |
| Identifier *id; |
| Statement *ensure; |
| }; |
| class FuncDeclaration; |
| class StructDeclaration; |
| struct IntRange; |
| |
| //enum STC : ulong from astenums.d: |
| |
| #define STCundefined 0ULL |
| |
| #define STCstatic 1ULL /// `static` |
| #define STCextern 2ULL /// `extern` |
| #define STCconst 4ULL /// `const` |
| #define STCfinal 8ULL /// `final` |
| |
| #define STCabstract 0x10ULL /// `abstract` |
| #define STCparameter 0x20ULL /// is function parameter |
| #define STCfield 0x40ULL /// is field of struct, union or class |
| #define STCoverride 0x80ULL /// `override` |
| |
| #define STCauto 0x100ULL /// `auto` |
| #define STCsynchronized 0x200ULL /// `synchronized` |
| #define STCdeprecated 0x400ULL /// `deprecated` |
| #define STCin 0x800ULL /// `in` parameter |
| |
| #define STCout 0x1000ULL /// `out` parameter |
| #define STClazy 0x2000ULL /// `lazy` parameter |
| #define STCforeach 0x4000ULL /// variable for foreach loop |
| #define STCvariadic 0x8000ULL /// the `variadic` parameter in: T foo(T a, U b, V variadic...) |
| |
| // 0x10000ULL |
| #define STCtemplateparameter 0x20000ULL /// template parameter |
| #define STCref 0x40000ULL /// `ref` |
| #define STCscope 0x80000ULL /// `scope` |
| |
| #define STCmaybescope 0x100000ULL /// parameter might be `scope` |
| #define STCscopeinferred 0x200000ULL /// `scope` has been inferred and should not be part of mangling, `scope` must also be set |
| #define STCreturn 0x400000ULL /// 'return ref' or 'return scope' for function parameters |
| #define STCreturnScope 0x800000ULL /// if `ref return scope` then resolve to `ref` and `return scope` |
| |
| #define STCreturninferred 0x1000000ULL /// `return` has been inferred and should not be part of mangling, `return` must also be set |
| #define STCimmutable 0x2000000ULL /// `immutable` |
| // 0x4000000ULL |
| #define STCmanifest 0x8000000ULL /// manifest constant |
| |
| #define STCnodtor 0x10000000ULL /// do not run destructor |
| #define STCnothrow 0x20000000ULL /// `nothrow` meaning never throws exceptions |
| #define STCpure 0x40000000ULL /// `pure` function |
| |
| #define STCalias 0x100000000ULL /// `alias` parameter |
| #define STCshared 0x200000000ULL /// accessible from multiple threads |
| #define STCgshared 0x400000000ULL /// accessible from multiple threads, but not typed as `shared` |
| #define STCwild 0x800000000ULL /// for wild type constructor |
| |
| #define STCproperty 0x1000000000ULL /// `@property` |
| #define STCsafe 0x2000000000ULL /// `@safe` |
| #define STCtrusted 0x4000000000ULL /// `@trusted` |
| #define STCsystem 0x8000000000ULL /// `@system` |
| |
| #define STCctfe 0x10000000000ULL /// can be used in CTFE, even if it is static |
| #define STCdisable 0x20000000000ULL /// for functions that are not callable |
| #define STCresult 0x40000000000ULL /// for result variables passed to out contracts |
| #define STCnodefaultctor 0x80000000000ULL /// must be set inside constructor |
| |
| #define STCtemp 0x100000000000ULL /// temporary variable |
| #define STCrvalue 0x200000000000ULL /// force rvalue for variables |
| #define STCnogc 0x400000000000ULL /// `@nogc` |
| #define STCautoref 0x800000000000ULL /// Mark for the already deduced `auto ref` parameter |
| |
| #define STCinference 0x1000000000000ULL /// do attribute inference |
| #define STCexptemp 0x2000000000000ULL /// temporary variable that has lifetime restricted to an expression |
| #define STCfuture 0x4000000000000ULL /// introducing new base class function |
| #define STClocal 0x8000000000000ULL /// do not forward (see dmd.dsymbol.ForwardingScopeDsymbol). |
| |
| #define STClive 0x10000000000000ULL /// function `@live` attribute |
| #define STCregister 0x20000000000000ULL /// `register` storage class (ImportC) |
| #define STCvolatile 0x40000000000000ULL /// destined for volatile in the back end |
| |
| #define STC_TYPECTOR (STCconst | STCimmutable | STCshared | STCwild) |
| #define STC_FUNCATTR (STCref | STCnothrow | STCnogc | STCpure | STCproperty | STCsafe | STCtrusted | STCsystem) |
| |
| void ObjectNotFound(Identifier *id); |
| |
| /**************************************************************/ |
| |
| class Declaration : public Dsymbol |
| { |
| public: |
| Type *type; |
| Type *originalType; // before semantic analysis |
| StorageClass storage_class; |
| Visibility visibility; |
| LINK linkage; |
| short inuse; // used to detect cycles |
| uint8_t adFlags; |
| Symbol* isym; // import version of csym |
| DString mangleOverride; // overridden symbol with pragma(mangle, "...") |
| |
| const char *kind() const; |
| uinteger_t size(const Loc &loc); |
| |
| Dsymbol *search(const Loc &loc, Identifier *ident, int flags = SearchLocalsOnly); |
| |
| bool isStatic() const { return (storage_class & STCstatic) != 0; } |
| virtual bool isDelete(); |
| virtual bool isDataseg(); |
| virtual bool isThreadlocal(); |
| virtual bool isCodeseg() const; |
| bool isFinal() const { return (storage_class & STCfinal) != 0; } |
| virtual bool isAbstract() { return (storage_class & STCabstract) != 0; } |
| bool isConst() const { return (storage_class & STCconst) != 0; } |
| bool isImmutable() const { return (storage_class & STCimmutable) != 0; } |
| bool isWild() const { return (storage_class & STCwild) != 0; } |
| bool isAuto() const { return (storage_class & STCauto) != 0; } |
| bool isScope() const { return (storage_class & STCscope) != 0; } |
| bool isSynchronized() const { return (storage_class & STCsynchronized) != 0; } |
| bool isParameter() const { return (storage_class & STCparameter) != 0; } |
| bool isDeprecated() const { return (storage_class & STCdeprecated) != 0; } |
| bool isOverride() const { return (storage_class & STCoverride) != 0; } |
| bool isResult() const { return (storage_class & STCresult) != 0; } |
| bool isField() const { return (storage_class & STCfield) != 0; } |
| |
| bool isIn() const { return (storage_class & STCin) != 0; } |
| bool isOut() const { return (storage_class & STCout) != 0; } |
| bool isRef() const { return (storage_class & STCref) != 0; } |
| bool isReference() const { return (storage_class & (STCref | STCout)) != 0; } |
| |
| bool isFuture() const { return (storage_class & STCfuture) != 0; } |
| |
| Visibility visible(); |
| |
| Declaration *isDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| /**************************************************************/ |
| |
| class TupleDeclaration : public Declaration |
| { |
| public: |
| Objects *objects; |
| bool isexp; // true: expression tuple |
| |
| TypeTuple *tupletype; // !=NULL if this is a type tuple |
| |
| TupleDeclaration *syntaxCopy(Dsymbol *); |
| const char *kind() const; |
| Type *getType(); |
| Dsymbol *toAlias2(); |
| bool needThis(); |
| |
| TupleDeclaration *isTupleDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| /**************************************************************/ |
| |
| class AliasDeclaration : public Declaration |
| { |
| public: |
| Dsymbol *aliassym; |
| Dsymbol *overnext; // next in overload list |
| Dsymbol *_import; // !=NULL if unresolved internal alias for selective import |
| |
| static AliasDeclaration *create(const Loc &loc, Identifier *id, Type *type); |
| AliasDeclaration *syntaxCopy(Dsymbol *); |
| bool overloadInsert(Dsymbol *s); |
| const char *kind() const; |
| Type *getType(); |
| Dsymbol *toAlias(); |
| Dsymbol *toAlias2(); |
| bool isOverloadable() const; |
| |
| AliasDeclaration *isAliasDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| /**************************************************************/ |
| |
| class OverDeclaration : public Declaration |
| { |
| public: |
| Dsymbol *overnext; // next in overload list |
| Dsymbol *aliassym; |
| |
| const char *kind() const; |
| bool equals(const RootObject *o) const; |
| bool overloadInsert(Dsymbol *s); |
| |
| Dsymbol *toAlias(); |
| Dsymbol *isUnique(); |
| bool isOverloadable() const; |
| |
| OverDeclaration *isOverDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| /**************************************************************/ |
| |
| class VarDeclaration : public Declaration |
| { |
| public: |
| Initializer *_init; |
| FuncDeclarations nestedrefs; // referenced by these lexically nested functions |
| Dsymbol *aliassym; // if redone as alias to another symbol |
| VarDeclaration *lastVar; // Linked list of variables for goto-skips-init detection |
| Expression *edtor; // if !=NULL, does the destruction of the variable |
| IntRange *range; // if !NULL, the variable is known to be within the range |
| VarDeclarations *maybes; // STCmaybescope variables that are assigned to this STCmaybescope variable |
| |
| unsigned endlinnum; // line number of end of scope that this var lives in |
| unsigned offset; |
| unsigned sequenceNumber; // order the variables are declared |
| structalign_t alignment; |
| |
| // When interpreting, these point to the value (NULL if value not determinable) |
| // The index of this variable on the CTFE stack, ~0u if not allocated |
| unsigned ctfeAdrOnStack; |
| private: |
| uint16_t bitFields; |
| public: |
| int8_t canassign; // // it can be assigned to |
| uint8_t isdataseg; // private data for isDataseg |
| bool isargptr() const; // if parameter that _argptr points to |
| bool isargptr(bool v); |
| bool ctorinit() const; // it has been initialized in a ctor |
| bool ctorinit(bool v); |
| bool iscatchvar() const; // this is the exception object variable in catch() clause |
| bool iscatchvar(bool v); |
| bool isowner() const; // this is an Owner, despite it being `scope` |
| bool isowner(bool v); |
| bool setInCtorOnly() const; // field can only be set in a constructor, as it is const or immutable |
| bool setInCtorOnly(bool v); |
| bool onstack() const; // it is a class that was allocated on the stack |
| bool onstack(bool v); |
| bool overlapped() const; // if it is a field and has overlapping |
| bool overlapped(bool v); |
| bool overlapUnsafe() const; // if it is an overlapping field and the overlaps are unsafe |
| bool overlapUnsafe(bool v); |
| bool doNotInferScope() const; // do not infer 'scope' for this variable |
| bool doNotInferScope(bool v); |
| bool doNotInferReturn() const; // do not infer 'return' for this variable |
| bool doNotInferReturn(bool v); |
| bool isArgDtorVar() const; // temporary created to handle scope destruction of a function argument |
| bool isArgDtorVar(bool v); |
| static VarDeclaration *create(const Loc &loc, Type *t, Identifier *id, Initializer *init, StorageClass storage_class = STCundefined); |
| VarDeclaration *syntaxCopy(Dsymbol *); |
| void setFieldOffset(AggregateDeclaration *ad, FieldState& fieldState, bool isunion); |
| const char *kind() const; |
| AggregateDeclaration *isThis(); |
| bool needThis(); |
| bool isExport() const; |
| bool isImportedSymbol() const; |
| bool isCtorinit() const; |
| bool isDataseg(); |
| bool isThreadlocal(); |
| bool isCTFE(); |
| bool isOverlappedWith(VarDeclaration *v); |
| bool hasPointers(); |
| bool canTakeAddressOf(); |
| bool needsScopeDtor(); |
| void checkCtorConstInit(); |
| Dsymbol *toAlias(); |
| // Eliminate need for dynamic_cast |
| VarDeclaration *isVarDeclaration() { return (VarDeclaration *)this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| /**************************************************************/ |
| |
| class BitFieldDeclaration : public VarDeclaration |
| { |
| public: |
| Expression *width; |
| |
| unsigned fieldWidth; |
| unsigned bitOffset; |
| |
| BitFieldDeclaration *syntaxCopy(Dsymbol*); |
| BitFieldDeclaration *isBitFieldDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| /**************************************************************/ |
| |
| // This is a shell around a back end symbol |
| |
| class SymbolDeclaration : public Declaration |
| { |
| public: |
| AggregateDeclaration *dsym; |
| |
| // Eliminate need for dynamic_cast |
| SymbolDeclaration *isSymbolDeclaration() { return (SymbolDeclaration *)this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoDeclaration : public VarDeclaration |
| { |
| public: |
| Type *tinfo; |
| |
| static TypeInfoDeclaration *create(Type *tinfo); |
| TypeInfoDeclaration *syntaxCopy(Dsymbol *); |
| const char *toChars() const; |
| |
| TypeInfoDeclaration *isTypeInfoDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoStructDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoStructDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoClassDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoClassDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoInterfaceDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoInterfaceDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoPointerDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoPointerDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoArrayDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoArrayDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoStaticArrayDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoStaticArrayDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoAssociativeArrayDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoAssociativeArrayDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoEnumDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoEnumDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoFunctionDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoFunctionDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoDelegateDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoDelegateDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoTupleDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoTupleDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoConstDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoConstDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoInvariantDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoInvariantDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoSharedDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoSharedDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoWildDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoWildDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class TypeInfoVectorDeclaration : public TypeInfoDeclaration |
| { |
| public: |
| static TypeInfoVectorDeclaration *create(Type *tinfo); |
| |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| /**************************************************************/ |
| |
| class ThisDeclaration : public VarDeclaration |
| { |
| public: |
| ThisDeclaration *syntaxCopy(Dsymbol *); |
| ThisDeclaration *isThisDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| enum class ILS : unsigned char |
| { |
| ILSuninitialized, // not computed yet |
| ILSno, // cannot inline |
| ILSyes // can inline |
| }; |
| |
| /**************************************************************/ |
| |
| enum class BUILTIN : unsigned char |
| { |
| 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 |
| }; |
| |
| Expression *eval_builtin(const Loc &loc, FuncDeclaration *fd, Expressions *arguments); |
| BUILTIN isBuiltin(FuncDeclaration *fd); |
| |
| class FuncDeclaration : public Declaration |
| { |
| public: |
| Statements *frequires; // in contracts |
| Ensures *fensures; // out contracts |
| Statement *frequire; // lowered in contract |
| Statement *fensure; // lowered out contract |
| Statement *fbody; |
| |
| FuncDeclarations foverrides; // functions this function overrides |
| 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 |
| |
| const char *mangleString; // mangled symbol created from mangleExact() |
| |
| VarDeclaration *vresult; // result variable for out contracts |
| LabelDsymbol *returnLabel; // where the return goes |
| |
| void *isTypeIsolatedCache; // An AA on the D side to cache an expensive check result |
| |
| // 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; // for member functions, index into vtbl[] |
| |
| ILS inlineStatusStmt; |
| ILS inlineStatusExp; |
| PINLINE inlining; |
| |
| int inlineNest; // !=0 if nested inline |
| |
| // true if errors in semantic3 this function's frame ptr |
| ForeachStatement *fes; // if foreach body, this is the foreach |
| BaseClass* interfaceVirtual; // if virtual, but only appears in 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 |
| |
| // 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 |
| int hasReturnExp; |
| |
| VarDeclaration *nrvo_var; // variable to replace with shidden |
| Symbol *shidden; // hidden pointer passed to function |
| |
| ReturnStatements *returns; |
| |
| GotoStatements *gotos; // Gotos with forward references |
| |
| // set if this is a known, builtin function we can evaluate at compile time |
| BUILTIN builtin; |
| |
| // 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 |
| VarDeclarations closureVars; |
| |
| /** Outer variables which are referenced by this nested function |
| * (the inverse of closureVars) |
| */ |
| VarDeclarations outerVars; |
| |
| // Sibling nested functions which called this one |
| FuncDeclarations siblingCallers; |
| |
| FuncDeclarations *inlinedNestedCallees; |
| |
| unsigned flags; // FUNCFLAGxxxxx |
| |
| // Data for a function declaration that is needed for the Objective-C |
| // integration. |
| ObjcFuncDeclaration objc; |
| |
| static FuncDeclaration *create(const Loc &loc, const Loc &endloc, Identifier *id, StorageClass storage_class, Type *type, bool noreturn = false); |
| FuncDeclaration *syntaxCopy(Dsymbol *); |
| bool functionSemantic(); |
| bool functionSemantic3(); |
| bool equals(const RootObject *o) const; |
| |
| int overrides(FuncDeclaration *fd); |
| int findVtblIndex(Dsymbols *vtbl, int dim); |
| BaseClass *overrideInterface(); |
| bool overloadInsert(Dsymbol *s); |
| bool inUnittest(); |
| MATCH leastAsSpecialized(FuncDeclaration *g); |
| LabelDsymbol *searchLabel(Identifier *ident, const Loc &loc); |
| int getLevel(FuncDeclaration *fd, int intypeof); // lexical nesting level difference |
| int getLevelAndCheck(const Loc &loc, Scope *sc, FuncDeclaration *fd); |
| const char *toPrettyChars(bool QualifyTypes = false); |
| const char *toFullSignature(); // for diagnostics, e.g. 'int foo(int x, int y) pure' |
| bool isMain() const; |
| bool isCMain() const; |
| bool isWinMain() const; |
| bool isDllMain() const; |
| bool isExport() const; |
| bool isImportedSymbol() const; |
| bool isCodeseg() const; |
| bool isOverloadable() const; |
| bool isAbstract(); |
| PURE isPure(); |
| PURE isPureBypassingInference(); |
| bool isSafe(); |
| bool isSafeBypassingInference(); |
| bool isTrusted(); |
| |
| bool isNogc(); |
| bool isNogcBypassingInference(); |
| bool isNRVO() const; |
| void isNRVO(bool v); |
| bool isNaked() const; |
| bool isGenerated() const; |
| void isGenerated(bool v); |
| bool isIntroducing() const; |
| bool hasSemantic3Errors() const; |
| bool hasNoEH() const; |
| bool inferRetType() const; |
| bool hasDualContext() const; |
| bool hasAlwaysInlines() const; |
| bool isCrtCtor() const; |
| bool isCrtDtor() const; |
| |
| virtual bool isNested() const; |
| AggregateDeclaration *isThis(); |
| bool needThis(); |
| bool isVirtualMethod(); |
| virtual bool isVirtual() const; |
| bool isFinalFunc() const; |
| virtual bool addPreInvariant(); |
| virtual bool addPostInvariant(); |
| const char *kind() const; |
| bool isUnique(); |
| bool needsClosure(); |
| bool hasNestedFrameRefs(); |
| ParameterList getParameterList(); |
| |
| static FuncDeclaration *genCfunc(Parameters *args, Type *treturn, const char *name, StorageClass stc=0); |
| static FuncDeclaration *genCfunc(Parameters *args, Type *treturn, Identifier *id, StorageClass stc=0); |
| |
| bool checkNRVO(); |
| |
| FuncDeclaration *isFuncDeclaration() { return this; } |
| |
| virtual FuncDeclaration *toAliasFunc() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class FuncAliasDeclaration : public FuncDeclaration |
| { |
| public: |
| FuncDeclaration *funcalias; |
| bool hasOverloads; |
| |
| FuncAliasDeclaration *isFuncAliasDeclaration() { return this; } |
| const char *kind() const; |
| |
| FuncDeclaration *toAliasFunc(); |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class FuncLiteralDeclaration : public FuncDeclaration |
| { |
| public: |
| TOK tok; // TOKfunction or TOKdelegate |
| Type *treq; // target of return type inference |
| |
| // backend |
| bool deferToObj; |
| |
| FuncLiteralDeclaration *syntaxCopy(Dsymbol *); |
| bool isNested() const; |
| AggregateDeclaration *isThis(); |
| bool isVirtual() const; |
| bool addPreInvariant(); |
| bool addPostInvariant(); |
| |
| void modifyReturns(Scope *sc, Type *tret); |
| |
| FuncLiteralDeclaration *isFuncLiteralDeclaration() { return this; } |
| const char *kind() const; |
| const char *toPrettyChars(bool QualifyTypes = false); |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class CtorDeclaration : public FuncDeclaration |
| { |
| public: |
| bool isCpCtor; |
| CtorDeclaration *syntaxCopy(Dsymbol *); |
| const char *kind() const; |
| const char *toChars() const; |
| bool isVirtual() const; |
| bool addPreInvariant(); |
| bool addPostInvariant(); |
| |
| CtorDeclaration *isCtorDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class PostBlitDeclaration : public FuncDeclaration |
| { |
| public: |
| PostBlitDeclaration *syntaxCopy(Dsymbol *); |
| bool isVirtual() const; |
| bool addPreInvariant(); |
| bool addPostInvariant(); |
| bool overloadInsert(Dsymbol *s); |
| |
| PostBlitDeclaration *isPostBlitDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class DtorDeclaration : public FuncDeclaration |
| { |
| public: |
| DtorDeclaration *syntaxCopy(Dsymbol *); |
| const char *kind() const; |
| const char *toChars() const; |
| bool isVirtual() const; |
| bool addPreInvariant(); |
| bool addPostInvariant(); |
| bool overloadInsert(Dsymbol *s); |
| |
| DtorDeclaration *isDtorDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class StaticCtorDeclaration : public FuncDeclaration |
| { |
| public: |
| StaticCtorDeclaration *syntaxCopy(Dsymbol *); |
| AggregateDeclaration *isThis(); |
| bool isVirtual() const; |
| bool addPreInvariant(); |
| bool addPostInvariant(); |
| bool hasStaticCtorOrDtor(); |
| |
| StaticCtorDeclaration *isStaticCtorDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class SharedStaticCtorDeclaration : public StaticCtorDeclaration |
| { |
| public: |
| SharedStaticCtorDeclaration *syntaxCopy(Dsymbol *); |
| |
| SharedStaticCtorDeclaration *isSharedStaticCtorDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class StaticDtorDeclaration : public FuncDeclaration |
| { |
| public: |
| VarDeclaration *vgate; // 'gate' variable |
| |
| StaticDtorDeclaration *syntaxCopy(Dsymbol *); |
| AggregateDeclaration *isThis(); |
| bool isVirtual() const; |
| bool hasStaticCtorOrDtor(); |
| bool addPreInvariant(); |
| bool addPostInvariant(); |
| |
| StaticDtorDeclaration *isStaticDtorDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class SharedStaticDtorDeclaration : public StaticDtorDeclaration |
| { |
| public: |
| SharedStaticDtorDeclaration *syntaxCopy(Dsymbol *); |
| |
| SharedStaticDtorDeclaration *isSharedStaticDtorDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class InvariantDeclaration : public FuncDeclaration |
| { |
| public: |
| InvariantDeclaration *syntaxCopy(Dsymbol *); |
| bool isVirtual() const; |
| bool addPreInvariant(); |
| bool addPostInvariant(); |
| |
| InvariantDeclaration *isInvariantDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class UnitTestDeclaration : public FuncDeclaration |
| { |
| public: |
| char *codedoc; /** For documented unittest. */ |
| |
| // toObjFile() these nested functions after this one |
| FuncDeclarations deferredNested; |
| |
| UnitTestDeclaration *syntaxCopy(Dsymbol *); |
| AggregateDeclaration *isThis(); |
| bool isVirtual() const; |
| bool addPreInvariant(); |
| bool addPostInvariant(); |
| |
| UnitTestDeclaration *isUnitTestDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |
| |
| class NewDeclaration : public FuncDeclaration |
| { |
| public: |
| NewDeclaration *syntaxCopy(Dsymbol *); |
| const char *kind() const; |
| bool isVirtual() const; |
| bool addPreInvariant(); |
| bool addPostInvariant(); |
| |
| NewDeclaration *isNewDeclaration() { return this; } |
| void accept(Visitor *v) { v->visit(this); } |
| }; |