dmd2/declaration.h

   1
   2 // Compiler implementation of the D programming language
   3 // Copyright (c) 1999-2008 by Digital Mars
   4 // All Rights Reserved
   5 // written by Walter Bright
   6 // http://www.digitalmars.com
   7 // License for redistribution is by either the Artistic License
   8 // in artistic.txt, or the GNU General Public License in gnu.txt.
   9 // See the included readme.txt for details.
  10
  11 /* NOTE: This file has been patched from the original DMD distribution to
  12    work with the GDC compiler.
  13
  14    Modified by David Friedman, December 2006
  15 */
  16
  17 #ifndef DMD_DECLARATION_H
  18 #define DMD_DECLARATION_H
  19
  20 #ifdef __DMC__
  21 #pragma once
  22 #endif /* __DMC__ */
  23
  24 #include "dsymbol.h"
  25 #include "lexer.h"
  26 #include "mtype.h"
  27
  28 struct Expression;
  29 struct Statement;
  30 struct LabelDsymbol;
  31 struct Initializer;
  32 struct Module;
  33 struct InlineScanState;
  34 struct ForeachStatement;
  35 struct FuncDeclaration;
  36 struct ExpInitializer;
  37 struct StructDeclaration;
  38 struct TupleType;
  39 struct InterState;
  40 struct IRState;
  41
  42 enum PROT;
  43 enum LINK;
  44 enum TOK;
  45 enum MATCH;
  46
  47 enum STC
  48 {
  49     STCundefined    = 0,
  50     STCstatic       = 1,
  51     STCextern       = 2,
  52     STCconst        = 4,
  53     STCfinal        = 8,
  54     STCabstract     = 0x10,
  55     STCparameter    = 0x20,
  56     STCfield        = 0x40,
  57     STCoverride     = 0x80,
  58     STCauto         = 0x100,
  59     STCsynchronized = 0x200,
  60     STCdeprecated   = 0x400,
  61     STCin           = 0x800,            // in parameter
  62     STCout          = 0x1000,           // out parameter
  63     STClazy         = 0x2000,           // lazy parameter
  64     STCforeach      = 0x4000,           // variable for foreach loop
  65     STCcomdat       = 0x8000,           // should go into COMDAT record
  66     STCvariadic     = 0x10000,          // variadic function argument
  67     STCctorinit     = 0x20000,          // can only be set inside constructor
  68     STCtemplateparameter = 0x40000,     // template parameter
  69     STCscope        = 0x80000,          // template parameter
  70     STCinvariant    = 0x100000,
  71     STCref          = 0x200000,
  72     STCinit         = 0x400000,         // has explicit initializer
  73     STCmanifest     = 0x800000,         // manifest constant
  74     STCnodtor       = 0x1000000,        // don't run destructor
  75     STCnothrow      = 0x2000000,        // never throws exceptions
  76     STCpure         = 0x4000000,        // pure function
  77     STCtls          = 0x8000000,        // thread local
  78 };
  79
  80 struct Match
  81 {
  82     int count;                  // number of matches found
  83     MATCH last;                 // match level of lastf
  84     FuncDeclaration *lastf;     // last matching function we found
  85     FuncDeclaration *nextf;     // current matching function
  86     FuncDeclaration *anyf;      // pick a func, any func, to use for error recovery
  87 };
  88
  89 void overloadResolveX(Match *m, FuncDeclaration *f,
  90         Expression *ethis, Expressions *arguments);
  91 int overloadApply(FuncDeclaration *fstart,
  92         int (*fp)(void *, FuncDeclaration *),
  93         void *param);
  94
  95 /**************************************************************/
  96
  97 struct Declaration : Dsymbol
  98 {
  99     Type *type;
 100     Type *originalType;         // before semantic analysis
 101     unsigned storage_class;
 102     enum PROT protection;
 103     enum LINK linkage;
 104     Expressions * attributes; // GCC decl/type attributes
 105
 106     Declaration(Identifier *id);
 107     void semantic(Scope *sc);
 108     char *kind();
 109     target_size_t size(Loc loc);
 110     void checkModify(Loc loc, Scope *sc, Type *t);
 111
 112     void emitComment(Scope *sc);
 113     void toDocBuffer(OutBuffer *buf);
 114
 115     char *mangle();
 116     int isStatic() { return storage_class & STCstatic; }
 117     virtual int isStaticConstructor();
 118     virtual int isStaticDestructor();
 119     virtual int isDelete();
 120     virtual int isDataseg();
 121     virtual int isCodeseg();
 122     int isCtorinit()     { return storage_class & STCctorinit; }
 123     int isFinal()        { return storage_class & STCfinal; }
 124     int isAbstract()     { return storage_class & STCabstract; }
 125     int isConst()        { return storage_class & STCconst; }
 126     int isInvariant()    { return storage_class & STCinvariant; }
 127     int isAuto()         { return storage_class & STCauto; }
 128     int isScope()        { return storage_class & (STCscope | STCauto); }
 129     int isSynchronized() { return storage_class & STCsynchronized; }
 130     int isParameter()    { return storage_class & STCparameter; }
 131     int isDeprecated()   { return storage_class & STCdeprecated; }
 132     int isOverride()     { return storage_class & STCoverride; }
 133
 134     int isIn()    { return storage_class & STCin; }
 135     int isOut()   { return storage_class & STCout; }
 136     int isRef()   { return storage_class & STCref; }
 137
 138     enum PROT prot();
 139
 140     Declaration *isDeclaration() { return this; }
 141 };
 142
 143 /**************************************************************/
 144
 145 struct TupleDeclaration : Declaration
 146 {
 147     Objects *objects;
 148     int isexp;                  // 1: expression tuple
 149
 150     TypeTuple *tupletype;       // !=NULL if this is a type tuple
 151
 152     TupleDeclaration(Loc loc, Identifier *ident, Objects *objects);
 153     Dsymbol *syntaxCopy(Dsymbol *);
 154     char *kind();
 155     Type *getType();
 156     int needThis();
 157
 158     TupleDeclaration *isTupleDeclaration() { return this; }
 159 };
 160
 161 /**************************************************************/
 162
 163 struct TypedefDeclaration : Declaration
 164 {
 165     Type *basetype;
 166     Initializer *init;
 167     int sem;                    // 0: semantic() has not been run
 168                                 // 1: semantic() is in progress
 169                                 // 2: semantic() has been run
 170                                 // 3: semantic2() has been run
 171     int inuse;                  // used to detect typedef cycles
 172
 173     TypedefDeclaration(Loc loc, Identifier *ident, Type *basetype, Initializer *init);
 174     Dsymbol *syntaxCopy(Dsymbol *);
 175     void semantic(Scope *sc);
 176     void semantic2(Scope *sc);
 177     char *mangle();
 178     char *kind();
 179     Type *getType();
 180     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 181 #ifdef _DH
 182     Type *htype;
 183     Type *hbasetype;
 184 #endif
 185
 186     void toDocBuffer(OutBuffer *buf);
 187
 188     void toObjFile(int multiobj);                       // compile to .obj file
 189     void toDebug();
 190     int cvMember(unsigned char *p);
 191
 192     TypedefDeclaration *isTypedefDeclaration() { return this; }
 193
 194     Symbol *sinit;
 195     Symbol *toInitializer();
 196 };
 197
 198 /**************************************************************/
 199
 200 struct AliasDeclaration : Declaration
 201 {
 202     Dsymbol *aliassym;
 203     Dsymbol *overnext;          // next in overload list
 204     int inSemantic;
 205
 206     AliasDeclaration(Loc loc, Identifier *ident, Type *type);
 207     AliasDeclaration(Loc loc, Identifier *ident, Dsymbol *s);
 208     Dsymbol *syntaxCopy(Dsymbol *);
 209     void semantic(Scope *sc);
 210     int overloadInsert(Dsymbol *s);
 211     char *kind();
 212     Type *getType();
 213     Dsymbol *toAlias();
 214     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 215 #ifdef _DH
 216     Type *htype;
 217     Dsymbol *haliassym;
 218 #endif
 219
 220     void toDocBuffer(OutBuffer *buf);
 221
 222     AliasDeclaration *isAliasDeclaration() { return this; }
 223 };
 224
 225 /**************************************************************/
 226
 227 struct VarDeclaration : Declaration
 228 {
 229     Initializer *init;
 230     target_size_t offset;
 231     int noauto;                 // no auto semantics
 232     FuncDeclarations nestedrefs; // referenced by these lexically nested functions
 233     int inuse;
 234     int ctorinit;               // it has been initialized in a ctor
 235     int onstack;                // 1: it has been allocated on the stack
 236                                 // 2: on stack, run destructor anyway
 237     int canassign;              // it can be assigned to
 238     Dsymbol *aliassym;          // if redone as alias to another symbol
 239     Expression *value;          // when interpreting, this is the value
 240                                 // (NULL if value not determinable)
 241     Scope *scope;               // !=NULL means context to use
 242
 243     VarDeclaration(Loc loc, Type *t, Identifier *id, Initializer *init);
 244     Dsymbol *syntaxCopy(Dsymbol *);
 245     void semantic(Scope *sc);
 246     void semantic2(Scope *sc);
 247     char *kind();
 248     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 249 #ifdef _DH
 250     Type *htype;
 251     Initializer *hinit;
 252 #endif
 253     int needThis();
 254     int isImportedSymbol();
 255     int isDataseg();
 256     int hasPointers();
 257     int canTakeAddressOf();
 258     int needsAutoDtor();
 259     Expression *callAutoDtor(Scope *sc);
 260     ExpInitializer *getExpInitializer();
 261     Expression *getConstInitializer();
 262     void checkCtorConstInit();
 263     void checkNestedReference(Scope *sc, Loc loc);
 264     Dsymbol *toAlias();
 265
 266     Symbol *toSymbol();
 267     void toObjFile(int multiobj);                       // compile to .obj file
 268     int cvMember(unsigned char *p);
 269
 270     // Eliminate need for dynamic_cast
 271     VarDeclaration *isVarDeclaration() { return (VarDeclaration *)this; }
 272 };
 273
 274
 275 /**************************************************************/
 276
 277 // This is a shell around a back end symbol
 278
 279 struct SymbolDeclaration : Declaration
 280 {
 281     Symbol *sym;
 282     StructDeclaration *dsym;
 283
 284     SymbolDeclaration(Loc loc, Symbol *s, StructDeclaration *dsym);
 285
 286     Symbol *toSymbol();
 287
 288     // Eliminate need for dynamic_cast
 289     SymbolDeclaration *isSymbolDeclaration() { return (SymbolDeclaration *)this; }
 290 };
 291
 292 struct ClassInfoDeclaration : VarDeclaration
 293 {
 294     ClassDeclaration *cd;
 295
 296     ClassInfoDeclaration(ClassDeclaration *cd);
 297     Dsymbol *syntaxCopy(Dsymbol *);
 298     void semantic(Scope *sc);
 299
 300     void emitComment(Scope *sc);
 301
 302     Symbol *toSymbol();
 303 };
 304
 305 struct ModuleInfoDeclaration : VarDeclaration
 306 {
 307     Module *mod;
 308
 309     ModuleInfoDeclaration(Module *mod);
 310     Dsymbol *syntaxCopy(Dsymbol *);
 311     void semantic(Scope *sc);
 312
 313     void emitComment(Scope *sc);
 314
 315     Symbol *toSymbol();
 316 };
 317
 318 struct TypeInfoDeclaration : VarDeclaration
 319 {
 320     Type *tinfo;
 321
 322     TypeInfoDeclaration(Type *tinfo, int internal);
 323     Dsymbol *syntaxCopy(Dsymbol *);
 324     void semantic(Scope *sc);
 325
 326     void emitComment(Scope *sc);
 327
 328     Symbol *toSymbol();
 329     void toObjFile(int multiobj);                       // compile to .obj file
 330     virtual void toDt(dt_t **pdt);
 331 };
 332
 333 struct TypeInfoStructDeclaration : TypeInfoDeclaration
 334 {
 335     TypeInfoStructDeclaration(Type *tinfo);
 336
 337     void toDt(dt_t **pdt);
 338 };
 339
 340 struct TypeInfoClassDeclaration : TypeInfoDeclaration
 341 {
 342     TypeInfoClassDeclaration(Type *tinfo);
 343
 344     void toDt(dt_t **pdt);
 345 };
 346
 347 struct TypeInfoInterfaceDeclaration : TypeInfoDeclaration
 348 {
 349     TypeInfoInterfaceDeclaration(Type *tinfo);
 350
 351     void toDt(dt_t **pdt);
 352 };
 353
 354 struct TypeInfoTypedefDeclaration : TypeInfoDeclaration
 355 {
 356     TypeInfoTypedefDeclaration(Type *tinfo);
 357
 358     void toDt(dt_t **pdt);
 359 };
 360
 361 struct TypeInfoPointerDeclaration : TypeInfoDeclaration
 362 {
 363     TypeInfoPointerDeclaration(Type *tinfo);
 364
 365     void toDt(dt_t **pdt);
 366 };
 367
 368 struct TypeInfoArrayDeclaration : TypeInfoDeclaration
 369 {
 370     TypeInfoArrayDeclaration(Type *tinfo);
 371
 372     void toDt(dt_t **pdt);
 373 };
 374
 375 struct TypeInfoStaticArrayDeclaration : TypeInfoDeclaration
 376 {
 377     TypeInfoStaticArrayDeclaration(Type *tinfo);
 378
 379     void toDt(dt_t **pdt);
 380 };
 381
 382 struct TypeInfoAssociativeArrayDeclaration : TypeInfoDeclaration
 383 {
 384     TypeInfoAssociativeArrayDeclaration(Type *tinfo);
 385
 386     void toDt(dt_t **pdt);
 387 };
 388
 389 struct TypeInfoEnumDeclaration : TypeInfoDeclaration
 390 {
 391     TypeInfoEnumDeclaration(Type *tinfo);
 392
 393     void toDt(dt_t **pdt);
 394 };
 395
 396 struct TypeInfoFunctionDeclaration : TypeInfoDeclaration
 397 {
 398     TypeInfoFunctionDeclaration(Type *tinfo);
 399
 400     void toDt(dt_t **pdt);
 401 };
 402
 403 struct TypeInfoDelegateDeclaration : TypeInfoDeclaration
 404 {
 405     TypeInfoDelegateDeclaration(Type *tinfo);
 406
 407     void toDt(dt_t **pdt);
 408 };
 409
 410 struct TypeInfoTupleDeclaration : TypeInfoDeclaration
 411 {
 412     TypeInfoTupleDeclaration(Type *tinfo);
 413
 414     void toDt(dt_t **pdt);
 415 };
 416
 417 #if V2
 418 struct TypeInfoConstDeclaration : TypeInfoDeclaration
 419 {
 420     TypeInfoConstDeclaration(Type *tinfo);
 421
 422     void toDt(dt_t **pdt);
 423 };
 424
 425 struct TypeInfoInvariantDeclaration : TypeInfoDeclaration
 426 {
 427     TypeInfoInvariantDeclaration(Type *tinfo);
 428
 429     void toDt(dt_t **pdt);
 430 };
 431 #endif
 432
 433 /**************************************************************/
 434
 435 struct ThisDeclaration : VarDeclaration
 436 {
 437     ThisDeclaration(Type *t);
 438     Dsymbol *syntaxCopy(Dsymbol *);
 439 };
 440
 441 enum ILS
 442 {
 443     ILSuninitialized,   // not computed yet
 444     ILSno,              // cannot inline
 445     ILSyes,             // can inline
 446 };
 447
 448 /**************************************************************/
 449 #if V2
 450
 451 enum BUILTIN
 452 {
 453     BUILTINunknown = -1,        // not known if this is a builtin
 454     BUILTINnot,                 // this is not a builtin
 455     BUILTINsin,                 // std.math.sin
 456     BUILTINcos,                 // std.math.cos
 457     BUILTINtan,                 // std.math.tan
 458     BUILTINsqrt,                // std.math.sqrt
 459     BUILTINfabs,                // std.math.fabs
 460 };
 461
 462 Expression *eval_builtin(enum BUILTIN builtin, Expressions *arguments);
 463
 464 #endif
 465
 466 struct FuncDeclaration : Declaration
 467 {
 468     Array *fthrows;                     // Array of Type's of exceptions (not used)
 469     Statement *frequire;
 470     Statement *fensure;
 471     Statement *fbody;
 472
 473     Identifier *outId;                  // identifier for out statement
 474     VarDeclaration *vresult;            // variable corresponding to outId
 475     LabelDsymbol *returnLabel;          // where the return goes
 476
 477     DsymbolTable *localsymtab;          // used to prevent symbols in different
 478                                         // scopes from having the same name
 479     VarDeclaration *vthis;              // 'this' parameter (member and nested)
 480     VarDeclaration *v_arguments;        // '_arguments' parameter
 481 #if IN_GCC
 482     VarDeclaration *v_arguments_var;    // '_arguments' variable
 483     VarDeclaration *v_argptr;           // '_argptr' variable
 484 #endif
 485     Dsymbols *parameters;               // Array of VarDeclaration's for parameters
 486     DsymbolTable *labtab;               // statement label symbol table
 487     Declaration *overnext;              // next in overload list
 488     Loc endloc;                         // location of closing curly bracket
 489     int vtblIndex;                      // for member functions, index into vtbl[]
 490     int naked;                          // !=0 if naked
 491     int inlineAsm;                      // !=0 if has inline assembler
 492     ILS inlineStatus;
 493     int inlineNest;                     // !=0 if nested inline
 494     int cantInterpret;                  // !=0 if cannot interpret function
 495     int semanticRun;                    // !=0 if semantic3() had been run
 496                                         // this function's frame ptr
 497     ForeachStatement *fes;              // if foreach body, this is the foreach
 498     int introducing;                    // !=0 if 'introducing' function
 499     Type *tintro;                       // if !=NULL, then this is the type
 500                                         // of the 'introducing' function
 501                                         // this one is overriding
 502     int inferRetType;                   // !=0 if return type is to be inferred
 503     Scope *scope;                       // !=NULL means context to use
 504
 505     // Things that should really go into Scope
 506     int hasReturnExp;                   // 1 if there's a return exp; statement
 507                                         // 2 if there's a throw statement
 508                                         // 4 if there's an assert(0)
 509                                         // 8 if there's inline asm
 510
 511     // Support for NRVO (named return value optimization)
 512     int nrvo_can;                       // !=0 means we can do it
 513     VarDeclaration *nrvo_var;           // variable to replace with shidden
 514     Symbol *shidden;                    // hidden pointer passed to function
 515
 516 #if V2
 517     enum BUILTIN builtin;               // set if this is a known, builtin
 518                                         // function we can evaluate at compile
 519                                         // time
 520
 521     int tookAddressOf;                  // set if someone took the address of
 522                                         // this function
 523     Dsymbols closureVars;               // local variables in this function
 524                                         // which are referenced by nested
 525                                         // functions
 526 #else
 527     int nestedFrameRef;                 // !=0 if nested variables referenced
 528 #endif
 529
 530     FuncDeclaration(Loc loc, Loc endloc, Identifier *id, enum STC storage_class, Type *type);
 531     Dsymbol *syntaxCopy(Dsymbol *);
 532     void semantic(Scope *sc);
 533     void semantic2(Scope *sc);
 534     void semantic3(Scope *sc);
 535     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 536     void bodyToCBuffer(OutBuffer *buf, HdrGenState *hgs);
 537     int overrides(FuncDeclaration *fd);
 538     int findVtblIndex(Array *vtbl, int dim);
 539     int overloadInsert(Dsymbol *s);
 540     FuncDeclaration *overloadExactMatch(Type *t);
 541     FuncDeclaration *overloadResolve(Loc loc, Expression *ethis, Expressions *arguments, int flags = 0);
 542     MATCH leastAsSpecialized(FuncDeclaration *g);
 543     LabelDsymbol *searchLabel(Identifier *ident);
 544     AggregateDeclaration *isThis();
 545     AggregateDeclaration *isMember2();
 546     int getLevel(Loc loc, FuncDeclaration *fd); // lexical nesting level difference
 547     void appendExp(Expression *e);
 548     void appendState(Statement *s);
 549     char *mangle();
 550     int isMain();
 551     int isWinMain();
 552     int isDllMain();
 553     enum BUILTIN isBuiltin();
 554     int isExport();
 555     int isImportedSymbol();
 556     int isAbstract();
 557     int isCodeseg();
 558     int isOverloadable();
 559     virtual int isNested();
 560     int needThis();
 561     virtual int isVirtual();
 562     virtual int isFinal();
 563     virtual int addPreInvariant();
 564     virtual int addPostInvariant();
 565     Expression *interpret(InterState *istate, Expressions *arguments);
 566     void inlineScan();
 567     int canInline(int hasthis, int hdrscan = 0);
 568     Expression *doInline(InlineScanState *iss, Expression *ethis, Array *arguments);
 569     char *kind();
 570     void toDocBuffer(OutBuffer *buf);
 571     FuncDeclaration *isUnique();
 572     int needsClosure();
 573
 574     static FuncDeclaration *genCfunc(Type *treturn, char *name,
 575         Type *t1 = 0, Type *t2 = 0, Type *t3 = 0);
 576     static FuncDeclaration *genCfunc(Type *treturn, Identifier *id,
 577         Type *t1 = 0, Type *t2 = 0, Type *t3 = 0);
 578
 579     Symbol *toSymbol();
 580     Symbol *toThunkSymbol(target_ptrdiff_t offset);     // thunk version
 581     void toObjFile(int multiobj);                       // compile to .obj file
 582     int cvMember(unsigned char *p);
 583     void buildClosure(IRState *irs);
 584
 585     FuncDeclaration *isFuncDeclaration() { return this; }
 586 };
 587
 588 struct FuncAliasDeclaration : FuncDeclaration
 589 {
 590     FuncDeclaration *funcalias;
 591
 592     FuncAliasDeclaration(FuncDeclaration *funcalias);
 593
 594     FuncAliasDeclaration *isFuncAliasDeclaration() { return this; }
 595     char *kind();
 596     Symbol *toSymbol();
 597 };
 598
 599 struct FuncLiteralDeclaration : FuncDeclaration
 600 {
 601     enum TOK tok;                       // TOKfunction or TOKdelegate
 602
 603     FuncLiteralDeclaration(Loc loc, Loc endloc, Type *type, enum TOK tok,
 604         ForeachStatement *fes);
 605     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 606     Dsymbol *syntaxCopy(Dsymbol *);
 607     int isNested();
 608
 609     FuncLiteralDeclaration *isFuncLiteralDeclaration() { return this; }
 610     char *kind();
 611 };
 612
 613 struct CtorDeclaration : FuncDeclaration
 614 {   Arguments *arguments;
 615     int varargs;
 616
 617     CtorDeclaration(Loc loc, Loc endloc, Arguments *arguments, int varargs);
 618     Dsymbol *syntaxCopy(Dsymbol *);
 619     void semantic(Scope *sc);
 620     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 621     char *kind();
 622     char *toChars();
 623     int isVirtual();
 624     int addPreInvariant();
 625     int addPostInvariant();
 626     void toDocBuffer(OutBuffer *buf);
 627
 628     CtorDeclaration *isCtorDeclaration() { return this; }
 629 };
 630
 631 struct PostBlitDeclaration : FuncDeclaration
 632 {
 633     PostBlitDeclaration(Loc loc, Loc endloc);
 634     PostBlitDeclaration(Loc loc, Loc endloc, Identifier *id);
 635     Dsymbol *syntaxCopy(Dsymbol *);
 636     void semantic(Scope *sc);
 637     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 638     int isVirtual();
 639     int addPreInvariant();
 640     int addPostInvariant();
 641     int overloadInsert(Dsymbol *s);
 642     void emitComment(Scope *sc);
 643
 644     PostBlitDeclaration *isPostBlitDeclaration() { return this; }
 645 };
 646
 647 struct DtorDeclaration : FuncDeclaration
 648 {
 649     DtorDeclaration(Loc loc, Loc endloc);
 650     DtorDeclaration(Loc loc, Loc endloc, Identifier *id);
 651     Dsymbol *syntaxCopy(Dsymbol *);
 652     void semantic(Scope *sc);
 653     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 654     int isVirtual();
 655     int addPreInvariant();
 656     int addPostInvariant();
 657     int overloadInsert(Dsymbol *s);
 658     void emitComment(Scope *sc);
 659
 660     DtorDeclaration *isDtorDeclaration() { return this; }
 661 };
 662
 663 struct StaticCtorDeclaration : FuncDeclaration
 664 {
 665     StaticCtorDeclaration(Loc loc, Loc endloc);
 666     Dsymbol *syntaxCopy(Dsymbol *);
 667     void semantic(Scope *sc);
 668     AggregateDeclaration *isThis();
 669     int isStaticConstructor();
 670     int isVirtual();
 671     int addPreInvariant();
 672     int addPostInvariant();
 673     void emitComment(Scope *sc);
 674     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 675
 676     StaticCtorDeclaration *isStaticCtorDeclaration() { return this; }
 677 };
 678
 679 struct StaticDtorDeclaration : FuncDeclaration
 680 {
 681     StaticDtorDeclaration(Loc loc, Loc endloc);
 682     Dsymbol *syntaxCopy(Dsymbol *);
 683     void semantic(Scope *sc);
 684     AggregateDeclaration *isThis();
 685     int isStaticDestructor();
 686     int isVirtual();
 687     int addPreInvariant();
 688     int addPostInvariant();
 689     void emitComment(Scope *sc);
 690     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 691
 692     StaticDtorDeclaration *isStaticDtorDeclaration() { return this; }
 693 };
 694
 695 struct InvariantDeclaration : FuncDeclaration
 696 {
 697     InvariantDeclaration(Loc loc, Loc endloc);
 698     Dsymbol *syntaxCopy(Dsymbol *);
 699     void semantic(Scope *sc);
 700     int isVirtual();
 701     int addPreInvariant();
 702     int addPostInvariant();
 703     void emitComment(Scope *sc);
 704     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 705
 706     InvariantDeclaration *isInvariantDeclaration() { return this; }
 707 };
 708
 709
 710 struct UnitTestDeclaration : FuncDeclaration
 711 {
 712     UnitTestDeclaration(Loc loc, Loc endloc);
 713     Dsymbol *syntaxCopy(Dsymbol *);
 714     void semantic(Scope *sc);
 715     AggregateDeclaration *isThis();
 716     int isVirtual();
 717     int addPreInvariant();
 718     int addPostInvariant();
 719     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 720
 721     UnitTestDeclaration *isUnitTestDeclaration() { return this; }
 722 };
 723
 724 struct NewDeclaration : FuncDeclaration
 725 {   Arguments *arguments;
 726     int varargs;
 727
 728     NewDeclaration(Loc loc, Loc endloc, Arguments *arguments, int varargs);
 729     Dsymbol *syntaxCopy(Dsymbol *);
 730     void semantic(Scope *sc);
 731     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 732     char *kind();
 733     int isVirtual();
 734     int addPreInvariant();
 735     int addPostInvariant();
 736
 737     NewDeclaration *isNewDeclaration() { return this; }
 738 };
 739
 740
 741 struct DeleteDeclaration : FuncDeclaration
 742 {   Arguments *arguments;
 743
 744     DeleteDeclaration(Loc loc, Loc endloc, Arguments *arguments);
 745     Dsymbol *syntaxCopy(Dsymbol *);
 746     void semantic(Scope *sc);
 747     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 748     char *kind();
 749     int isDelete();
 750     int isVirtual();
 751     int addPreInvariant();
 752     int addPostInvariant();
 753 #ifdef _DH
 754     DeleteDeclaration *isDeleteDeclaration() { return this; }
 755 #endif
 756 };
 757
 758 #endif /* DMD_DECLARATION_H */