gcc/d/dmd/mtype.h

   1
   2 /* Compiler implementation of the D programming language
   3  * Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved
   4  * written by Walter Bright
   5  * https://www.digitalmars.com
   6  * Distributed under the Boost Software License, Version 1.0.
   7  * https://www.boost.org/LICENSE_1_0.txt
   8  * https://github.com/dlang/dmd/blob/master/src/dmd/mtype.h
   9  */
  10
  11 #pragma once
  12
  13 #include "root/dcompat.h" // for d_size_t
  14
  15 #include "arraytypes.h"
  16 #include "ast_node.h"
  17 #include "globals.h"
  18 #include "visitor.h"
  19
  20 struct Scope;
  21 class AggregateDeclaration;
  22 class Identifier;
  23 class Expression;
  24 class StructDeclaration;
  25 class ClassDeclaration;
  26 class EnumDeclaration;
  27 class TypeInfoDeclaration;
  28 class Dsymbol;
  29 class TemplateInstance;
  30 class TemplateDeclaration;
  31
  32 class TypeBasic;
  33 class Parameter;
  34
  35 // Back end
  36 #ifdef IN_GCC
  37 typedef union tree_node type;
  38 #else
  39 typedef struct TYPE type;
  40 #endif
  41
  42 extern const char* toChars(const Type* const t);
  43 Type *typeSemantic(Type *t, const Loc &loc, Scope *sc);
  44 Type *merge(Type *type);
  45
  46 enum class TY : uint8_t
  47 {
  48     Tarray,             // slice array, aka T[]
  49     Tsarray,            // static array, aka T[dimension]
  50     Taarray,            // associative array, aka T[type]
  51     Tpointer,
  52     Treference,
  53     Tfunction,
  54     Tident,
  55     Tclass,
  56     Tstruct,
  57     Tenum,
  58
  59     Tdelegate,
  60     Tnone,
  61     Tvoid,
  62     Tint8,
  63     Tuns8,
  64     Tint16,
  65     Tuns16,
  66     Tint32,
  67     Tuns32,
  68     Tint64,
  69
  70     Tuns64,
  71     Tfloat32,
  72     Tfloat64,
  73     Tfloat80,
  74     Timaginary32,
  75     Timaginary64,
  76     Timaginary80,
  77     Tcomplex32,
  78     Tcomplex64,
  79     Tcomplex80,
  80
  81     Tbool,
  82     Tchar,
  83     Twchar,
  84     Tdchar,
  85     Terror,
  86     Tinstance,
  87     Ttypeof,
  88     Ttuple,
  89     Tslice,
  90     Treturn,
  91
  92     Tnull,
  93     Tvector,
  94     Tint128,
  95     Tuns128,
  96     Ttraits,
  97     Tmixin,
  98     Tnoreturn,
  99     TMAX
 100 };
 101
 102 #define SIZE_INVALID (~(uinteger_t)0)   // error return from size() functions
 103
 104
 105 /**
 106  * type modifiers
 107  * pick this order of numbers so switch statements work better
 108  */
 109 enum MODFlags
 110 {
 111     MODnone      = 0, // default (mutable)
 112     MODconst     = 1, // type is const
 113     MODimmutable = 4, // type is immutable
 114     MODshared    = 2, // type is shared
 115     MODwild      = 8, // type is wild
 116     MODwildconst = (MODwild | MODconst), // type is wild const
 117     MODmutable   = 0x10       // type is mutable (only used in wildcard matching)
 118 };
 119 typedef unsigned char MOD;
 120
 121 enum VarArgValues
 122 {
 123     VARARGnone     = 0,  /// fixed number of arguments
 124     VARARGvariadic = 1,  /// T t, ...)  can be C-style (core.stdc.stdarg) or D-style (core.vararg)
 125     VARARGtypesafe = 2,  /// T t ...) typesafe https://dlang.org/spec/function.html#typesafe_variadic_functions
 126                          ///   or https://dlang.org/spec/function.html#typesafe_variadic_functions
 127     VARARGKRvariadic = 3 /// K+R C style variadics (no function prototype)
 128 };
 129 typedef unsigned char VarArg;
 130
 131 enum class Covariant
 132 {
 133     distinct = 0, /// types are distinct
 134     yes = 1,      /// types are covariant
 135     no = 2,       /// arguments match as far as overloading goes, but types are not covariant
 136     fwdref = 3,   /// cannot determine covariance because of forward references
 137 };
 138
 139 class Type : public ASTNode
 140 {
 141 public:
 142     TY ty;
 143     MOD mod;  // modifiers MODxxxx
 144     char *deco;
 145
 146 private:
 147     void* mcache;
 148
 149 public:
 150     Type *pto;          // merged pointer to this type
 151     Type *rto;          // reference to this type
 152     Type *arrayof;      // array of this type
 153     TypeInfoDeclaration *vtinfo;        // TypeInfo object for this Type
 154
 155     type *ctype;        // for back end
 156
 157     static Type *tvoid;
 158     static Type *tint8;
 159     static Type *tuns8;
 160     static Type *tint16;
 161     static Type *tuns16;
 162     static Type *tint32;
 163     static Type *tuns32;
 164     static Type *tint64;
 165     static Type *tuns64;
 166     static Type *tint128;
 167     static Type *tuns128;
 168     static Type *tfloat32;
 169     static Type *tfloat64;
 170     static Type *tfloat80;
 171
 172     static Type *timaginary32;
 173     static Type *timaginary64;
 174     static Type *timaginary80;
 175
 176     static Type *tcomplex32;
 177     static Type *tcomplex64;
 178     static Type *tcomplex80;
 179
 180     static Type *tbool;
 181     static Type *tchar;
 182     static Type *twchar;
 183     static Type *tdchar;
 184
 185     // Some special types
 186     static Type *tshiftcnt;
 187     static Type *tvoidptr;              // void*
 188     static Type *tstring;               // immutable(char)[]
 189     static Type *twstring;              // immutable(wchar)[]
 190     static Type *tdstring;              // immutable(dchar)[]
 191     static Type *terror;                // for error recovery
 192     static Type *tnull;                 // for null type
 193     static Type *tnoreturn;             // for bottom type typeof(*null)
 194
 195     static Type *tsize_t;               // matches size_t alias
 196     static Type *tptrdiff_t;            // matches ptrdiff_t alias
 197     static Type *thash_t;               // matches hash_t alias
 198
 199     static ClassDeclaration *dtypeinfo;
 200     static ClassDeclaration *typeinfoclass;
 201     static ClassDeclaration *typeinfointerface;
 202     static ClassDeclaration *typeinfostruct;
 203     static ClassDeclaration *typeinfopointer;
 204     static ClassDeclaration *typeinfoarray;
 205     static ClassDeclaration *typeinfostaticarray;
 206     static ClassDeclaration *typeinfoassociativearray;
 207     static ClassDeclaration *typeinfovector;
 208     static ClassDeclaration *typeinfoenum;
 209     static ClassDeclaration *typeinfofunction;
 210     static ClassDeclaration *typeinfodelegate;
 211     static ClassDeclaration *typeinfotypelist;
 212     static ClassDeclaration *typeinfoconst;
 213     static ClassDeclaration *typeinfoinvariant;
 214     static ClassDeclaration *typeinfoshared;
 215     static ClassDeclaration *typeinfowild;
 216
 217     static TemplateDeclaration *rtinfo;
 218
 219     static Type *basic[(int)TY::TMAX];
 220
 221     virtual const char *kind();
 222     Type *copy() const;
 223     virtual Type *syntaxCopy();
 224     bool equals(const RootObject * const o) const override;
 225     bool equivalent(Type *t);
 226     // kludge for template.isType()
 227     DYNCAST dyncast() const override final { return DYNCAST_TYPE; }
 228     size_t getUniqueID() const;
 229     const char *toChars() const override;
 230     char *toPrettyChars(bool QualifyTypes = false);
 231     static void _init();
 232
 233     uinteger_t size();
 234     virtual uinteger_t size(const Loc &loc);
 235     virtual unsigned alignsize();
 236     Type *trySemantic(const Loc &loc, Scope *sc);
 237     Type *merge2();
 238     void modToBuffer(OutBuffer& buf) const;
 239     char *modToChars() const;
 240
 241     virtual bool isintegral();
 242     virtual bool isfloating();   // real, imaginary, or complex
 243     virtual bool isreal();
 244     virtual bool isimaginary();
 245     virtual bool iscomplex();
 246     virtual bool isscalar();
 247     virtual bool isunsigned();
 248     virtual bool isscope();
 249     virtual bool isString();
 250     virtual bool isAssignable();
 251     virtual bool isBoolean();
 252     bool isConst() const       { return (mod & MODconst) != 0; }
 253     bool isImmutable() const   { return (mod & MODimmutable) != 0; }
 254     bool isMutable() const     { return (mod & (MODconst | MODimmutable | MODwild)) == 0; }
 255     bool isShared() const      { return (mod & MODshared) != 0; }
 256     bool isSharedConst() const { return (mod & (MODshared | MODconst)) == (MODshared | MODconst); }
 257     bool isWild() const        { return (mod & MODwild) != 0; }
 258     bool isWildConst() const   { return (mod & MODwildconst) == MODwildconst; }
 259     bool isSharedWild() const  { return (mod & (MODshared | MODwild)) == (MODshared | MODwild); }
 260     bool isNaked() const       { return mod == 0; }
 261     Type *nullAttributes() const;
 262     Type *constOf();
 263     Type *immutableOf();
 264     Type *mutableOf();
 265     Type *sharedOf();
 266     Type *sharedConstOf();
 267     Type *unSharedOf();
 268     Type *wildOf();
 269     Type *wildConstOf();
 270     Type *sharedWildOf();
 271     Type *sharedWildConstOf();
 272     Type *castMod(MOD mod);
 273     Type *addMod(MOD mod);
 274     virtual Type *addStorageClass(StorageClass stc);
 275     Type *pointerTo();
 276     Type *referenceTo();
 277     Type *arrayOf();
 278     Type *sarrayOf(dinteger_t dim);
 279     bool hasDeprecatedAliasThis();
 280     Type *aliasthisOf();
 281     virtual Type *makeConst();
 282     virtual Type *makeImmutable();
 283     virtual Type *makeShared();
 284     virtual Type *makeSharedConst();
 285     virtual Type *makeWild();
 286     virtual Type *makeWildConst();
 287     virtual Type *makeSharedWild();
 288     virtual Type *makeSharedWildConst();
 289     virtual Type *makeMutable();
 290     virtual Dsymbol *toDsymbol(Scope *sc);
 291     Type *toBasetype();
 292     virtual bool isBaseOf(Type *t, int *poffset);
 293     virtual MATCH implicitConvTo(Type *to);
 294     virtual MATCH constConv(Type *to);
 295     virtual unsigned char deduceWild(Type *t, bool isRef);
 296     virtual Type *substWildTo(unsigned mod);
 297
 298     Type *unqualify(unsigned m);
 299
 300     virtual Type *toHeadMutable();
 301     virtual ClassDeclaration *isClassHandle();
 302     virtual structalign_t alignment();
 303     virtual Expression *defaultInitLiteral(const Loc &loc);
 304     virtual bool isZeroInit(const Loc &loc = Loc()); // if initializer is 0
 305     Identifier *getTypeInfoIdent();
 306     virtual int hasWild() const;
 307     virtual bool hasPointers();
 308     virtual bool hasVoidInitPointers();
 309     virtual bool hasSystemFields();
 310     virtual bool hasInvariant();
 311     virtual Type *nextOf();
 312     Type *baseElemOf();
 313     virtual bool needsDestruction();
 314     virtual bool needsCopyOrPostblit();
 315     virtual bool needsNested();
 316
 317     TypeFunction *toTypeFunction();
 318
 319     // For eliminating dynamic_cast
 320     virtual TypeBasic *isTypeBasic();
 321     TypeFunction *isPtrToFunction();
 322     TypeFunction *isFunction_Delegate_PtrToFunction();
 323     TypeError *isTypeError();
 324     TypeVector *isTypeVector();
 325     TypeSArray *isTypeSArray();
 326     TypeDArray *isTypeDArray();
 327     TypeAArray *isTypeAArray();
 328     TypePointer *isTypePointer();
 329     TypeReference *isTypeReference();
 330     TypeFunction *isTypeFunction();
 331     TypeDelegate *isTypeDelegate();
 332     TypeIdentifier *isTypeIdentifier();
 333     TypeInstance *isTypeInstance();
 334     TypeTypeof *isTypeTypeof();
 335     TypeReturn *isTypeReturn();
 336     TypeStruct *isTypeStruct();
 337     TypeEnum *isTypeEnum();
 338     TypeClass *isTypeClass();
 339     TypeTuple *isTypeTuple();
 340     TypeSlice *isTypeSlice();
 341     TypeNull *isTypeNull();
 342     TypeMixin *isTypeMixin();
 343     TypeTraits *isTypeTraits();
 344     TypeNoreturn *isTypeNoreturn();
 345     TypeTag *isTypeTag();
 346
 347     void accept(Visitor *v) override { v->visit(this); }
 348 };
 349
 350 class TypeError final : public Type
 351 {
 352 public:
 353     const char *kind() override;
 354     TypeError *syntaxCopy() override;
 355
 356     uinteger_t size(const Loc &loc) override;
 357     Expression *defaultInitLiteral(const Loc &loc) override;
 358     void accept(Visitor *v) override { v->visit(this); }
 359 };
 360
 361 class TypeNext : public Type
 362 {
 363 public:
 364     Type *next;
 365
 366     int hasWild() const override final;
 367     Type *nextOf() override final;
 368     Type *makeConst() override final;
 369     Type *makeImmutable() override final;
 370     Type *makeShared() override final;
 371     Type *makeSharedConst() override final;
 372     Type *makeWild() override final;
 373     Type *makeWildConst() override final;
 374     Type *makeSharedWild() override final;
 375     Type *makeSharedWildConst() override final;
 376     Type *makeMutable() override final;
 377     MATCH constConv(Type *to) override;
 378     unsigned char deduceWild(Type *t, bool isRef) override final;
 379     void transitive();
 380     void accept(Visitor *v) override { v->visit(this); }
 381 };
 382
 383 class TypeBasic final : public Type
 384 {
 385 public:
 386     const char *dstring;
 387     unsigned flags;
 388
 389     const char *kind() override;
 390     TypeBasic *syntaxCopy() override;
 391     uinteger_t size(const Loc &loc) override;
 392     unsigned alignsize() override;
 393     bool isintegral() override;
 394     bool isfloating() override;
 395     bool isreal() override;
 396     bool isimaginary() override;
 397     bool iscomplex() override;
 398     bool isscalar() override;
 399     bool isunsigned() override;
 400     MATCH implicitConvTo(Type *to) override;
 401     bool isZeroInit(const Loc &loc) override;
 402
 403     // For eliminating dynamic_cast
 404     TypeBasic *isTypeBasic() override;
 405     void accept(Visitor *v) override { v->visit(this); }
 406 };
 407
 408 class TypeVector final : public Type
 409 {
 410 public:
 411     Type *basetype;
 412
 413     static TypeVector *create(Type *basetype);
 414     const char *kind() override;
 415     TypeVector *syntaxCopy() override;
 416     uinteger_t size(const Loc &loc) override;
 417     unsigned alignsize() override;
 418     bool isintegral() override;
 419     bool isfloating() override;
 420     bool isscalar() override;
 421     bool isunsigned() override;
 422     bool isBoolean() override;
 423     MATCH implicitConvTo(Type *to) override;
 424     Expression *defaultInitLiteral(const Loc &loc) override;
 425     TypeBasic *elementType();
 426     bool isZeroInit(const Loc &loc) override;
 427
 428     void accept(Visitor *v) override { v->visit(this); }
 429 };
 430
 431 class TypeArray : public TypeNext
 432 {
 433 public:
 434     void accept(Visitor *v) override { v->visit(this); }
 435 };
 436
 437 // Static array, one with a fixed dimension
 438 class TypeSArray final : public TypeArray
 439 {
 440 public:
 441     Expression *dim;
 442
 443     const char *kind() override;
 444     TypeSArray *syntaxCopy() override;
 445     bool isIncomplete();
 446     uinteger_t size(const Loc &loc) override;
 447     unsigned alignsize() override;
 448     bool isString() override;
 449     bool isZeroInit(const Loc &loc) override;
 450     structalign_t alignment() override;
 451     MATCH constConv(Type *to) override;
 452     MATCH implicitConvTo(Type *to) override;
 453     Expression *defaultInitLiteral(const Loc &loc) override;
 454     bool hasPointers() override;
 455     bool hasSystemFields() override;
 456     bool hasVoidInitPointers() override;
 457     bool hasInvariant() override;
 458     bool needsDestruction() override;
 459     bool needsCopyOrPostblit() override;
 460     bool needsNested() override;
 461
 462     void accept(Visitor *v) override { v->visit(this); }
 463 };
 464
 465 // Dynamic array, no dimension
 466 class TypeDArray final : public TypeArray
 467 {
 468 public:
 469     const char *kind() override;
 470     TypeDArray *syntaxCopy() override;
 471     uinteger_t size(const Loc &loc) override;
 472     unsigned alignsize() override;
 473     bool isString() override;
 474     bool isZeroInit(const Loc &loc) override;
 475     bool isBoolean() override;
 476     MATCH implicitConvTo(Type *to) override;
 477     bool hasPointers() override;
 478
 479     void accept(Visitor *v) override { v->visit(this); }
 480 };
 481
 482 class TypeAArray final : public TypeArray
 483 {
 484 public:
 485     Type *index;                // key type
 486     Loc loc;
 487
 488     static TypeAArray *create(Type *t, Type *index);
 489     const char *kind() override;
 490     TypeAArray *syntaxCopy() override;
 491     uinteger_t size(const Loc &loc) override;
 492     bool isZeroInit(const Loc &loc) override;
 493     bool isBoolean() override;
 494     bool hasPointers() override;
 495     MATCH implicitConvTo(Type *to) override;
 496     MATCH constConv(Type *to) override;
 497
 498     void accept(Visitor *v) override { v->visit(this); }
 499 };
 500
 501 class TypePointer final : public TypeNext
 502 {
 503 public:
 504     static TypePointer *create(Type *t);
 505     const char *kind() override;
 506     TypePointer *syntaxCopy() override;
 507     uinteger_t size(const Loc &loc) override;
 508     MATCH implicitConvTo(Type *to) override;
 509     MATCH constConv(Type *to) override;
 510     bool isscalar() override;
 511     bool isZeroInit(const Loc &loc) override;
 512     bool hasPointers() override;
 513
 514     void accept(Visitor *v) override { v->visit(this); }
 515 };
 516
 517 class TypeReference final : public TypeNext
 518 {
 519 public:
 520     const char *kind() override;
 521     TypeReference *syntaxCopy() override;
 522     uinteger_t size(const Loc &loc) override;
 523     bool isZeroInit(const Loc &loc) override;
 524     void accept(Visitor *v) override { v->visit(this); }
 525 };
 526
 527 enum RET
 528 {
 529     RETregs     = 1,    // returned in registers
 530     RETstack    = 2     // returned on stack
 531 };
 532
 533 enum class TRUST : unsigned char
 534 {
 535     default_ = 0,
 536     system = 1,    // @system (same as TRUSTdefault)
 537     trusted = 2,   // @trusted
 538     safe = 3       // @safe
 539 };
 540
 541 enum TRUSTformat
 542 {
 543     TRUSTformatDefault,  // do not emit @system when trust == TRUSTdefault
 544     TRUSTformatSystem    // emit @system when trust == TRUSTdefault
 545 };
 546
 547 enum class PURE : unsigned char
 548 {
 549     impure = 0,     // not pure at all
 550     fwdref = 1,     // it's pure, but not known which level yet
 551     weak = 2,       // no mutable globals are read or written
 552     const_ = 3,     // parameters are values or const
 553 };
 554
 555 class Parameter final : public ASTNode
 556 {
 557 public:
 558     Loc loc;
 559     StorageClass storageClass;
 560     Type *type;
 561     Identifier *ident;
 562     Expression *defaultArg;
 563     UserAttributeDeclaration *userAttribDecl;   // user defined attributes
 564
 565     static Parameter *create(const Loc &loc, StorageClass storageClass, Type *type, Identifier *ident,
 566                              Expression *defaultArg, UserAttributeDeclaration *userAttribDecl);
 567     Parameter *syntaxCopy();
 568     Type *isLazyArray();
 569     bool isLazy() const;
 570     bool isReference() const;
 571     // kludge for template.isType()
 572     DYNCAST dyncast() const override { return DYNCAST_PARAMETER; }
 573     void accept(Visitor *v) override { v->visit(this); }
 574
 575     static size_t dim(Parameters *parameters);
 576     static Parameter *getNth(Parameters *parameters, d_size_t nth);
 577     const char *toChars() const override;
 578     bool isCovariant(bool returnByRef, const Parameter *p, bool previewIn) const;
 579 };
 580
 581 struct ParameterList
 582 {
 583     Parameters* parameters;
 584     StorageClass stc;
 585     VarArg varargs;
 586     d_bool hasIdentifierList; // true if C identifier-list style
 587
 588     size_t length();
 589     Parameter *operator[](size_t i) { return Parameter::getNth(parameters, i); }
 590 };
 591
 592 class TypeFunction final : public TypeNext
 593 {
 594 public:
 595     // .next is the return type
 596
 597     ParameterList parameterList; // function parameters
 598     uint16_t bitFields;
 599     LINK linkage;                // calling convention
 600     TRUST trust;                 // level of trust
 601     PURE purity;                 // PURExxxx
 602     char inuse;
 603     Expressions *fargs;          // function arguments
 604
 605     static TypeFunction *create(Parameters *parameters, Type *treturn, VarArg varargs, LINK linkage, StorageClass stc = 0);
 606     const char *kind() override;
 607     TypeFunction *syntaxCopy() override;
 608     void purityLevel();
 609     bool hasLazyParameters();
 610     bool isDstyleVariadic() const;
 611     StorageClass parameterStorageClass(Type* tthis, Parameter *p, VarDeclarations* outerVars = nullptr, bool indirect = false);
 612     Type *addStorageClass(StorageClass stc) override;
 613
 614     Type *substWildTo(unsigned mod) override;
 615     MATCH constConv(Type *to) override;
 616
 617     bool isnothrow() const;
 618     void isnothrow(bool v);
 619     bool isnogc() const;
 620     void isnogc(bool v);
 621     bool isproperty() const;
 622     void isproperty(bool v);
 623     bool isref() const;
 624     void isref(bool v);
 625     bool isreturn() const;
 626     void isreturn(bool v);
 627     bool isreturnscope() const;
 628     void isreturnscope(bool v);
 629     bool isScopeQual() const;
 630     void isScopeQual(bool v);
 631     bool isreturninferred() const;
 632     void isreturninferred(bool v);
 633     bool isscopeinferred() const;
 634     void isscopeinferred(bool v);
 635     bool islive() const;
 636     void islive(bool v);
 637     bool incomplete() const;
 638     void incomplete(bool v);
 639     bool isInOutParam() const;
 640     void isInOutParam(bool v);
 641     bool isInOutQual() const;
 642     void isInOutQual(bool v);
 643     bool iswild() const;
 644
 645     void accept(Visitor *v) override { v->visit(this); }
 646 };
 647
 648 class TypeDelegate final : public TypeNext
 649 {
 650 public:
 651     // .next is a TypeFunction
 652
 653     static TypeDelegate *create(TypeFunction *t);
 654     const char *kind() override;
 655     TypeDelegate *syntaxCopy() override;
 656     Type *addStorageClass(StorageClass stc) override;
 657     uinteger_t size(const Loc &loc) override;
 658     unsigned alignsize() override;
 659     MATCH implicitConvTo(Type *to) override;
 660     bool isZeroInit(const Loc &loc) override;
 661     bool isBoolean() override;
 662     bool hasPointers() override;
 663
 664     void accept(Visitor *v) override { v->visit(this); }
 665 };
 666
 667 class TypeTraits final : public Type
 668 {
 669     Loc loc;
 670     /// The expression to resolve as type or symbol.
 671     TraitsExp *exp;
 672     /// Cached type/symbol after semantic analysis.
 673     RootObject *obj;
 674
 675     const char *kind() override;
 676     TypeTraits *syntaxCopy() override;
 677     uinteger_t size(const Loc &loc) override;
 678     Dsymbol *toDsymbol(Scope *sc) override;
 679     void accept(Visitor *v) override { v->visit(this); }
 680 };
 681
 682 class TypeMixin final : public Type
 683 {
 684     Loc loc;
 685     Expressions *exps;
 686     RootObject *obj;
 687
 688     const char *kind() override;
 689     TypeMixin *syntaxCopy() override;
 690     Dsymbol *toDsymbol(Scope *sc) override;
 691     void accept(Visitor *v) override { v->visit(this); }
 692 };
 693
 694 class TypeQualified : public Type
 695 {
 696 public:
 697     Loc loc;
 698     // array of Identifier and TypeInstance,
 699     // representing ident.ident!tiargs.ident. ... etc.
 700     Objects idents;
 701
 702     uinteger_t size(const Loc &loc) override;
 703
 704     void accept(Visitor *v) override { v->visit(this); }
 705 };
 706
 707 class TypeIdentifier final : public TypeQualified
 708 {
 709 public:
 710     Identifier *ident;
 711     Dsymbol *originalSymbol; // The symbol representing this identifier, before alias resolution
 712
 713     static TypeIdentifier *create(const Loc &loc, Identifier *ident);
 714     const char *kind() override;
 715     TypeIdentifier *syntaxCopy() override;
 716     Dsymbol *toDsymbol(Scope *sc) override;
 717     void accept(Visitor *v) override { v->visit(this); }
 718 };
 719
 720 /* Similar to TypeIdentifier, but with a TemplateInstance as the root
 721  */
 722 class TypeInstance final : public TypeQualified
 723 {
 724 public:
 725     TemplateInstance *tempinst;
 726
 727     const char *kind() override;
 728     TypeInstance *syntaxCopy() override;
 729     Dsymbol *toDsymbol(Scope *sc) override;
 730     void accept(Visitor *v) override { v->visit(this); }
 731 };
 732
 733 class TypeTypeof final : public TypeQualified
 734 {
 735 public:
 736     Expression *exp;
 737     int inuse;
 738
 739     const char *kind() override;
 740     TypeTypeof *syntaxCopy() override;
 741     Dsymbol *toDsymbol(Scope *sc) override;
 742     uinteger_t size(const Loc &loc) override;
 743     void accept(Visitor *v) override { v->visit(this); }
 744 };
 745
 746 class TypeReturn final : public TypeQualified
 747 {
 748 public:
 749     const char *kind() override;
 750     TypeReturn *syntaxCopy() override;
 751     Dsymbol *toDsymbol(Scope *sc) override;
 752     void accept(Visitor *v) override { v->visit(this); }
 753 };
 754
 755 // Whether alias this dependency is recursive or not.
 756 enum AliasThisRec
 757 {
 758     RECno = 0,      // no alias this recursion
 759     RECyes = 1,     // alias this has recursive dependency
 760     RECfwdref = 2,  // not yet known
 761     RECtypeMask = 3,// mask to read no/yes/fwdref
 762
 763     RECtracing = 0x4, // mark in progress of implicitConvTo/deduceWild
 764     RECtracingDT = 0x8  // mark in progress of deduceType
 765 };
 766
 767 class TypeStruct final : public Type
 768 {
 769 public:
 770     StructDeclaration *sym;
 771     AliasThisRec att;
 772     d_bool inuse;
 773
 774     static TypeStruct *create(StructDeclaration *sym);
 775     const char *kind() override;
 776     uinteger_t size(const Loc &loc) override;
 777     unsigned alignsize() override;
 778     TypeStruct *syntaxCopy() override;
 779     Dsymbol *toDsymbol(Scope *sc) override;
 780     structalign_t alignment() override;
 781     Expression *defaultInitLiteral(const Loc &loc) override;
 782     bool isZeroInit(const Loc &loc) override;
 783     bool isAssignable() override;
 784     bool isBoolean() override;
 785     bool needsDestruction() override;
 786     bool needsCopyOrPostblit() override;
 787     bool needsNested() override;
 788     bool hasPointers() override;
 789     bool hasVoidInitPointers() override;
 790     bool hasSystemFields() override;
 791     bool hasInvariant() override;
 792     MATCH implicitConvTo(Type *to) override;
 793     MATCH constConv(Type *to) override;
 794     unsigned char deduceWild(Type *t, bool isRef) override;
 795     Type *toHeadMutable() override;
 796
 797     void accept(Visitor *v) override { v->visit(this); }
 798 };
 799
 800 class TypeEnum final : public Type
 801 {
 802 public:
 803     EnumDeclaration *sym;
 804
 805     const char *kind() override;
 806     TypeEnum *syntaxCopy() override;
 807     uinteger_t size(const Loc &loc) override;
 808     unsigned alignsize() override;
 809     Type *memType(const Loc &loc = Loc());
 810     Dsymbol *toDsymbol(Scope *sc) override;
 811     bool isintegral() override;
 812     bool isfloating() override;
 813     bool isreal() override;
 814     bool isimaginary() override;
 815     bool iscomplex() override;
 816     bool isscalar() override;
 817     bool isunsigned() override;
 818     bool isBoolean() override;
 819     bool isString() override;
 820     bool isAssignable() override;
 821     bool needsDestruction() override;
 822     bool needsCopyOrPostblit() override;
 823     bool needsNested() override;
 824     MATCH implicitConvTo(Type *to) override;
 825     MATCH constConv(Type *to) override;
 826     bool isZeroInit(const Loc &loc) override;
 827     bool hasPointers() override;
 828     bool hasVoidInitPointers() override;
 829     bool hasSystemFields() override;
 830     bool hasInvariant() override;
 831     Type *nextOf() override;
 832
 833     void accept(Visitor *v) override { v->visit(this); }
 834 };
 835
 836 class TypeClass final : public Type
 837 {
 838 public:
 839     ClassDeclaration *sym;
 840     AliasThisRec att;
 841     CPPMANGLE cppmangle;
 842
 843     const char *kind() override;
 844     uinteger_t size(const Loc &loc) override;
 845     TypeClass *syntaxCopy() override;
 846     Dsymbol *toDsymbol(Scope *sc) override;
 847     ClassDeclaration *isClassHandle() override;
 848     bool isBaseOf(Type *t, int *poffset) override;
 849     MATCH implicitConvTo(Type *to) override;
 850     MATCH constConv(Type *to) override;
 851     unsigned char deduceWild(Type *t, bool isRef) override;
 852     Type *toHeadMutable() override;
 853     bool isZeroInit(const Loc &loc) override;
 854     bool isscope() override;
 855     bool isBoolean() override;
 856     bool hasPointers() override;
 857
 858     void accept(Visitor *v) override { v->visit(this); }
 859 };
 860
 861 class TypeTuple final : public Type
 862 {
 863 public:
 864     // 'logically immutable' cached global - don't modify (neither pointer nor pointee)!
 865     static TypeTuple *empty;
 866
 867     Parameters *arguments;      // types making up the tuple
 868
 869     static TypeTuple *create(Parameters *arguments);
 870     static TypeTuple *create();
 871     static TypeTuple *create(Type *t1);
 872     static TypeTuple *create(Type *t1, Type *t2);
 873     const char *kind() override;
 874     TypeTuple *syntaxCopy() override;
 875     bool equals(const RootObject * const o) const override;
 876     void accept(Visitor *v) override { v->visit(this); }
 877 };
 878
 879 class TypeSlice final : public TypeNext
 880 {
 881 public:
 882     Expression *lwr;
 883     Expression *upr;
 884
 885     const char *kind() override;
 886     TypeSlice *syntaxCopy() override;
 887     void accept(Visitor *v) override { v->visit(this); }
 888 };
 889
 890 class TypeNull final : public Type
 891 {
 892 public:
 893     const char *kind() override;
 894
 895     TypeNull *syntaxCopy() override;
 896     MATCH implicitConvTo(Type *to) override;
 897     bool hasPointers() override;
 898     bool isBoolean() override;
 899
 900     uinteger_t size(const Loc &loc) override;
 901     void accept(Visitor *v) override { v->visit(this); }
 902 };
 903
 904 class TypeNoreturn final : public Type
 905 {
 906 public:
 907     const char *kind() override;
 908     TypeNoreturn *syntaxCopy() override;
 909     MATCH implicitConvTo(Type* to) override;
 910     MATCH constConv(Type* to) override;
 911     bool isBoolean() override;
 912     uinteger_t size(const Loc& loc) override;
 913     unsigned alignsize() override;
 914
 915     void accept(Visitor *v) override { v->visit(this); }
 916 };
 917
 918 class TypeTag final : public Type
 919 {
 920 public:
 921     TypeTag *syntaxCopy() override;
 922
 923     void accept(Visitor *v) override { v->visit(this); }
 924 };
 925
 926 /**************************************************************/
 927
 928 // If the type is a class or struct, returns the symbol for it, else null.
 929 AggregateDeclaration *isAggregate(Type *t);
 930 Covariant covariant(Type *, Type *, StorageClass * = NULL, bool = false);