xref: /netbsd-src/external/gpl3/gcc/dist/gcc/d/dmd/mtype.h (revision b1e838363e3c6fc78a55519254d99869742dd33c) 
1 
2 /* Compiler implementation of the D programming language
3  * Copyright (C) 1999-2022 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 void semanticTypeInfo(Scope *sc, Type *t);
43 
44 Type *typeSemantic(Type *t, const Loc &loc, Scope *sc);
45 Type *merge(Type *type);
46 
47 enum class TY : uint8_t
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     Tmixin,
99     Tnoreturn,
100     TMAX
101 };
102 
103 #define SIZE_INVALID (~(uinteger_t)0)   // error return from size() functions
104 
105 
106 /**
107  * type modifiers
108  * pick this order of numbers so switch statements work better
109  */
110 enum MODFlags
111 {
112     MODnone      = 0, // default (mutable)
113     MODconst     = 1, // type is const
114     MODimmutable = 4, // type is immutable
115     MODshared    = 2, // type is shared
116     MODwild      = 8, // type is wild
117     MODwildconst = (MODwild | MODconst), // type is wild const
118     MODmutable   = 0x10       // type is mutable (only used in wildcard matching)
119 };
120 typedef unsigned char MOD;
121 
122 enum class Covariant
123 {
124     distinct = 0,
125     yes = 1,
126     no = 2,
127     fwdref = 3,
128 };
129 
130 enum VarArgValues
131 {
132     VARARGnone     = 0,  /// fixed number of arguments
133     VARARGvariadic = 1,  /// T t, ...)  can be C-style (core.stdc.stdarg) or D-style (core.vararg)
134     VARARGtypesafe = 2   /// T t ...) typesafe https://dlang.org/spec/function.html#typesafe_variadic_functions
135                          ///   or https://dlang.org/spec/function.html#typesafe_variadic_functions
136 };
137 typedef unsigned char VarArg;
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 *o) const;
225     bool equivalent(Type *t);
226     // kludge for template.isType()
dyncast()227     DYNCAST dyncast() const { return DYNCAST_TYPE; }
228     size_t getUniqueID() const;
229     Covariant covariant(Type *t, StorageClass *pstc = NULL);
230     const char *toChars() const;
231     char *toPrettyChars(bool QualifyTypes = false);
232     static void _init();
233 
234     uinteger_t size();
235     virtual uinteger_t size(const Loc &loc);
236     virtual unsigned alignsize();
237     Type *trySemantic(const Loc &loc, Scope *sc);
238     Type *merge2();
239     void modToBuffer(OutBuffer *buf) const;
240     char *modToChars() const;
241 
242     virtual bool isintegral();
243     virtual bool isfloating();   // real, imaginary, or complex
244     virtual bool isreal();
245     virtual bool isimaginary();
246     virtual bool iscomplex();
247     virtual bool isscalar();
248     virtual bool isunsigned();
249     virtual bool isscope();
250     virtual bool isString();
251     virtual bool isAssignable();
252     virtual bool isBoolean();
253     virtual void checkDeprecated(const Loc &loc, Scope *sc);
isConst()254     bool isConst() const       { return (mod & MODconst) != 0; }
isImmutable()255     bool isImmutable() const   { return (mod & MODimmutable) != 0; }
isMutable()256     bool isMutable() const     { return (mod & (MODconst | MODimmutable | MODwild)) == 0; }
isShared()257     bool isShared() const      { return (mod & MODshared) != 0; }
isSharedConst()258     bool isSharedConst() const { return (mod & (MODshared | MODconst)) == (MODshared | MODconst); }
isWild()259     bool isWild() const        { return (mod & MODwild) != 0; }
isWildConst()260     bool isWildConst() const   { return (mod & MODwildconst) == MODwildconst; }
isSharedWild()261     bool isSharedWild() const  { return (mod & (MODshared | MODwild)) == (MODshared | MODwild); }
isNaked()262     bool isNaked() const       { return mod == 0; }
263     Type *nullAttributes() const;
264     Type *constOf();
265     Type *immutableOf();
266     Type *mutableOf();
267     Type *sharedOf();
268     Type *sharedConstOf();
269     Type *unSharedOf();
270     Type *wildOf();
271     Type *wildConstOf();
272     Type *sharedWildOf();
273     Type *sharedWildConstOf();
274     void fixTo(Type *t);
275     void check();
276     Type *addSTC(StorageClass stc);
277     Type *castMod(MOD mod);
278     Type *addMod(MOD mod);
279     virtual Type *addStorageClass(StorageClass stc);
280     Type *pointerTo();
281     Type *referenceTo();
282     Type *arrayOf();
283     Type *sarrayOf(dinteger_t dim);
284     bool hasDeprecatedAliasThis();
285     Type *aliasthisOf();
286     virtual Type *makeConst();
287     virtual Type *makeImmutable();
288     virtual Type *makeShared();
289     virtual Type *makeSharedConst();
290     virtual Type *makeWild();
291     virtual Type *makeWildConst();
292     virtual Type *makeSharedWild();
293     virtual Type *makeSharedWildConst();
294     virtual Type *makeMutable();
295     virtual Dsymbol *toDsymbol(Scope *sc);
296     Type *toBasetype();
297     virtual bool isBaseOf(Type *t, int *poffset);
298     virtual MATCH implicitConvTo(Type *to);
299     virtual MATCH constConv(Type *to);
300     virtual unsigned char deduceWild(Type *t, bool isRef);
301     virtual Type *substWildTo(unsigned mod);
302 
303     Type *unqualify(unsigned m);
304 
305     virtual Type *toHeadMutable();
306     virtual ClassDeclaration *isClassHandle();
307     virtual structalign_t alignment();
308     virtual Expression *defaultInitLiteral(const Loc &loc);
309     virtual bool isZeroInit(const Loc &loc = Loc());                // if initializer is 0
310     Identifier *getTypeInfoIdent();
311     virtual int hasWild() const;
312     virtual bool hasPointers();
313     virtual bool hasVoidInitPointers();
314     virtual bool hasInvariant();
315     virtual Type *nextOf();
316     Type *baseElemOf();
317     uinteger_t sizemask();
318     virtual bool needsDestruction();
319     virtual bool needsCopyOrPostblit();
320     virtual bool needsNested();
321 
322     TypeFunction *toTypeFunction();
323 
324     // For eliminating dynamic_cast
325     virtual TypeBasic *isTypeBasic();
326     TypeFunction *isPtrToFunction();
327     TypeFunction *isFunction_Delegate_PtrToFunction();
328     TypeError *isTypeError();
329     TypeVector *isTypeVector();
330     TypeSArray *isTypeSArray();
331     TypeDArray *isTypeDArray();
332     TypeAArray *isTypeAArray();
333     TypePointer *isTypePointer();
334     TypeReference *isTypeReference();
335     TypeFunction *isTypeFunction();
336     TypeDelegate *isTypeDelegate();
337     TypeIdentifier *isTypeIdentifier();
338     TypeInstance *isTypeInstance();
339     TypeTypeof *isTypeTypeof();
340     TypeReturn *isTypeReturn();
341     TypeStruct *isTypeStruct();
342     TypeEnum *isTypeEnum();
343     TypeClass *isTypeClass();
344     TypeTuple *isTypeTuple();
345     TypeSlice *isTypeSlice();
346     TypeNull *isTypeNull();
347     TypeMixin *isTypeMixin();
348     TypeTraits *isTypeTraits();
349     TypeNoreturn *isTypeNoreturn();
350     TypeTag *isTypeTag();
351 
accept(Visitor * v)352     void accept(Visitor *v) { v->visit(this); }
353 };
354 
355 class TypeError : public Type
356 {
357 public:
358     const char *kind();
359     TypeError *syntaxCopy();
360 
361     uinteger_t size(const Loc &loc);
362     Expression *defaultInitLiteral(const Loc &loc);
accept(Visitor * v)363     void accept(Visitor *v) { v->visit(this); }
364 };
365 
366 class TypeNext : public Type
367 {
368 public:
369     Type *next;
370 
371     void checkDeprecated(const Loc &loc, Scope *sc);
372     int hasWild() const;
373     Type *nextOf();
374     Type *makeConst();
375     Type *makeImmutable();
376     Type *makeShared();
377     Type *makeSharedConst();
378     Type *makeWild();
379     Type *makeWildConst();
380     Type *makeSharedWild();
381     Type *makeSharedWildConst();
382     Type *makeMutable();
383     MATCH constConv(Type *to);
384     unsigned char deduceWild(Type *t, bool isRef);
385     void transitive();
accept(Visitor * v)386     void accept(Visitor *v) { v->visit(this); }
387 };
388 
389 class TypeBasic : public Type
390 {
391 public:
392     const char *dstring;
393     unsigned flags;
394 
395     const char *kind();
396     TypeBasic *syntaxCopy();
397     uinteger_t size(const Loc &loc) /*const*/;
398     unsigned alignsize();
399     bool isintegral();
400     bool isfloating() /*const*/;
401     bool isreal() /*const*/;
402     bool isimaginary() /*const*/;
403     bool iscomplex() /*const*/;
404     bool isscalar() /*const*/;
405     bool isunsigned() /*const*/;
406     MATCH implicitConvTo(Type *to);
407     bool isZeroInit(const Loc &loc) /*const*/;
408 
409     // For eliminating dynamic_cast
410     TypeBasic *isTypeBasic();
accept(Visitor * v)411     void accept(Visitor *v) { v->visit(this); }
412 };
413 
414 class TypeVector : public Type
415 {
416 public:
417     Type *basetype;
418 
419     static TypeVector *create(Type *basetype);
420     const char *kind();
421     TypeVector *syntaxCopy();
422     uinteger_t size(const Loc &loc);
423     unsigned alignsize();
424     bool isintegral();
425     bool isfloating();
426     bool isscalar();
427     bool isunsigned();
428     bool isBoolean() /*const*/;
429     MATCH implicitConvTo(Type *to);
430     Expression *defaultInitLiteral(const Loc &loc);
431     TypeBasic *elementType();
432     bool isZeroInit(const Loc &loc);
433 
accept(Visitor * v)434     void accept(Visitor *v) { v->visit(this); }
435 };
436 
437 class TypeArray : public TypeNext
438 {
439 public:
accept(Visitor * v)440     void accept(Visitor *v) { v->visit(this); }
441 };
442 
443 // Static array, one with a fixed dimension
444 class TypeSArray : public TypeArray
445 {
446 public:
447     Expression *dim;
448 
449     const char *kind();
450     TypeSArray *syntaxCopy();
451     bool isIncomplete();
452     uinteger_t size(const Loc &loc);
453     unsigned alignsize();
454     bool isString();
455     bool isZeroInit(const Loc &loc);
456     structalign_t alignment();
457     MATCH constConv(Type *to);
458     MATCH implicitConvTo(Type *to);
459     Expression *defaultInitLiteral(const Loc &loc);
460     bool hasPointers();
461     bool hasInvariant();
462     bool needsDestruction();
463     bool needsCopyOrPostblit();
464     bool needsNested();
465 
accept(Visitor * v)466     void accept(Visitor *v) { v->visit(this); }
467 };
468 
469 // Dynamic array, no dimension
470 class TypeDArray : public TypeArray
471 {
472 public:
473     const char *kind();
474     TypeDArray *syntaxCopy();
475     uinteger_t size(const Loc &loc) /*const*/;
476     unsigned alignsize() /*const*/;
477     bool isString();
478     bool isZeroInit(const Loc &loc) /*const*/;
479     bool isBoolean() /*const*/;
480     MATCH implicitConvTo(Type *to);
481     bool hasPointers() /*const*/;
482 
accept(Visitor * v)483     void accept(Visitor *v) { v->visit(this); }
484 };
485 
486 class TypeAArray : public TypeArray
487 {
488 public:
489     Type *index;                // key type
490     Loc loc;
491 
492     static TypeAArray *create(Type *t, Type *index);
493     const char *kind();
494     TypeAArray *syntaxCopy();
495     uinteger_t size(const Loc &loc);
496     bool isZeroInit(const Loc &loc) /*const*/;
497     bool isBoolean() /*const*/;
498     bool hasPointers() /*const*/;
499     MATCH implicitConvTo(Type *to);
500     MATCH constConv(Type *to);
501 
accept(Visitor * v)502     void accept(Visitor *v) { v->visit(this); }
503 };
504 
505 class TypePointer : public TypeNext
506 {
507 public:
508     static TypePointer *create(Type *t);
509     const char *kind();
510     TypePointer *syntaxCopy();
511     uinteger_t size(const Loc &loc) /*const*/;
512     MATCH implicitConvTo(Type *to);
513     MATCH constConv(Type *to);
514     bool isscalar() /*const*/;
515     bool isZeroInit(const Loc &loc) /*const*/;
516     bool hasPointers() /*const*/;
517 
accept(Visitor * v)518     void accept(Visitor *v) { v->visit(this); }
519 };
520 
521 class TypeReference : public TypeNext
522 {
523 public:
524     const char *kind();
525     TypeReference *syntaxCopy();
526     uinteger_t size(const Loc &loc) /*const*/;
527     bool isZeroInit(const Loc &loc) /*const*/;
accept(Visitor * v)528     void accept(Visitor *v) { v->visit(this); }
529 };
530 
531 enum RET
532 {
533     RETregs     = 1,    // returned in registers
534     RETstack    = 2     // returned on stack
535 };
536 
537 enum class TRUST : unsigned char
538 {
539     default_ = 0,
540     system = 1,    // @system (same as TRUSTdefault)
541     trusted = 2,   // @trusted
542     safe = 3       // @safe
543 };
544 
545 enum TRUSTformat
546 {
547     TRUSTformatDefault,  // do not emit @system when trust == TRUSTdefault
548     TRUSTformatSystem    // emit @system when trust == TRUSTdefault
549 };
550 
551 enum class PURE : unsigned char
552 {
553     impure = 0,     // not pure at all
554     fwdref = 1,     // it's pure, but not known which level yet
555     weak = 2,       // no mutable globals are read or written
556     const_ = 3,     // parameters are values or const
557 };
558 
559 class Parameter : public ASTNode
560 {
561 public:
562     StorageClass storageClass;
563     Type *type;
564     Identifier *ident;
565     Expression *defaultArg;
566     UserAttributeDeclaration *userAttribDecl;   // user defined attributes
567 
568     static Parameter *create(StorageClass storageClass, Type *type, Identifier *ident,
569                              Expression *defaultArg, UserAttributeDeclaration *userAttribDecl);
570     Parameter *syntaxCopy();
571     Type *isLazyArray();
572     // kludge for template.isType()
dyncast()573     DYNCAST dyncast() const { return DYNCAST_PARAMETER; }
accept(Visitor * v)574     void accept(Visitor *v) { v->visit(this); }
575 
576     static size_t dim(Parameters *parameters);
577     static Parameter *getNth(Parameters *parameters, d_size_t nth);
578     const char *toChars() const;
579     bool isCovariant(bool returnByRef, const Parameter *p, bool previewIn) const;
580 };
581 
582 struct ParameterList
583 {
584     Parameters* parameters;
585     StorageClass stc;
586     VarArg varargs;
587     bool hasIdentifierList; // true if C identifier-list style
588 
589     size_t length();
590     Parameter *operator[](size_t i) { return Parameter::getNth(parameters, i); }
591 };
592 
593 class TypeFunction : public TypeNext
594 {
595 public:
596     // .next is the return type
597 
598     ParameterList parameterList; // function parameters
599     uint16_t bitFields;
600     LINK linkage;                // calling convention
601     TRUST trust;                 // level of trust
602     PURE purity;                 // PURExxxx
603     char inuse;
604     Expressions *fargs;          // function arguments
605 
606     static TypeFunction *create(Parameters *parameters, Type *treturn, VarArg varargs, LINK linkage, StorageClass stc = 0);
607     const char *kind();
608     TypeFunction *syntaxCopy();
609     void purityLevel();
610     bool hasLazyParameters();
611     bool isDstyleVariadic() const;
612     StorageClass parameterStorageClass(Parameter *p);
613     Type *addStorageClass(StorageClass stc);
614 
615     Type *substWildTo(unsigned mod);
616     MATCH constConv(Type *to);
617 
618     bool isnothrow() const;
619     void isnothrow(bool v);
620     bool isnogc() const;
621     void isnogc(bool v);
622     bool isproperty() const;
623     void isproperty(bool v);
624     bool isref() const;
625     void isref(bool v);
626     bool isreturn() const;
627     void isreturn(bool v);
628     bool isreturnscope() const;
629     void isreturnscope(bool v);
630     bool isScopeQual() const;
631     void isScopeQual(bool v);
632     bool isreturninferred() const;
633     void isreturninferred(bool v);
634     bool isscopeinferred() const;
635     void isscopeinferred(bool v);
636     bool islive() const;
637     void islive(bool v);
638     bool incomplete() const;
639     void incomplete(bool v);
640     bool isInOutParam() const;
641     void isInOutParam(bool v);
642     bool isInOutQual() const;
643     void isInOutQual(bool v);
644     bool iswild() const;
645 
accept(Visitor * v)646     void accept(Visitor *v) { v->visit(this); }
647 };
648 
649 class TypeDelegate : public TypeNext
650 {
651 public:
652     // .next is a TypeFunction
653 
654     static TypeDelegate *create(TypeFunction *t);
655     const char *kind();
656     TypeDelegate *syntaxCopy();
657     Type *addStorageClass(StorageClass stc);
658     uinteger_t size(const Loc &loc) /*const*/;
659     unsigned alignsize() /*const*/;
660     MATCH implicitConvTo(Type *to);
661     bool isZeroInit(const Loc &loc) /*const*/;
662     bool isBoolean() /*const*/;
663     bool hasPointers() /*const*/;
664 
accept(Visitor * v)665     void accept(Visitor *v) { v->visit(this); }
666 };
667 
668 class TypeTraits : public Type
669 {
670     Loc loc;
671     /// The expression to resolve as type or symbol.
672     TraitsExp *exp;
673     /// The symbol when exp doesn't represent a type.
674     Dsymbol *sym;
675 
676     const char *kind();
677     TypeTraits *syntaxCopy();
678     uinteger_t size(const Loc &loc);
679     Dsymbol *toDsymbol(Scope *sc);
accept(Visitor * v)680     void accept(Visitor *v) { v->visit(this); }
681 };
682 
683 class TypeMixin : public Type
684 {
685     Loc loc;
686     Expressions *exps;
687     RootObject *obj;
688 
689     const char *kind();
690     TypeMixin *syntaxCopy();
691     Dsymbol *toDsymbol(Scope *sc);
accept(Visitor * v)692     void accept(Visitor *v) { v->visit(this); }
693 };
694 
695 class TypeQualified : public Type
696 {
697 public:
698     Loc loc;
699     // array of Identifier and TypeInstance,
700     // representing ident.ident!tiargs.ident. ... etc.
701     Objects idents;
702 
703     void syntaxCopyHelper(TypeQualified *t);
704     void addIdent(Identifier *ident);
705     void addInst(TemplateInstance *inst);
706     void addIndex(RootObject *expr);
707     uinteger_t size(const Loc &loc);
708 
accept(Visitor * v)709     void accept(Visitor *v) { v->visit(this); }
710 };
711 
712 class TypeIdentifier : public TypeQualified
713 {
714 public:
715     Identifier *ident;
716     Dsymbol *originalSymbol; // The symbol representing this identifier, before alias resolution
717 
718     static TypeIdentifier *create(const Loc &loc, Identifier *ident);
719     const char *kind();
720     TypeIdentifier *syntaxCopy();
721     Dsymbol *toDsymbol(Scope *sc);
accept(Visitor * v)722     void accept(Visitor *v) { v->visit(this); }
723 };
724 
725 /* Similar to TypeIdentifier, but with a TemplateInstance as the root
726  */
727 class TypeInstance : public TypeQualified
728 {
729 public:
730     TemplateInstance *tempinst;
731 
732     const char *kind();
733     TypeInstance *syntaxCopy();
734     Dsymbol *toDsymbol(Scope *sc);
accept(Visitor * v)735     void accept(Visitor *v) { v->visit(this); }
736 };
737 
738 class TypeTypeof : public TypeQualified
739 {
740 public:
741     Expression *exp;
742     int inuse;
743 
744     const char *kind();
745     TypeTypeof *syntaxCopy();
746     Dsymbol *toDsymbol(Scope *sc);
747     uinteger_t size(const Loc &loc);
accept(Visitor * v)748     void accept(Visitor *v) { v->visit(this); }
749 };
750 
751 class TypeReturn : public TypeQualified
752 {
753 public:
754     const char *kind();
755     TypeReturn *syntaxCopy();
756     Dsymbol *toDsymbol(Scope *sc);
accept(Visitor * v)757     void accept(Visitor *v) { v->visit(this); }
758 };
759 
760 // Whether alias this dependency is recursive or not.
761 enum AliasThisRec
762 {
763     RECno = 0,      // no alias this recursion
764     RECyes = 1,     // alias this has recursive dependency
765     RECfwdref = 2,  // not yet known
766     RECtypeMask = 3,// mask to read no/yes/fwdref
767 
768     RECtracing = 0x4, // mark in progress of implicitConvTo/deduceWild
769     RECtracingDT = 0x8  // mark in progress of deduceType
770 };
771 
772 class TypeStruct : public Type
773 {
774 public:
775     StructDeclaration *sym;
776     AliasThisRec att;
777     bool inuse;
778 
779     static TypeStruct *create(StructDeclaration *sym);
780     const char *kind();
781     uinteger_t size(const Loc &loc);
782     unsigned alignsize();
783     TypeStruct *syntaxCopy();
784     Dsymbol *toDsymbol(Scope *sc);
785     structalign_t alignment();
786     Expression *defaultInitLiteral(const Loc &loc);
787     bool isZeroInit(const Loc &loc);
788     bool isAssignable();
789     bool isBoolean() /*const*/;
790     bool needsDestruction() /*const*/;
791     bool needsCopyOrPostblit();
792     bool needsNested();
793     bool hasPointers();
794     bool hasVoidInitPointers();
795     bool hasInvariant();
796     MATCH implicitConvTo(Type *to);
797     MATCH constConv(Type *to);
798     unsigned char deduceWild(Type *t, bool isRef);
799     Type *toHeadMutable();
800 
accept(Visitor * v)801     void accept(Visitor *v) { v->visit(this); }
802 };
803 
804 class TypeEnum : public Type
805 {
806 public:
807     EnumDeclaration *sym;
808 
809     const char *kind();
810     TypeEnum *syntaxCopy();
811     uinteger_t size(const Loc &loc);
812     unsigned alignsize();
813     Type *memType(const Loc &loc = Loc());
814     Dsymbol *toDsymbol(Scope *sc);
815     bool isintegral();
816     bool isfloating();
817     bool isreal();
818     bool isimaginary();
819     bool iscomplex();
820     bool isscalar();
821     bool isunsigned();
822     bool isBoolean();
823     bool isString();
824     bool isAssignable();
825     bool needsDestruction();
826     bool needsCopyOrPostblit();
827     bool needsNested();
828     MATCH implicitConvTo(Type *to);
829     MATCH constConv(Type *to);
830     bool isZeroInit(const Loc &loc);
831     bool hasPointers();
832     bool hasVoidInitPointers();
833     bool hasInvariant();
834     Type *nextOf();
835 
accept(Visitor * v)836     void accept(Visitor *v) { v->visit(this); }
837 };
838 
839 class TypeClass : public Type
840 {
841 public:
842     ClassDeclaration *sym;
843     AliasThisRec att;
844     CPPMANGLE cppmangle;
845 
846     const char *kind();
847     uinteger_t size(const Loc &loc) /*const*/;
848     TypeClass *syntaxCopy();
849     Dsymbol *toDsymbol(Scope *sc);
850     ClassDeclaration *isClassHandle();
851     bool isBaseOf(Type *t, int *poffset);
852     MATCH implicitConvTo(Type *to);
853     MATCH constConv(Type *to);
854     unsigned char deduceWild(Type *t, bool isRef);
855     Type *toHeadMutable();
856     bool isZeroInit(const Loc &loc) /*const*/;
857     bool isscope() /*const*/;
858     bool isBoolean() /*const*/;
859     bool hasPointers() /*const*/;
860 
accept(Visitor * v)861     void accept(Visitor *v) { v->visit(this); }
862 };
863 
864 class TypeTuple : public Type
865 {
866 public:
867     // 'logically immutable' cached global - don't modify (neither pointer nor pointee)!
868     static TypeTuple *empty;
869 
870     Parameters *arguments;      // types making up the tuple
871 
872     static TypeTuple *create(Parameters *arguments);
873     static TypeTuple *create();
874     static TypeTuple *create(Type *t1);
875     static TypeTuple *create(Type *t1, Type *t2);
876     const char *kind();
877     TypeTuple *syntaxCopy();
878     bool equals(const RootObject *o) const;
accept(Visitor * v)879     void accept(Visitor *v) { v->visit(this); }
880 };
881 
882 class TypeSlice : public TypeNext
883 {
884 public:
885     Expression *lwr;
886     Expression *upr;
887 
888     const char *kind();
889     TypeSlice *syntaxCopy();
accept(Visitor * v)890     void accept(Visitor *v) { v->visit(this); }
891 };
892 
893 class TypeNull : public Type
894 {
895 public:
896     const char *kind();
897 
898     TypeNull *syntaxCopy();
899     MATCH implicitConvTo(Type *to);
900     bool isBoolean() /*const*/;
901 
902     uinteger_t size(const Loc &loc) /*const*/;
accept(Visitor * v)903     void accept(Visitor *v) { v->visit(this); }
904 };
905 
906 class TypeNoreturn final : public Type
907 {
908 public:
909     const char *kind();
910     TypeNoreturn *syntaxCopy();
911     MATCH implicitConvTo(Type* to);
912     MATCH constConv(Type* to);
913     bool isBoolean() /* const */;
914     uinteger_t size(const Loc& loc) /* const */;
915     unsigned alignsize();
916 
accept(Visitor * v)917     void accept(Visitor *v) { v->visit(this); }
918 };
919 
920 class TypeTag final : public Type
921 {
922 public:
923     TypeTag *syntaxCopy();
924 
accept(Visitor * v)925     void accept(Visitor *v) { v->visit(this); }
926 };
927 
928 /**************************************************************/
929 
930 bool arrayTypeCompatibleWithoutCasting(Type *t1, Type *t2);
931 
932 // If the type is a class or struct, returns the symbol for it, else null.
933 AggregateDeclaration *isAggregate(Type *t);
934