gcc/d/dmd/declaration.h

   1
   2 /* Compiler implementation of the D programming language
   3  * Copyright (C) 1999-2021 by The D Language Foundation, All Rights Reserved
   4  * written by Walter Bright
   5  * http://www.digitalmars.com
   6  * Distributed under the Boost Software License, Version 1.0.
   7  * http://www.boost.org/LICENSE_1_0.txt
   8  * https://github.com/dlang/dmd/blob/master/src/dmd/declaration.h
   9  */
  10
  11 #pragma once
  12
  13 #include "dsymbol.h"
  14 #include "mtype.h"
  15 #include "objc.h"
  16 #include "tokens.h"
  17
  18 class Expression;
  19 class Statement;
  20 class LabelDsymbol;
  21 class Initializer;
  22 class ForeachStatement;
  23 struct Ensure
  24 {
  25     Identifier *id;
  26     Statement *ensure;
  27 };
  28 class FuncDeclaration;
  29 class StructDeclaration;
  30 struct IntRange;
  31
  32 //enum STC : ulong from astenums.d:
  33
  34     #define STCundefined          0ULL
  35
  36     #define STCstatic             1ULL    /// `static`
  37     #define STCextern             2ULL    /// `extern`
  38     #define STCconst              4ULL    /// `const`
  39     #define STCfinal              8ULL    /// `final`
  40
  41     #define STCabstract           0x10ULL    /// `abstract`
  42     #define STCparameter          0x20ULL    /// is function parameter
  43     #define STCfield              0x40ULL    /// is field of struct, union or class
  44     #define STCoverride           0x80ULL    /// `override`
  45
  46     #define STCauto               0x100ULL    /// `auto`
  47     #define STCsynchronized       0x200ULL    /// `synchronized`
  48     #define STCdeprecated         0x400ULL    /// `deprecated`
  49     #define STCin                 0x800ULL    /// `in` parameter
  50
  51     #define STCout                0x1000ULL    /// `out` parameter
  52     #define STClazy               0x2000ULL    /// `lazy` parameter
  53     #define STCforeach            0x4000ULL    /// variable for foreach loop
  54     #define STCvariadic           0x8000ULL    /// the `variadic` parameter in: T foo(T a, U b, V variadic...)
  55
  56     #define STCctorinit           0x10000ULL    /// can only be set inside constructor
  57     #define STCtemplateparameter  0x20000ULL    /// template parameter
  58     #define STCref                0x40000ULL    /// `ref`
  59     #define STCscope              0x80000ULL    /// `scope`
  60
  61     #define STCmaybescope         0x100000ULL    /// parameter might be `scope`
  62     #define STCscopeinferred      0x200000ULL    /// `scope` has been inferred and should not be part of mangling, `scope` must also be set
  63     #define STCreturn             0x400000ULL    /// 'return ref' or 'return scope' for function parameters
  64     #define STCreturnScope        0x800000ULL    /// if `ref return scope` then resolve to `ref` and `return scope`
  65
  66     #define STCreturninferred     0x1000000ULL    /// `return` has been inferred and should not be part of mangling, `return` must also be set
  67     #define STCimmutable          0x2000000ULL    /// `immutable`
  68     #define STCinit               0x4000000ULL    /// has explicit initializer
  69     #define STCmanifest           0x8000000ULL    /// manifest constant
  70
  71     #define STCnodtor             0x10000000ULL    /// do not run destructor
  72     #define STCnothrow            0x20000000ULL    /// `nothrow` meaning never throws exceptions
  73     #define STCpure               0x40000000ULL    /// `pure` function
  74     #define STCtls                0x80000000ULL    /// thread local
  75
  76     #define STCalias              0x100000000ULL    /// `alias` parameter
  77     #define STCshared             0x200000000ULL    /// accessible from multiple threads
  78     #define STCgshared            0x400000000ULL    /// accessible from multiple threads, but not typed as `shared`
  79     #define STCwild               0x800000000ULL    /// for wild type constructor
  80
  81     #define STCproperty           0x1000000000ULL    /// `@property`
  82     #define STCsafe               0x2000000000ULL    /// `@safe`
  83     #define STCtrusted            0x4000000000ULL    /// `@trusted`
  84     #define STCsystem             0x8000000000ULL    /// `@system`
  85
  86     #define STCctfe               0x10000000000ULL    /// can be used in CTFE, even if it is static
  87     #define STCdisable            0x20000000000ULL    /// for functions that are not callable
  88     #define STCresult             0x40000000000ULL    /// for result variables passed to out contracts
  89     #define STCnodefaultctor      0x80000000000ULL    /// must be set inside constructor
  90
  91     #define STCtemp               0x100000000000ULL    /// temporary variable
  92     #define STCrvalue             0x200000000000ULL    /// force rvalue for variables
  93     #define STCnogc               0x400000000000ULL    /// `@nogc`
  94     #define STCautoref            0x800000000000ULL    /// Mark for the already deduced `auto ref` parameter
  95
  96     #define STCinference          0x1000000000000ULL    /// do attribute inference
  97     #define STCexptemp            0x2000000000000ULL    /// temporary variable that has lifetime restricted to an expression
  98     #define STCfuture             0x4000000000000ULL    /// introducing new base class function
  99     #define STClocal              0x8000000000000ULL    /// do not forward (see dmd.dsymbol.ForwardingScopeDsymbol).
 100
 101     #define STClive               0x10000000000000ULL    /// function `@live` attribute
 102     #define STCregister           0x20000000000000ULL    /// `register` storage class (ImportC)
 103     #define STCvolatile           0x40000000000000ULL    /// destined for volatile in the back end
 104
 105 #define STC_TYPECTOR    (STCconst | STCimmutable | STCshared | STCwild)
 106 #define STC_FUNCATTR    (STCref | STCnothrow | STCnogc | STCpure | STCproperty | STCsafe | STCtrusted | STCsystem)
 107
 108 void ObjectNotFound(Identifier *id);
 109
 110 /**************************************************************/
 111
 112 class Declaration : public Dsymbol
 113 {
 114 public:
 115     Type *type;
 116     Type *originalType;         // before semantic analysis
 117     StorageClass storage_class;
 118     Visibility visibility;
 119     LINK linkage;
 120     short inuse;                // used to detect cycles
 121     uint8_t adFlags;
 122     DString mangleOverride;     // overridden symbol with pragma(mangle, "...")
 123
 124     const char *kind() const;
 125     d_uns64 size(const Loc &loc);
 126
 127     Dsymbol *search(const Loc &loc, Identifier *ident, int flags = SearchLocalsOnly);
 128
 129     bool isStatic() const { return (storage_class & STCstatic) != 0; }
 130     virtual bool isDelete();
 131     virtual bool isDataseg();
 132     virtual bool isThreadlocal();
 133     virtual bool isCodeseg() const;
 134     bool isCtorinit() const     { return (storage_class & STCctorinit) != 0; }
 135     bool isFinal() const        { return (storage_class & STCfinal) != 0; }
 136     virtual bool isAbstract()   { return (storage_class & STCabstract) != 0; }
 137     bool isConst() const        { return (storage_class & STCconst) != 0; }
 138     bool isImmutable() const    { return (storage_class & STCimmutable) != 0; }
 139     bool isWild() const         { return (storage_class & STCwild) != 0; }
 140     bool isAuto() const         { return (storage_class & STCauto) != 0; }
 141     bool isScope() const        { return (storage_class & STCscope) != 0; }
 142     bool isSynchronized() const { return (storage_class & STCsynchronized) != 0; }
 143     bool isParameter() const    { return (storage_class & STCparameter) != 0; }
 144     bool isDeprecated() const   { return (storage_class & STCdeprecated) != 0; }
 145     bool isOverride() const     { return (storage_class & STCoverride) != 0; }
 146     bool isResult() const       { return (storage_class & STCresult) != 0; }
 147     bool isField() const        { return (storage_class & STCfield) != 0; }
 148
 149     bool isIn()  const  { return (storage_class & STCin) != 0; }
 150     bool isOut() const  { return (storage_class & STCout) != 0; }
 151     bool isRef() const  { return (storage_class & STCref) != 0; }
 152     bool isReference() const { return (storage_class & (STCref | STCout)) != 0; }
 153
 154     bool isFuture() const { return (storage_class & STCfuture) != 0; }
 155
 156     Visibility visible();
 157
 158     Declaration *isDeclaration() { return this; }
 159     void accept(Visitor *v) { v->visit(this); }
 160 };
 161
 162 /**************************************************************/
 163
 164 class TupleDeclaration : public Declaration
 165 {
 166 public:
 167     Objects *objects;
 168     bool isexp;                 // true: expression tuple
 169
 170     TypeTuple *tupletype;       // !=NULL if this is a type tuple
 171
 172     TupleDeclaration *syntaxCopy(Dsymbol *);
 173     const char *kind() const;
 174     Type *getType();
 175     Dsymbol *toAlias2();
 176     bool needThis();
 177
 178     TupleDeclaration *isTupleDeclaration() { return this; }
 179     void accept(Visitor *v) { v->visit(this); }
 180 };
 181
 182 /**************************************************************/
 183
 184 class AliasDeclaration : public Declaration
 185 {
 186 public:
 187     Dsymbol *aliassym;
 188     Dsymbol *overnext;          // next in overload list
 189     Dsymbol *_import;           // !=NULL if unresolved internal alias for selective import
 190
 191     static AliasDeclaration *create(Loc loc, Identifier *id, Type *type);
 192     AliasDeclaration *syntaxCopy(Dsymbol *);
 193     bool overloadInsert(Dsymbol *s);
 194     const char *kind() const;
 195     Type *getType();
 196     Dsymbol *toAlias();
 197     Dsymbol *toAlias2();
 198     bool isOverloadable() const;
 199
 200     AliasDeclaration *isAliasDeclaration() { return this; }
 201     void accept(Visitor *v) { v->visit(this); }
 202 };
 203
 204 /**************************************************************/
 205
 206 class OverDeclaration : public Declaration
 207 {
 208 public:
 209     Dsymbol *overnext;          // next in overload list
 210     Dsymbol *aliassym;
 211
 212     const char *kind() const;
 213     bool equals(const RootObject *o) const;
 214     bool overloadInsert(Dsymbol *s);
 215
 216     Dsymbol *toAlias();
 217     Dsymbol *isUnique();
 218     bool isOverloadable() const;
 219
 220     OverDeclaration *isOverDeclaration() { return this; }
 221     void accept(Visitor *v) { v->visit(this); }
 222 };
 223
 224 /**************************************************************/
 225
 226 class VarDeclaration : public Declaration
 227 {
 228 public:
 229     Initializer *_init;
 230     FuncDeclarations nestedrefs; // referenced by these lexically nested functions
 231     Dsymbol *aliassym;          // if redone as alias to another symbol
 232     VarDeclaration *lastVar;    // Linked list of variables for goto-skips-init detection
 233     Expression *edtor;          // if !=NULL, does the destruction of the variable
 234     IntRange *range;            // if !NULL, the variable is known to be within the range
 235     VarDeclarations *maybes;    // STCmaybescope variables that are assigned to this STCmaybescope variable
 236
 237     unsigned endlinnum;         // line number of end of scope that this var lives in
 238     unsigned offset;
 239     unsigned sequenceNumber;     // order the variables are declared
 240     structalign_t alignment;
 241
 242     // When interpreting, these point to the value (NULL if value not determinable)
 243     // The index of this variable on the CTFE stack, ~0u if not allocated
 244     unsigned ctfeAdrOnStack;
 245
 246     bool isargptr;              // if parameter that _argptr points to
 247     bool ctorinit;              // it has been initialized in a ctor
 248     bool iscatchvar;            // this is the exception object variable in catch() clause
 249     bool isowner;               // this is an Owner, despite it being `scope`
 250     bool onstack;               // it is a class that was allocated on the stack
 251     bool mynew;                 // it is a class new'd with custom operator new
 252     char canassign;             // it can be assigned to
 253     bool overlapped;            // if it is a field and has overlapping
 254     bool overlapUnsafe;         // if it is an overlapping field and the overlaps are unsafe
 255     bool doNotInferScope;       // do not infer 'scope' for this variable
 256     bool doNotInferReturn;      // do not infer 'return' for this variable
 257     unsigned char isdataseg;    // private data for isDataseg
 258     bool isArgDtorVar;          // temporary created to handle scope destruction of a function argument
 259
 260 public:
 261     static VarDeclaration *create(const Loc &loc, Type *t, Identifier *id, Initializer *init, StorageClass storage_class = STCundefined);
 262     VarDeclaration *syntaxCopy(Dsymbol *);
 263     void setFieldOffset(AggregateDeclaration *ad, FieldState& fieldState, bool isunion);
 264     const char *kind() const;
 265     AggregateDeclaration *isThis();
 266     bool needThis();
 267     bool isExport() const;
 268     bool isImportedSymbol() const;
 269     bool isDataseg();
 270     bool isThreadlocal();
 271     bool isCTFE();
 272     bool isOverlappedWith(VarDeclaration *v);
 273     bool hasPointers();
 274     bool canTakeAddressOf();
 275     bool needsScopeDtor();
 276     bool enclosesLifetimeOf(VarDeclaration *v) const;
 277     void checkCtorConstInit();
 278     Dsymbol *toAlias();
 279     // Eliminate need for dynamic_cast
 280     VarDeclaration *isVarDeclaration() { return (VarDeclaration *)this; }
 281     void accept(Visitor *v) { v->visit(this); }
 282 };
 283
 284 /**************************************************************/
 285
 286 class BitFieldDeclaration : public VarDeclaration
 287 {
 288 public:
 289     Expression *width;
 290
 291     unsigned fieldWidth;
 292     unsigned bitOffset;
 293
 294     BitFieldDeclaration *syntaxCopy(Dsymbol*);
 295     BitFieldDeclaration *isBitFieldDeclaration() { return this; }
 296     void accept(Visitor *v) { v->visit(this); }
 297 };
 298
 299 /**************************************************************/
 300
 301 // This is a shell around a back end symbol
 302
 303 class SymbolDeclaration : public Declaration
 304 {
 305 public:
 306     StructDeclaration *dsym;
 307
 308     // Eliminate need for dynamic_cast
 309     SymbolDeclaration *isSymbolDeclaration() { return (SymbolDeclaration *)this; }
 310     void accept(Visitor *v) { v->visit(this); }
 311 };
 312
 313 class TypeInfoDeclaration : public VarDeclaration
 314 {
 315 public:
 316     Type *tinfo;
 317
 318     static TypeInfoDeclaration *create(Type *tinfo);
 319     TypeInfoDeclaration *syntaxCopy(Dsymbol *);
 320     const char *toChars() const;
 321
 322     TypeInfoDeclaration *isTypeInfoDeclaration() { return this; }
 323     void accept(Visitor *v) { v->visit(this); }
 324 };
 325
 326 class TypeInfoStructDeclaration : public TypeInfoDeclaration
 327 {
 328 public:
 329     static TypeInfoStructDeclaration *create(Type *tinfo);
 330
 331     void accept(Visitor *v) { v->visit(this); }
 332 };
 333
 334 class TypeInfoClassDeclaration : public TypeInfoDeclaration
 335 {
 336 public:
 337     static TypeInfoClassDeclaration *create(Type *tinfo);
 338
 339     void accept(Visitor *v) { v->visit(this); }
 340 };
 341
 342 class TypeInfoInterfaceDeclaration : public TypeInfoDeclaration
 343 {
 344 public:
 345     static TypeInfoInterfaceDeclaration *create(Type *tinfo);
 346
 347     void accept(Visitor *v) { v->visit(this); }
 348 };
 349
 350 class TypeInfoPointerDeclaration : public TypeInfoDeclaration
 351 {
 352 public:
 353     static TypeInfoPointerDeclaration *create(Type *tinfo);
 354
 355     void accept(Visitor *v) { v->visit(this); }
 356 };
 357
 358 class TypeInfoArrayDeclaration : public TypeInfoDeclaration
 359 {
 360 public:
 361     static TypeInfoArrayDeclaration *create(Type *tinfo);
 362
 363     void accept(Visitor *v) { v->visit(this); }
 364 };
 365
 366 class TypeInfoStaticArrayDeclaration : public TypeInfoDeclaration
 367 {
 368 public:
 369     static TypeInfoStaticArrayDeclaration *create(Type *tinfo);
 370
 371     void accept(Visitor *v) { v->visit(this); }
 372 };
 373
 374 class TypeInfoAssociativeArrayDeclaration : public TypeInfoDeclaration
 375 {
 376 public:
 377     static TypeInfoAssociativeArrayDeclaration *create(Type *tinfo);
 378
 379     void accept(Visitor *v) { v->visit(this); }
 380 };
 381
 382 class TypeInfoEnumDeclaration : public TypeInfoDeclaration
 383 {
 384 public:
 385     static TypeInfoEnumDeclaration *create(Type *tinfo);
 386
 387     void accept(Visitor *v) { v->visit(this); }
 388 };
 389
 390 class TypeInfoFunctionDeclaration : public TypeInfoDeclaration
 391 {
 392 public:
 393     static TypeInfoFunctionDeclaration *create(Type *tinfo);
 394
 395     void accept(Visitor *v) { v->visit(this); }
 396 };
 397
 398 class TypeInfoDelegateDeclaration : public TypeInfoDeclaration
 399 {
 400 public:
 401     static TypeInfoDelegateDeclaration *create(Type *tinfo);
 402
 403     void accept(Visitor *v) { v->visit(this); }
 404 };
 405
 406 class TypeInfoTupleDeclaration : public TypeInfoDeclaration
 407 {
 408 public:
 409     static TypeInfoTupleDeclaration *create(Type *tinfo);
 410
 411     void accept(Visitor *v) { v->visit(this); }
 412 };
 413
 414 class TypeInfoConstDeclaration : public TypeInfoDeclaration
 415 {
 416 public:
 417     static TypeInfoConstDeclaration *create(Type *tinfo);
 418
 419     void accept(Visitor *v) { v->visit(this); }
 420 };
 421
 422 class TypeInfoInvariantDeclaration : public TypeInfoDeclaration
 423 {
 424 public:
 425     static TypeInfoInvariantDeclaration *create(Type *tinfo);
 426
 427     void accept(Visitor *v) { v->visit(this); }
 428 };
 429
 430 class TypeInfoSharedDeclaration : public TypeInfoDeclaration
 431 {
 432 public:
 433     static TypeInfoSharedDeclaration *create(Type *tinfo);
 434
 435     void accept(Visitor *v) { v->visit(this); }
 436 };
 437
 438 class TypeInfoWildDeclaration : public TypeInfoDeclaration
 439 {
 440 public:
 441     static TypeInfoWildDeclaration *create(Type *tinfo);
 442
 443     void accept(Visitor *v) { v->visit(this); }
 444 };
 445
 446 class TypeInfoVectorDeclaration : public TypeInfoDeclaration
 447 {
 448 public:
 449     static TypeInfoVectorDeclaration *create(Type *tinfo);
 450
 451     void accept(Visitor *v) { v->visit(this); }
 452 };
 453
 454 /**************************************************************/
 455
 456 class ThisDeclaration : public VarDeclaration
 457 {
 458 public:
 459     ThisDeclaration *syntaxCopy(Dsymbol *);
 460     ThisDeclaration *isThisDeclaration() { return this; }
 461     void accept(Visitor *v) { v->visit(this); }
 462 };
 463
 464 enum class ILS : unsigned char
 465 {
 466     ILSuninitialized,   // not computed yet
 467     ILSno,              // cannot inline
 468     ILSyes              // can inline
 469 };
 470
 471 /**************************************************************/
 472
 473 enum class BUILTIN : unsigned char
 474 {
 475     unknown = 255,   /// not known if this is a builtin
 476     unimp = 0,       /// this is not a builtin
 477     gcc,             /// this is a GCC builtin
 478     llvm,            /// this is an LLVM builtin
 479     sin,
 480     cos,
 481     tan,
 482     sqrt,
 483     fabs,
 484     ldexp,
 485     log,
 486     log2,
 487     log10,
 488     exp,
 489     expm1,
 490     exp2,
 491     round,
 492     floor,
 493     ceil,
 494     trunc,
 495     copysign,
 496     pow,
 497     fmin,
 498     fmax,
 499     fma,
 500     isnan,
 501     isinfinity,
 502     isfinite,
 503     bsf,
 504     bsr,
 505     bswap,
 506     popcnt,
 507     yl2x,
 508     yl2xp1,
 509     toPrecFloat,
 510     toPrecDouble,
 511     toPrecReal
 512 };
 513
 514 Expression *eval_builtin(Loc loc, FuncDeclaration *fd, Expressions *arguments);
 515 BUILTIN isBuiltin(FuncDeclaration *fd);
 516
 517 class FuncDeclaration : public Declaration
 518 {
 519 public:
 520     Statements *frequires;              // in contracts
 521     Ensures *fensures;                  // out contracts
 522     Statement *frequire;                // lowered in contract
 523     Statement *fensure;                 // lowered out contract
 524     Statement *fbody;
 525
 526     FuncDeclarations foverrides;        // functions this function overrides
 527     FuncDeclaration *fdrequire;         // function that does the in contract
 528     FuncDeclaration *fdensure;          // function that does the out contract
 529
 530     Expressions *fdrequireParams;       // argument list for __require
 531     Expressions *fdensureParams;        // argument list for __ensure
 532
 533     const char *mangleString;           // mangled symbol created from mangleExact()
 534
 535     VarDeclaration *vresult;            // result variable for out contracts
 536     LabelDsymbol *returnLabel;          // where the return goes
 537
 538     // used to prevent symbols in different
 539     // scopes from having the same name
 540     DsymbolTable *localsymtab;
 541     VarDeclaration *vthis;              // 'this' parameter (member and nested)
 542     bool isThis2;                       // has a dual-context 'this' parameter
 543     VarDeclaration *v_arguments;        // '_arguments' parameter
 544
 545     VarDeclaration *v_argptr;           // '_argptr' variable
 546     VarDeclarations *parameters;        // Array of VarDeclaration's for parameters
 547     DsymbolTable *labtab;               // statement label symbol table
 548     Dsymbol *overnext;                  // next in overload list
 549     FuncDeclaration *overnext0;         // next in overload list (only used during IFTI)
 550     Loc endloc;                         // location of closing curly bracket
 551     int vtblIndex;                      // for member functions, index into vtbl[]
 552     bool naked;                         // true if naked
 553     bool generated;                     // true if function was generated by the compiler rather than
 554                                         // supplied by the user
 555     bool hasAlwaysInlines;              // contains references to functions that must be inlined
 556     unsigned char isCrtCtorDtor;        // has attribute pragma(crt_constructor(1)/crt_destructor(2))
 557                                         // not set before the glue layer
 558     ILS inlineStatusStmt;
 559     ILS inlineStatusExp;
 560     PINLINE inlining;
 561
 562     int inlineNest;                     // !=0 if nested inline
 563     bool eh_none;                       /// true if no exception unwinding is needed
 564
 565     // true if errors in semantic3 this function's frame ptr
 566     bool semantic3Errors;
 567     ForeachStatement *fes;              // if foreach body, this is the foreach
 568     BaseClass* interfaceVirtual;        // if virtual, but only appears in interface vtbl[]
 569     bool introducing;                   // true if 'introducing' function
 570     // if !=NULL, then this is the type
 571     // of the 'introducing' function
 572     // this one is overriding
 573     Type *tintro;
 574     bool inferRetType;                  // true if return type is to be inferred
 575     StorageClass storage_class2;        // storage class for template onemember's
 576
 577     // Things that should really go into Scope
 578
 579     // 1 if there's a return exp; statement
 580     // 2 if there's a throw statement
 581     // 4 if there's an assert(0)
 582     // 8 if there's inline asm
 583     // 16 if there are multiple return statements
 584     int hasReturnExp;
 585
 586     // Support for NRVO (named return value optimization)
 587     bool nrvo_can;                      // true means we can do it
 588     VarDeclaration *nrvo_var;           // variable to replace with shidden
 589     Symbol *shidden;                    // hidden pointer passed to function
 590
 591     ReturnStatements *returns;
 592
 593     GotoStatements *gotos;              // Gotos with forward references
 594
 595     // set if this is a known, builtin function we can evaluate at compile time
 596     BUILTIN builtin;
 597
 598     // set if someone took the address of this function
 599     int tookAddressOf;
 600     bool requiresClosure;               // this function needs a closure
 601
 602     // local variables in this function which are referenced by nested functions
 603     VarDeclarations closureVars;
 604
 605     /** Outer variables which are referenced by this nested function
 606      * (the inverse of closureVars)
 607      */
 608     VarDeclarations outerVars;
 609
 610     // Sibling nested functions which called this one
 611     FuncDeclarations siblingCallers;
 612
 613     FuncDeclarations *inlinedNestedCallees;
 614
 615     unsigned flags;                     // FUNCFLAGxxxxx
 616
 617     // Data for a function declaration that is needed for the Objective-C
 618     // integration.
 619     ObjcFuncDeclaration objc;
 620
 621     static FuncDeclaration *create(const Loc &loc, const Loc &endloc, Identifier *id, StorageClass storage_class, Type *type, bool noreturn = false);
 622     FuncDeclaration *syntaxCopy(Dsymbol *);
 623     bool functionSemantic();
 624     bool functionSemantic3();
 625     bool equals(const RootObject *o) const;
 626
 627     int overrides(FuncDeclaration *fd);
 628     int findVtblIndex(Dsymbols *vtbl, int dim);
 629     BaseClass *overrideInterface();
 630     bool overloadInsert(Dsymbol *s);
 631     bool inUnittest();
 632     MATCH leastAsSpecialized(FuncDeclaration *g);
 633     LabelDsymbol *searchLabel(Identifier *ident, const Loc &loc);
 634     int getLevel(FuncDeclaration *fd, int intypeof); // lexical nesting level difference
 635     int getLevelAndCheck(const Loc &loc, Scope *sc, FuncDeclaration *fd);
 636     const char *toPrettyChars(bool QualifyTypes = false);
 637     const char *toFullSignature();  // for diagnostics, e.g. 'int foo(int x, int y) pure'
 638     bool isMain() const;
 639     bool isCMain() const;
 640     bool isWinMain() const;
 641     bool isDllMain() const;
 642     bool isExport() const;
 643     bool isImportedSymbol() const;
 644     bool isCodeseg() const;
 645     bool isOverloadable() const;
 646     bool isAbstract();
 647     PURE isPure();
 648     PURE isPureBypassingInference();
 649     bool isSafe();
 650     bool isSafeBypassingInference();
 651     bool isTrusted();
 652
 653     bool isNogc();
 654     bool isNogcBypassingInference();
 655
 656     virtual bool isNested() const;
 657     AggregateDeclaration *isThis();
 658     bool needThis();
 659     bool isVirtualMethod();
 660     virtual bool isVirtual() const;
 661     bool isFinalFunc() const;
 662     virtual bool addPreInvariant();
 663     virtual bool addPostInvariant();
 664     const char *kind() const;
 665     bool isUnique();
 666     bool needsClosure();
 667     bool hasNestedFrameRefs();
 668     ParameterList getParameterList();
 669
 670     static FuncDeclaration *genCfunc(Parameters *args, Type *treturn, const char *name, StorageClass stc=0);
 671     static FuncDeclaration *genCfunc(Parameters *args, Type *treturn, Identifier *id, StorageClass stc=0);
 672
 673     bool checkNRVO();
 674
 675     FuncDeclaration *isFuncDeclaration() { return this; }
 676
 677     virtual FuncDeclaration *toAliasFunc() { return this; }
 678     void accept(Visitor *v) { v->visit(this); }
 679 };
 680
 681 class FuncAliasDeclaration : public FuncDeclaration
 682 {
 683 public:
 684     FuncDeclaration *funcalias;
 685     bool hasOverloads;
 686
 687     FuncAliasDeclaration *isFuncAliasDeclaration() { return this; }
 688     const char *kind() const;
 689
 690     FuncDeclaration *toAliasFunc();
 691     void accept(Visitor *v) { v->visit(this); }
 692 };
 693
 694 class FuncLiteralDeclaration : public FuncDeclaration
 695 {
 696 public:
 697     TOK tok;                       // TOKfunction or TOKdelegate
 698     Type *treq;                         // target of return type inference
 699
 700     // backend
 701     bool deferToObj;
 702
 703     FuncLiteralDeclaration *syntaxCopy(Dsymbol *);
 704     bool isNested() const;
 705     AggregateDeclaration *isThis();
 706     bool isVirtual() const;
 707     bool addPreInvariant();
 708     bool addPostInvariant();
 709
 710     void modifyReturns(Scope *sc, Type *tret);
 711
 712     FuncLiteralDeclaration *isFuncLiteralDeclaration() { return this; }
 713     const char *kind() const;
 714     const char *toPrettyChars(bool QualifyTypes = false);
 715     void accept(Visitor *v) { v->visit(this); }
 716 };
 717
 718 class CtorDeclaration : public FuncDeclaration
 719 {
 720 public:
 721     bool isCpCtor;
 722     CtorDeclaration *syntaxCopy(Dsymbol *);
 723     const char *kind() const;
 724     const char *toChars() const;
 725     bool isVirtual() const;
 726     bool addPreInvariant();
 727     bool addPostInvariant();
 728
 729     CtorDeclaration *isCtorDeclaration() { return this; }
 730     void accept(Visitor *v) { v->visit(this); }
 731 };
 732
 733 class PostBlitDeclaration : public FuncDeclaration
 734 {
 735 public:
 736     PostBlitDeclaration *syntaxCopy(Dsymbol *);
 737     bool isVirtual() const;
 738     bool addPreInvariant();
 739     bool addPostInvariant();
 740     bool overloadInsert(Dsymbol *s);
 741
 742     PostBlitDeclaration *isPostBlitDeclaration() { return this; }
 743     void accept(Visitor *v) { v->visit(this); }
 744 };
 745
 746 class DtorDeclaration : public FuncDeclaration
 747 {
 748 public:
 749     DtorDeclaration *syntaxCopy(Dsymbol *);
 750     const char *kind() const;
 751     const char *toChars() const;
 752     bool isVirtual() const;
 753     bool addPreInvariant();
 754     bool addPostInvariant();
 755     bool overloadInsert(Dsymbol *s);
 756
 757     DtorDeclaration *isDtorDeclaration() { return this; }
 758     void accept(Visitor *v) { v->visit(this); }
 759 };
 760
 761 class StaticCtorDeclaration : public FuncDeclaration
 762 {
 763 public:
 764     StaticCtorDeclaration *syntaxCopy(Dsymbol *);
 765     AggregateDeclaration *isThis();
 766     bool isVirtual() const;
 767     bool addPreInvariant();
 768     bool addPostInvariant();
 769     bool hasStaticCtorOrDtor();
 770
 771     StaticCtorDeclaration *isStaticCtorDeclaration() { return this; }
 772     void accept(Visitor *v) { v->visit(this); }
 773 };
 774
 775 class SharedStaticCtorDeclaration : public StaticCtorDeclaration
 776 {
 777 public:
 778     SharedStaticCtorDeclaration *syntaxCopy(Dsymbol *);
 779
 780     SharedStaticCtorDeclaration *isSharedStaticCtorDeclaration() { return this; }
 781     void accept(Visitor *v) { v->visit(this); }
 782 };
 783
 784 class StaticDtorDeclaration : public FuncDeclaration
 785 {
 786 public:
 787     VarDeclaration *vgate;      // 'gate' variable
 788
 789     StaticDtorDeclaration *syntaxCopy(Dsymbol *);
 790     AggregateDeclaration *isThis();
 791     bool isVirtual() const;
 792     bool hasStaticCtorOrDtor();
 793     bool addPreInvariant();
 794     bool addPostInvariant();
 795
 796     StaticDtorDeclaration *isStaticDtorDeclaration() { return this; }
 797     void accept(Visitor *v) { v->visit(this); }
 798 };
 799
 800 class SharedStaticDtorDeclaration : public StaticDtorDeclaration
 801 {
 802 public:
 803     SharedStaticDtorDeclaration *syntaxCopy(Dsymbol *);
 804
 805     SharedStaticDtorDeclaration *isSharedStaticDtorDeclaration() { return this; }
 806     void accept(Visitor *v) { v->visit(this); }
 807 };
 808
 809 class InvariantDeclaration : public FuncDeclaration
 810 {
 811 public:
 812     InvariantDeclaration *syntaxCopy(Dsymbol *);
 813     bool isVirtual() const;
 814     bool addPreInvariant();
 815     bool addPostInvariant();
 816
 817     InvariantDeclaration *isInvariantDeclaration() { return this; }
 818     void accept(Visitor *v) { v->visit(this); }
 819 };
 820
 821 class UnitTestDeclaration : public FuncDeclaration
 822 {
 823 public:
 824     char *codedoc; /** For documented unittest. */
 825
 826     // toObjFile() these nested functions after this one
 827     FuncDeclarations deferredNested;
 828
 829     UnitTestDeclaration *syntaxCopy(Dsymbol *);
 830     AggregateDeclaration *isThis();
 831     bool isVirtual() const;
 832     bool addPreInvariant();
 833     bool addPostInvariant();
 834
 835     UnitTestDeclaration *isUnitTestDeclaration() { return this; }
 836     void accept(Visitor *v) { v->visit(this); }
 837 };
 838
 839 class NewDeclaration : public FuncDeclaration
 840 {
 841 public:
 842     Parameters *parameters;
 843     VarArg varargs;
 844
 845     NewDeclaration *syntaxCopy(Dsymbol *);
 846     const char *kind() const;
 847     bool isVirtual() const;
 848     bool addPreInvariant();
 849     bool addPostInvariant();
 850
 851     NewDeclaration *isNewDeclaration() { return this; }
 852     void accept(Visitor *v) { v->visit(this); }
 853 };