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