Viewing file:  declaration.h (28.51 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/* 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; // may be `LINK::system`; use `resolvedLinkage()` to resolve it
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; }
LINK resolvedLinkage() const; // returns the linkage, resolving the target-specific `System` one
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;
void isNaked(bool v);
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;
void isCrtCtor(bool v);
bool isCrtDtor() const;
void isCrtDtor(bool v);
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); }
};
|
