?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d: Merge upstream dmd, druntime f8bae04558, phobos ba2ade9dec
[official-gcc.git] / gcc / d / dmd / mtype.d
blob2c9e058bf325c465e597a3b35550ec1ffb9e6061
1 /**
2 * Defines a D type.
3 *
4 * Copyright: Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved
5 * Authors: $(LINK2 https://www.digitalmars.com, Walter Bright)
6 * License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
7 * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/mtype.d, _mtype.d)
8 * Documentation: https://dlang.org/phobos/dmd_mtype.html
9 * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/mtype.d
10 */
11
12 module dmd.mtype;
13
14 import core.checkedint;
15 import core.stdc.stdarg;
16 import core.stdc.stdio;
17 import core.stdc.stdlib;
18 import core.stdc.string;
19
20 import dmd.aggregate;
21 import dmd.arraytypes;
22 import dmd.astenums;
23 import dmd.ast_node;
24 import dmd.dclass;
25 import dmd.declaration;
26 import dmd.denum;
27 import dmd.dstruct;
28 import dmd.dsymbol;
29 import dmd.dtemplate;
30 import dmd.enumsem;
31 import dmd.errors;
32 import dmd.expression;
33 import dmd.funcsem;
34 import dmd.globals;
35 import dmd.hdrgen;
36 import dmd.id;
37 import dmd.identifier;
38 import dmd.location;
39 import dmd.root.ctfloat;
40 import dmd.common.outbuffer;
41 import dmd.root.rmem;
42 import dmd.rootobject;
43 import dmd.root.stringtable;
44 import dmd.target;
45 import dmd.tokens;
46 import dmd.typesem;
47 import dmd.visitor;
48
49 enum LOGDOTEXP = 0; // log ::dotExp()
50 enum LOGDEFAULTINIT = 0; // log ::defaultInit()
51
52 enum SIZE_INVALID = (~cast(uinteger_t)0); // error return from size() functions
53
54 static if (__VERSION__ < 2095)
55 {
56 // Fix linker errors when building with older compilers.
57 // See: https://issues.dlang.org/show_bug.cgi?id=21299
58 private alias StringValueType = StringValue!Type;
59 }
60
61 /***************************
62 * Return !=0 if modfrom can be implicitly converted to modto
63 */
64 bool MODimplicitConv(MOD modfrom, MOD modto) pure nothrow @nogc @safe
65 {
66 if (modfrom == modto)
67 return true;
68
69 //printf("MODimplicitConv(from = %x, to = %x)\n", modfrom, modto);
70 auto X(T, U)(T m, U n)
71 {
72 return ((m << 4) | n);
73 }
74
75 switch (X(modfrom & ~MODFlags.shared_, modto & ~MODFlags.shared_))
76 {
77 case X(0, MODFlags.const_):
78 case X(MODFlags.wild, MODFlags.const_):
79 case X(MODFlags.wild, MODFlags.wildconst):
80 case X(MODFlags.wildconst, MODFlags.const_):
81 return (modfrom & MODFlags.shared_) == (modto & MODFlags.shared_);
82
83 case X(MODFlags.immutable_, MODFlags.const_):
84 case X(MODFlags.immutable_, MODFlags.wildconst):
85 return true;
86 default:
87 return false;
88 }
89 }
90
91 /***************************
92 * Return MATCH.exact or MATCH.constant if a method of type '() modfrom' can call a method of type '() modto'.
93 */
94 MATCH MODmethodConv(MOD modfrom, MOD modto) pure nothrow @nogc @safe
95 {
96 if (modfrom == modto)
97 return MATCH.exact;
98 if (MODimplicitConv(modfrom, modto))
99 return MATCH.constant;
100
101 auto X(T, U)(T m, U n)
102 {
103 return ((m << 4) | n);
104 }
105
106 switch (X(modfrom, modto))
107 {
108 case X(0, MODFlags.wild):
109 case X(MODFlags.immutable_, MODFlags.wild):
110 case X(MODFlags.const_, MODFlags.wild):
111 case X(MODFlags.wildconst, MODFlags.wild):
112 case X(MODFlags.shared_, MODFlags.shared_ | MODFlags.wild):
113 case X(MODFlags.shared_ | MODFlags.immutable_, MODFlags.shared_ | MODFlags.wild):
114 case X(MODFlags.shared_ | MODFlags.const_, MODFlags.shared_ | MODFlags.wild):
115 case X(MODFlags.shared_ | MODFlags.wildconst, MODFlags.shared_ | MODFlags.wild):
116 return MATCH.constant;
117
118 default:
119 return MATCH.nomatch;
120 }
121 }
122
123 /***************************
124 * Merge mod bits to form common mod.
125 */
126 MOD MODmerge(MOD mod1, MOD mod2) pure nothrow @nogc @safe
127 {
128 if (mod1 == mod2)
129 return mod1;
130
131 //printf("MODmerge(1 = %x, 2 = %x)\n", mod1, mod2);
132 MOD result = 0;
133 if ((mod1 | mod2) & MODFlags.shared_)
134 {
135 // If either type is shared, the result will be shared
136 result |= MODFlags.shared_;
137 mod1 &= ~MODFlags.shared_;
138 mod2 &= ~MODFlags.shared_;
139 }
140 if (mod1 == 0 || mod1 == MODFlags.mutable || mod1 == MODFlags.const_ || mod2 == 0 || mod2 == MODFlags.mutable || mod2 == MODFlags.const_)
141 {
142 // If either type is mutable or const, the result will be const.
143 result |= MODFlags.const_;
144 }
145 else
146 {
147 // MODFlags.immutable_ vs MODFlags.wild
148 // MODFlags.immutable_ vs MODFlags.wildconst
149 // MODFlags.wild vs MODFlags.wildconst
150 assert(mod1 & MODFlags.wild || mod2 & MODFlags.wild);
151 result |= MODFlags.wildconst;
152 }
153 return result;
154 }
155
156 /*********************************
157 * Store modifier name into buf.
158 */
159 void MODtoBuffer(ref OutBuffer buf, MOD mod) nothrow @safe
160 {
161 buf.writestring(MODtoString(mod));
162 }
163
164 /*********************************
165 * Returns:
166 * a human readable representation of `mod`,
167 * which is the token `mod` corresponds to
168 */
169 const(char)* MODtoChars(MOD mod) nothrow pure
170 {
171 /// Works because we return a literal
172 return MODtoString(mod).ptr;
173 }
174
175 /// Ditto
176 string MODtoString(MOD mod) nothrow pure @safe
177 {
178 final switch (mod)
179 {
180 case 0:
181 return "";
182
183 case MODFlags.immutable_:
184 return "immutable";
185
186 case MODFlags.shared_:
187 return "shared";
188
189 case MODFlags.shared_ | MODFlags.const_:
190 return "shared const";
191
192 case MODFlags.const_:
193 return "const";
194
195 case MODFlags.shared_ | MODFlags.wild:
196 return "shared inout";
197
198 case MODFlags.wild:
199 return "inout";
200
201 case MODFlags.shared_ | MODFlags.wildconst:
202 return "shared inout const";
203
204 case MODFlags.wildconst:
205 return "inout const";
206 }
207 }
208
209 /*************************************************
210 * Pick off one of the trust flags from trust,
211 * and return a string representation of it.
212 */
213 string trustToString(TRUST trust) pure nothrow @nogc @safe
214 {
215 final switch (trust)
216 {
217 case TRUST.default_:
218 return null;
219 case TRUST.system:
220 return "@system";
221 case TRUST.trusted:
222 return "@trusted";
223 case TRUST.safe:
224 return "@safe";
225 }
226 }
227
228 unittest
229 {
230 assert(trustToString(TRUST.default_) == "");
231 assert(trustToString(TRUST.system) == "@system");
232 assert(trustToString(TRUST.trusted) == "@trusted");
233 assert(trustToString(TRUST.safe) == "@safe");
234 }
235
236 /************************************
237 * Convert MODxxxx to STCxxx
238 */
239 StorageClass ModToStc(uint mod) pure nothrow @nogc @safe
240 {
241 StorageClass stc = 0;
242 if (mod & MODFlags.immutable_)
243 stc |= STC.immutable_;
244 if (mod & MODFlags.const_)
245 stc |= STC.const_;
246 if (mod & MODFlags.wild)
247 stc |= STC.wild;
248 if (mod & MODFlags.shared_)
249 stc |= STC.shared_;
250 return stc;
251 }
252
253 ///Returns true if ty is char, wchar, or dchar
254 bool isSomeChar(TY ty) pure nothrow @nogc @safe
255 {
256 return ty == Tchar || ty == Twchar || ty == Tdchar;
257 }
258
259 /****************
260 * dotExp() bit flags
261 */
262 enum DotExpFlag
263 {
264 none = 0,
265 gag = 1, // don't report "not a property" error and just return null
266 noDeref = 2, // the use of the expression will not attempt a dereference
267 noAliasThis = 4, // don't do 'alias this' resolution
268 }
269
270 /// Result of a check whether two types are covariant
271 enum Covariant
272 {
273 distinct = 0, /// types are distinct
274 yes = 1, /// types are covariant
275 no = 2, /// arguments match as far as overloading goes, but types are not covariant
276 fwdref = 3, /// cannot determine covariance because of forward references
277 }
278
279 /***********************************************************
280 */
281 extern (C++) abstract class Type : ASTNode
282 {
283 TY ty;
284 MOD mod; // modifiers MODxxxx
285 char* deco;
286
287 static struct Mcache
288 {
289 /* These are cached values that are lazily evaluated by constOf(), immutableOf(), etc.
290 * They should not be referenced by anybody but mtype.d.
291 * They can be null if not lazily evaluated yet.
292 * Note that there is no "shared immutable", because that is just immutable
293 * The point of this is to reduce the size of each Type instance as
294 * we bank on the idea that usually only one of variants exist.
295 * It will also speed up code because these are rarely referenced and
296 * so need not be in the cache.
297 */
298 Type cto; // MODFlags.const_
299 Type ito; // MODFlags.immutable_
300 Type sto; // MODFlags.shared_
301 Type scto; // MODFlags.shared_ | MODFlags.const_
302 Type wto; // MODFlags.wild
303 Type wcto; // MODFlags.wildconst
304 Type swto; // MODFlags.shared_ | MODFlags.wild
305 Type swcto; // MODFlags.shared_ | MODFlags.wildconst
306 }
307 Mcache* mcache;
308
309 Type pto; // merged pointer to this type
310 Type rto; // reference to this type
311 Type arrayof; // array of this type
312
313 TypeInfoDeclaration vtinfo; // TypeInfo object for this Type
314
315 void* ctype; // for back end
316
317 extern (C++) __gshared Type tvoid;
318 extern (C++) __gshared Type tint8;
319 extern (C++) __gshared Type tuns8;
320 extern (C++) __gshared Type tint16;
321 extern (C++) __gshared Type tuns16;
322 extern (C++) __gshared Type tint32;
323 extern (C++) __gshared Type tuns32;
324 extern (C++) __gshared Type tint64;
325 extern (C++) __gshared Type tuns64;
326 extern (C++) __gshared Type tint128;
327 extern (C++) __gshared Type tuns128;
328 extern (C++) __gshared Type tfloat32;
329 extern (C++) __gshared Type tfloat64;
330 extern (C++) __gshared Type tfloat80;
331 extern (C++) __gshared Type timaginary32;
332 extern (C++) __gshared Type timaginary64;
333 extern (C++) __gshared Type timaginary80;
334 extern (C++) __gshared Type tcomplex32;
335 extern (C++) __gshared Type tcomplex64;
336 extern (C++) __gshared Type tcomplex80;
337 extern (C++) __gshared Type tbool;
338 extern (C++) __gshared Type tchar;
339 extern (C++) __gshared Type twchar;
340 extern (C++) __gshared Type tdchar;
341
342 // Some special types
343 extern (C++) __gshared Type tshiftcnt;
344 extern (C++) __gshared Type tvoidptr; // void*
345 extern (C++) __gshared Type tstring; // immutable(char)[]
346 extern (C++) __gshared Type twstring; // immutable(wchar)[]
347 extern (C++) __gshared Type tdstring; // immutable(dchar)[]
348 extern (C++) __gshared Type terror; // for error recovery
349 extern (C++) __gshared Type tnull; // for null type
350 extern (C++) __gshared Type tnoreturn; // for bottom type typeof(*null)
351
352 extern (C++) __gshared Type tsize_t; // matches size_t alias
353 extern (C++) __gshared Type tptrdiff_t; // matches ptrdiff_t alias
354 extern (C++) __gshared Type thash_t; // matches hash_t alias
355
356 extern (C++) __gshared ClassDeclaration dtypeinfo;
357 extern (C++) __gshared ClassDeclaration typeinfoclass;
358 extern (C++) __gshared ClassDeclaration typeinfointerface;
359 extern (C++) __gshared ClassDeclaration typeinfostruct;
360 extern (C++) __gshared ClassDeclaration typeinfopointer;
361 extern (C++) __gshared ClassDeclaration typeinfoarray;
362 extern (C++) __gshared ClassDeclaration typeinfostaticarray;
363 extern (C++) __gshared ClassDeclaration typeinfoassociativearray;
364 extern (C++) __gshared ClassDeclaration typeinfovector;
365 extern (C++) __gshared ClassDeclaration typeinfoenum;
366 extern (C++) __gshared ClassDeclaration typeinfofunction;
367 extern (C++) __gshared ClassDeclaration typeinfodelegate;
368 extern (C++) __gshared ClassDeclaration typeinfotypelist;
369 extern (C++) __gshared ClassDeclaration typeinfoconst;
370 extern (C++) __gshared ClassDeclaration typeinfoinvariant;
371 extern (C++) __gshared ClassDeclaration typeinfoshared;
372 extern (C++) __gshared ClassDeclaration typeinfowild;
373
374 extern (C++) __gshared TemplateDeclaration rtinfo;
375
376 extern (C++) __gshared Type[TMAX] basic;
377
378 extern (D) __gshared StringTable!Type stringtable;
379 extern (D) private static immutable ubyte[TMAX] sizeTy = ()
380 {
381 ubyte[TMAX] sizeTy = __traits(classInstanceSize, TypeBasic);
382 sizeTy[Tsarray] = __traits(classInstanceSize, TypeSArray);
383 sizeTy[Tarray] = __traits(classInstanceSize, TypeDArray);
384 sizeTy[Taarray] = __traits(classInstanceSize, TypeAArray);
385 sizeTy[Tpointer] = __traits(classInstanceSize, TypePointer);
386 sizeTy[Treference] = __traits(classInstanceSize, TypeReference);
387 sizeTy[Tfunction] = __traits(classInstanceSize, TypeFunction);
388 sizeTy[Tdelegate] = __traits(classInstanceSize, TypeDelegate);
389 sizeTy[Tident] = __traits(classInstanceSize, TypeIdentifier);
390 sizeTy[Tinstance] = __traits(classInstanceSize, TypeInstance);
391 sizeTy[Ttypeof] = __traits(classInstanceSize, TypeTypeof);
392 sizeTy[Tenum] = __traits(classInstanceSize, TypeEnum);
393 sizeTy[Tstruct] = __traits(classInstanceSize, TypeStruct);
394 sizeTy[Tclass] = __traits(classInstanceSize, TypeClass);
395 sizeTy[Ttuple] = __traits(classInstanceSize, TypeTuple);
396 sizeTy[Tslice] = __traits(classInstanceSize, TypeSlice);
397 sizeTy[Treturn] = __traits(classInstanceSize, TypeReturn);
398 sizeTy[Terror] = __traits(classInstanceSize, TypeError);
399 sizeTy[Tnull] = __traits(classInstanceSize, TypeNull);
400 sizeTy[Tvector] = __traits(classInstanceSize, TypeVector);
401 sizeTy[Ttraits] = __traits(classInstanceSize, TypeTraits);
402 sizeTy[Tmixin] = __traits(classInstanceSize, TypeMixin);
403 sizeTy[Tnoreturn] = __traits(classInstanceSize, TypeNoreturn);
404 sizeTy[Ttag] = __traits(classInstanceSize, TypeTag);
405 return sizeTy;
406 }();
407
408 final extern (D) this(TY ty) scope @safe
409 {
410 this.ty = ty;
411 }
412
413 const(char)* kind() const nothrow pure @nogc @safe
414 {
415 assert(false); // should be overridden
416 }
417
418 final Type copy() nothrow const
419 {
420 Type t = cast(Type)mem.xmalloc(sizeTy[ty]);
421 memcpy(cast(void*)t, cast(void*)this, sizeTy[ty]);
422 return t;
423 }
424
425 Type syntaxCopy()
426 {
427 fprintf(stderr, "this = %s, ty = %d\n", toChars(), ty);
428 assert(0);
429 }
430
431 override bool equals(const RootObject o) const
432 {
433 Type t = cast(Type)o;
434 //printf("Type::equals(%s, %s)\n", toChars(), t.toChars());
435 // deco strings are unique
436 // and semantic() has been run
437 if (this == o || ((t && deco == t.deco) && deco !is null))
438 {
439 //printf("deco = '%s', t.deco = '%s'\n", deco, t.deco);
440 return true;
441 }
442 //if (deco && t && t.deco) printf("deco = '%s', t.deco = '%s'\n", deco, t.deco);
443 return false;
444 }
445
446 // kludge for template.isType()
447 override final DYNCAST dyncast() const
448 {
449 return DYNCAST.type;
450 }
451
452 /// Returns a non-zero unique ID for this Type, or returns 0 if the Type does not (yet) have a unique ID.
453 /// If `semantic()` has not been run, 0 is returned.
454 final size_t getUniqueID() const
455 {
456 return cast(size_t) deco;
457 }
458
459 extern (D)
460 final Mcache* getMcache()
461 {
462 if (!mcache)
463 mcache = cast(Mcache*) mem.xcalloc(Mcache.sizeof, 1);
464 return mcache;
465 }
466
467 /********************************
468 * For pretty-printing a type.
469 */
470 final override const(char)* toChars() const
471 {
472 return dmd.hdrgen.toChars(this);
473 }
474
475 /// ditto
476 final char* toPrettyChars(bool QualifyTypes = false)
477 {
478 OutBuffer buf;
479 buf.reserve(16);
480 HdrGenState hgs;
481 hgs.fullQual = QualifyTypes;
482
483 toCBuffer(this, buf, null, hgs);
484 return buf.extractChars();
485 }
486
487 static void _init()
488 {
489 stringtable._init(14_000);
490
491 // Set basic types
492 __gshared TY* basetab =
493 [
494 Tvoid,
495 Tint8,
496 Tuns8,
497 Tint16,
498 Tuns16,
499 Tint32,
500 Tuns32,
501 Tint64,
502 Tuns64,
503 Tint128,
504 Tuns128,
505 Tfloat32,
506 Tfloat64,
507 Tfloat80,
508 Timaginary32,
509 Timaginary64,
510 Timaginary80,
511 Tcomplex32,
512 Tcomplex64,
513 Tcomplex80,
514 Tbool,
515 Tchar,
516 Twchar,
517 Tdchar,
518 Terror
519 ];
520
521 static Type merge(Type t)
522 {
523 import dmd.basicmangle : tyToDecoBuffer;
524
525 OutBuffer buf;
526 buf.reserve(3);
527
528 if (t.ty == Tnoreturn)
529 buf.writestring("Nn");
530 else
531 tyToDecoBuffer(buf, t.ty);
532
533 auto sv = t.stringtable.update(buf[]);
534 if (sv.value)
535 return sv.value;
536 else
537 {
538 t.deco = cast(char*)sv.toDchars();
539 sv.value = t;
540 return t;
541 }
542 }
543
544 for (size_t i = 0; basetab[i] != Terror; i++)
545 {
546 Type t = new TypeBasic(basetab[i]);
547 t = merge(t);
548 basic[basetab[i]] = t;
549 }
550 basic[Terror] = new TypeError();
551
552 tnoreturn = new TypeNoreturn();
553 tnoreturn.deco = merge(tnoreturn).deco;
554 basic[Tnoreturn] = tnoreturn;
555
556 tvoid = basic[Tvoid];
557 tint8 = basic[Tint8];
558 tuns8 = basic[Tuns8];
559 tint16 = basic[Tint16];
560 tuns16 = basic[Tuns16];
561 tint32 = basic[Tint32];
562 tuns32 = basic[Tuns32];
563 tint64 = basic[Tint64];
564 tuns64 = basic[Tuns64];
565 tint128 = basic[Tint128];
566 tuns128 = basic[Tuns128];
567 tfloat32 = basic[Tfloat32];
568 tfloat64 = basic[Tfloat64];
569 tfloat80 = basic[Tfloat80];
570
571 timaginary32 = basic[Timaginary32];
572 timaginary64 = basic[Timaginary64];
573 timaginary80 = basic[Timaginary80];
574
575 tcomplex32 = basic[Tcomplex32];
576 tcomplex64 = basic[Tcomplex64];
577 tcomplex80 = basic[Tcomplex80];
578
579 tbool = basic[Tbool];
580 tchar = basic[Tchar];
581 twchar = basic[Twchar];
582 tdchar = basic[Tdchar];
583
584 tshiftcnt = tint32;
585 terror = basic[Terror];
586 tnoreturn = basic[Tnoreturn];
587 tnull = new TypeNull();
588 tnull.deco = merge(tnull).deco;
589
590 tvoidptr = tvoid.pointerTo();
591 tstring = tchar.immutableOf().arrayOf();
592 twstring = twchar.immutableOf().arrayOf();
593 tdstring = tdchar.immutableOf().arrayOf();
594
595 const isLP64 = target.isLP64;
596
597 tsize_t = basic[isLP64 ? Tuns64 : Tuns32];
598 tptrdiff_t = basic[isLP64 ? Tint64 : Tint32];
599 thash_t = tsize_t;
600 }
601
602 /**
603 * Deinitializes the global state of the compiler.
604 *
605 * This can be used to restore the state set by `_init` to its original
606 * state.
607 */
608 static void deinitialize()
609 {
610 stringtable = stringtable.init;
611 }
612
613 final uinteger_t size()
614 {
615 return size(Loc.initial);
616 }
617
618 uinteger_t size(const ref Loc loc)
619 {
620 error(loc, "no size for type `%s`", toChars());
621 return SIZE_INVALID;
622 }
623
624 uint alignsize()
625 {
626 return cast(uint)size(Loc.initial);
627 }
628
629 /*********************************
630 * Store this type's modifier name into buf.
631 */
632 final void modToBuffer(ref OutBuffer buf) nothrow const
633 {
634 if (mod)
635 {
636 buf.writeByte(' ');
637 MODtoBuffer(buf, mod);
638 }
639 }
640
641 /*********************************
642 * Return this type's modifier name.
643 */
644 final char* modToChars() nothrow const
645 {
646 OutBuffer buf;
647 buf.reserve(16);
648 modToBuffer(buf);
649 return buf.extractChars();
650 }
651
652 bool isintegral()
653 {
654 return false;
655 }
656
657 // real, imaginary, or complex
658 bool isfloating()
659 {
660 return false;
661 }
662
663 bool isreal()
664 {
665 return false;
666 }
667
668 bool isimaginary()
669 {
670 return false;
671 }
672
673 bool iscomplex()
674 {
675 return false;
676 }
677
678 bool isscalar()
679 {
680 return false;
681 }
682
683 bool isunsigned()
684 {
685 return false;
686 }
687
688 bool isscope()
689 {
690 return false;
691 }
692
693 bool isString()
694 {
695 return false;
696 }
697
698 /**************************
699 * When T is mutable,
700 * Given:
701 * T a, b;
702 * Can we bitwise assign:
703 * a = b;
704 * ?
705 */
706 bool isAssignable()
707 {
708 return true;
709 }
710
711 /**************************
712 * Returns true if T can be converted to boolean value.
713 */
714 bool isBoolean()
715 {
716 return isscalar();
717 }
718
719 final bool isConst() const nothrow pure @nogc @safe
720 {
721 return (mod & MODFlags.const_) != 0;
722 }
723
724 final bool isImmutable() const nothrow pure @nogc @safe
725 {
726 return (mod & MODFlags.immutable_) != 0;
727 }
728
729 final bool isMutable() const nothrow pure @nogc @safe
730 {
731 return (mod & (MODFlags.const_ | MODFlags.immutable_ | MODFlags.wild)) == 0;
732 }
733
734 final bool isShared() const nothrow pure @nogc @safe
735 {
736 return (mod & MODFlags.shared_) != 0;
737 }
738
739 final bool isSharedConst() const nothrow pure @nogc @safe
740 {
741 return (mod & (MODFlags.shared_ | MODFlags.const_)) == (MODFlags.shared_ | MODFlags.const_);
742 }
743
744 final bool isWild() const nothrow pure @nogc @safe
745 {
746 return (mod & MODFlags.wild) != 0;
747 }
748
749 final bool isWildConst() const nothrow pure @nogc @safe
750 {
751 return (mod & MODFlags.wildconst) == MODFlags.wildconst;
752 }
753
754 final bool isSharedWild() const nothrow pure @nogc @safe
755 {
756 return (mod & (MODFlags.shared_ | MODFlags.wild)) == (MODFlags.shared_ | MODFlags.wild);
757 }
758
759 final bool isNaked() const nothrow pure @nogc @safe
760 {
761 return mod == 0;
762 }
763
764 /********************************
765 * Return a copy of this type with all attributes null-initialized.
766 * Useful for creating a type with different modifiers.
767 */
768 final Type nullAttributes() nothrow const
769 {
770 uint sz = sizeTy[ty];
771 Type t = cast(Type)mem.xmalloc(sz);
772 memcpy(cast(void*)t, cast(void*)this, sz);
773 // t.mod = NULL; // leave mod unchanged
774 t.deco = null;
775 t.arrayof = null;
776 t.pto = null;
777 t.rto = null;
778 t.vtinfo = null;
779 t.ctype = null;
780 t.mcache = null;
781 if (t.ty == Tstruct)
782 (cast(TypeStruct)t).att = AliasThisRec.fwdref;
783 if (t.ty == Tclass)
784 (cast(TypeClass)t).att = AliasThisRec.fwdref;
785 return t;
786 }
787
788 /**********************************
789 * For our new type 'this', which is type-constructed from t,
790 * fill in the cto, ito, sto, scto, wto shortcuts.
791 */
792 extern (D) final void fixTo(Type t)
793 {
794 // If fixing this: immutable(T*) by t: immutable(T)*,
795 // cache t to this.xto won't break transitivity.
796 Type mto = null;
797 Type tn = nextOf();
798 if (!tn || ty != Tsarray && tn.mod == t.nextOf().mod)
799 {
800 switch (t.mod)
801 {
802 case 0:
803 mto = t;
804 break;
805
806 case MODFlags.const_:
807 getMcache();
808 mcache.cto = t;
809 break;
810
811 case MODFlags.wild:
812 getMcache();
813 mcache.wto = t;
814 break;
815
816 case MODFlags.wildconst:
817 getMcache();
818 mcache.wcto = t;
819 break;
820
821 case MODFlags.shared_:
822 getMcache();
823 mcache.sto = t;
824 break;
825
826 case MODFlags.shared_ | MODFlags.const_:
827 getMcache();
828 mcache.scto = t;
829 break;
830
831 case MODFlags.shared_ | MODFlags.wild:
832 getMcache();
833 mcache.swto = t;
834 break;
835
836 case MODFlags.shared_ | MODFlags.wildconst:
837 getMcache();
838 mcache.swcto = t;
839 break;
840
841 case MODFlags.immutable_:
842 getMcache();
843 mcache.ito = t;
844 break;
845
846 default:
847 break;
848 }
849 }
850 assert(mod != t.mod);
851
852 if (mod)
853 {
854 getMcache();
855 t.getMcache();
856 }
857 switch (mod)
858 {
859 case 0:
860 break;
861
862 case MODFlags.const_:
863 mcache.cto = mto;
864 t.mcache.cto = this;
865 break;
866
867 case MODFlags.wild:
868 mcache.wto = mto;
869 t.mcache.wto = this;
870 break;
871
872 case MODFlags.wildconst:
873 mcache.wcto = mto;
874 t.mcache.wcto = this;
875 break;
876
877 case MODFlags.shared_:
878 mcache.sto = mto;
879 t.mcache.sto = this;
880 break;
881
882 case MODFlags.shared_ | MODFlags.const_:
883 mcache.scto = mto;
884 t.mcache.scto = this;
885 break;
886
887 case MODFlags.shared_ | MODFlags.wild:
888 mcache.swto = mto;
889 t.mcache.swto = this;
890 break;
891
892 case MODFlags.shared_ | MODFlags.wildconst:
893 mcache.swcto = mto;
894 t.mcache.swcto = this;
895 break;
896
897 case MODFlags.immutable_:
898 t.mcache.ito = this;
899 if (t.mcache.cto)
900 t.mcache.cto.getMcache().ito = this;
901 if (t.mcache.sto)
902 t.mcache.sto.getMcache().ito = this;
903 if (t.mcache.scto)
904 t.mcache.scto.getMcache().ito = this;
905 if (t.mcache.wto)
906 t.mcache.wto.getMcache().ito = this;
907 if (t.mcache.wcto)
908 t.mcache.wcto.getMcache().ito = this;
909 if (t.mcache.swto)
910 t.mcache.swto.getMcache().ito = this;
911 if (t.mcache.swcto)
912 t.mcache.swcto.getMcache().ito = this;
913 break;
914
915 default:
916 assert(0);
917 }
918
919 check();
920 t.check();
921 //printf("fixTo: %s, %s\n", toChars(), t.toChars());
922 }
923
924 /***************************
925 * Look for bugs in constructing types.
926 */
927 extern (D) final void check()
928 {
929 if (mcache)
930 with (mcache)
931 switch (mod)
932 {
933 case 0:
934 if (cto)
935 assert(cto.mod == MODFlags.const_);
936 if (ito)
937 assert(ito.mod == MODFlags.immutable_);
938 if (sto)
939 assert(sto.mod == MODFlags.shared_);
940 if (scto)
941 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_));
942 if (wto)
943 assert(wto.mod == MODFlags.wild);
944 if (wcto)
945 assert(wcto.mod == MODFlags.wildconst);
946 if (swto)
947 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild));
948 if (swcto)
949 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst));
950 break;
951
952 case MODFlags.const_:
953 if (cto)
954 assert(cto.mod == 0);
955 if (ito)
956 assert(ito.mod == MODFlags.immutable_);
957 if (sto)
958 assert(sto.mod == MODFlags.shared_);
959 if (scto)
960 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_));
961 if (wto)
962 assert(wto.mod == MODFlags.wild);
963 if (wcto)
964 assert(wcto.mod == MODFlags.wildconst);
965 if (swto)
966 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild));
967 if (swcto)
968 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst));
969 break;
970
971 case MODFlags.wild:
972 if (cto)
973 assert(cto.mod == MODFlags.const_);
974 if (ito)
975 assert(ito.mod == MODFlags.immutable_);
976 if (sto)
977 assert(sto.mod == MODFlags.shared_);
978 if (scto)
979 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_));
980 if (wto)
981 assert(wto.mod == 0);
982 if (wcto)
983 assert(wcto.mod == MODFlags.wildconst);
984 if (swto)
985 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild));
986 if (swcto)
987 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst));
988 break;
989
990 case MODFlags.wildconst:
991 assert(!cto || cto.mod == MODFlags.const_);
992 assert(!ito || ito.mod == MODFlags.immutable_);
993 assert(!sto || sto.mod == MODFlags.shared_);
994 assert(!scto || scto.mod == (MODFlags.shared_ | MODFlags.const_));
995 assert(!wto || wto.mod == MODFlags.wild);
996 assert(!wcto || wcto.mod == 0);
997 assert(!swto || swto.mod == (MODFlags.shared_ | MODFlags.wild));
998 assert(!swcto || swcto.mod == (MODFlags.shared_ | MODFlags.wildconst));
999 break;
1000
1001 case MODFlags.shared_:
1002 if (cto)
1003 assert(cto.mod == MODFlags.const_);
1004 if (ito)
1005 assert(ito.mod == MODFlags.immutable_);
1006 if (sto)
1007 assert(sto.mod == 0);
1008 if (scto)
1009 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_));
1010 if (wto)
1011 assert(wto.mod == MODFlags.wild);
1012 if (wcto)
1013 assert(wcto.mod == MODFlags.wildconst);
1014 if (swto)
1015 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild));
1016 if (swcto)
1017 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst));
1018 break;
1019
1020 case MODFlags.shared_ | MODFlags.const_:
1021 if (cto)
1022 assert(cto.mod == MODFlags.const_);
1023 if (ito)
1024 assert(ito.mod == MODFlags.immutable_);
1025 if (sto)
1026 assert(sto.mod == MODFlags.shared_);
1027 if (scto)
1028 assert(scto.mod == 0);
1029 if (wto)
1030 assert(wto.mod == MODFlags.wild);
1031 if (wcto)
1032 assert(wcto.mod == MODFlags.wildconst);
1033 if (swto)
1034 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild));
1035 if (swcto)
1036 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst));
1037 break;
1038
1039 case MODFlags.shared_ | MODFlags.wild:
1040 if (cto)
1041 assert(cto.mod == MODFlags.const_);
1042 if (ito)
1043 assert(ito.mod == MODFlags.immutable_);
1044 if (sto)
1045 assert(sto.mod == MODFlags.shared_);
1046 if (scto)
1047 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_));
1048 if (wto)
1049 assert(wto.mod == MODFlags.wild);
1050 if (wcto)
1051 assert(wcto.mod == MODFlags.wildconst);
1052 if (swto)
1053 assert(swto.mod == 0);
1054 if (swcto)
1055 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst));
1056 break;
1057
1058 case MODFlags.shared_ | MODFlags.wildconst:
1059 assert(!cto || cto.mod == MODFlags.const_);
1060 assert(!ito || ito.mod == MODFlags.immutable_);
1061 assert(!sto || sto.mod == MODFlags.shared_);
1062 assert(!scto || scto.mod == (MODFlags.shared_ | MODFlags.const_));
1063 assert(!wto || wto.mod == MODFlags.wild);
1064 assert(!wcto || wcto.mod == MODFlags.wildconst);
1065 assert(!swto || swto.mod == (MODFlags.shared_ | MODFlags.wild));
1066 assert(!swcto || swcto.mod == 0);
1067 break;
1068
1069 case MODFlags.immutable_:
1070 if (cto)
1071 assert(cto.mod == MODFlags.const_);
1072 if (ito)
1073 assert(ito.mod == 0);
1074 if (sto)
1075 assert(sto.mod == MODFlags.shared_);
1076 if (scto)
1077 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_));
1078 if (wto)
1079 assert(wto.mod == MODFlags.wild);
1080 if (wcto)
1081 assert(wcto.mod == MODFlags.wildconst);
1082 if (swto)
1083 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild));
1084 if (swcto)
1085 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst));
1086 break;
1087
1088 default:
1089 assert(0);
1090 }
1091
1092 Type tn = nextOf();
1093 if (tn && ty != Tfunction && tn.ty != Tfunction && ty != Tenum)
1094 {
1095 // Verify transitivity
1096 switch (mod)
1097 {
1098 case 0:
1099 case MODFlags.const_:
1100 case MODFlags.wild:
1101 case MODFlags.wildconst:
1102 case MODFlags.shared_:
1103 case MODFlags.shared_ | MODFlags.const_:
1104 case MODFlags.shared_ | MODFlags.wild:
1105 case MODFlags.shared_ | MODFlags.wildconst:
1106 case MODFlags.immutable_:
1107 assert(tn.mod == MODFlags.immutable_ || (tn.mod & mod) == mod);
1108 break;
1109
1110 default:
1111 assert(0);
1112 }
1113 tn.check();
1114 }
1115 }
1116
1117 /*************************************
1118 * Apply STCxxxx bits to existing type.
1119 * Use *before* semantic analysis is run.
1120 */
1121 extern (D) final Type addSTC(StorageClass stc)
1122 {
1123 Type t = this;
1124 if (t.isImmutable())
1125 {
1126 }
1127 else if (stc & STC.immutable_)
1128 {
1129 t = t.makeImmutable();
1130 }
1131 else
1132 {
1133 if ((stc & STC.shared_) && !t.isShared())
1134 {
1135 if (t.isWild())
1136 {
1137 if (t.isConst())
1138 t = t.makeSharedWildConst();
1139 else
1140 t = t.makeSharedWild();
1141 }
1142 else
1143 {
1144 if (t.isConst())
1145 t = t.makeSharedConst();
1146 else
1147 t = t.makeShared();
1148 }
1149 }
1150 if ((stc & STC.const_) && !t.isConst())
1151 {
1152 if (t.isShared())
1153 {
1154 if (t.isWild())
1155 t = t.makeSharedWildConst();
1156 else
1157 t = t.makeSharedConst();
1158 }
1159 else
1160 {
1161 if (t.isWild())
1162 t = t.makeWildConst();
1163 else
1164 t = t.makeConst();
1165 }
1166 }
1167 if ((stc & STC.wild) && !t.isWild())
1168 {
1169 if (t.isShared())
1170 {
1171 if (t.isConst())
1172 t = t.makeSharedWildConst();
1173 else
1174 t = t.makeSharedWild();
1175 }
1176 else
1177 {
1178 if (t.isConst())
1179 t = t.makeWildConst();
1180 else
1181 t = t.makeWild();
1182 }
1183 }
1184 }
1185 return t;
1186 }
1187
1188 final bool hasDeprecatedAliasThis()
1189 {
1190 auto ad = isAggregate(this);
1191 return ad && ad.aliasthis && (ad.aliasthis.isDeprecated || ad.aliasthis.sym.isDeprecated);
1192 }
1193
1194 Type makeConst()
1195 {
1196 //printf("Type::makeConst() %p, %s\n", this, toChars());
1197 if (mcache && mcache.cto)
1198 return mcache.cto;
1199 Type t = this.nullAttributes();
1200 t.mod = MODFlags.const_;
1201 //printf("-Type::makeConst() %p, %s\n", t, toChars());
1202 return t;
1203 }
1204
1205 Type makeImmutable()
1206 {
1207 if (mcache && mcache.ito)
1208 return mcache.ito;
1209 Type t = this.nullAttributes();
1210 t.mod = MODFlags.immutable_;
1211 return t;
1212 }
1213
1214 Type makeShared()
1215 {
1216 if (mcache && mcache.sto)
1217 return mcache.sto;
1218 Type t = this.nullAttributes();
1219 t.mod = MODFlags.shared_;
1220 return t;
1221 }
1222
1223 Type makeSharedConst()
1224 {
1225 if (mcache && mcache.scto)
1226 return mcache.scto;
1227 Type t = this.nullAttributes();
1228 t.mod = MODFlags.shared_ | MODFlags.const_;
1229 return t;
1230 }
1231
1232 Type makeWild()
1233 {
1234 if (mcache && mcache.wto)
1235 return mcache.wto;
1236 Type t = this.nullAttributes();
1237 t.mod = MODFlags.wild;
1238 return t;
1239 }
1240
1241 Type makeWildConst()
1242 {
1243 if (mcache && mcache.wcto)
1244 return mcache.wcto;
1245 Type t = this.nullAttributes();
1246 t.mod = MODFlags.wildconst;
1247 return t;
1248 }
1249
1250 Type makeSharedWild()
1251 {
1252 if (mcache && mcache.swto)
1253 return mcache.swto;
1254 Type t = this.nullAttributes();
1255 t.mod = MODFlags.shared_ | MODFlags.wild;
1256 return t;
1257 }
1258
1259 Type makeSharedWildConst()
1260 {
1261 if (mcache && mcache.swcto)
1262 return mcache.swcto;
1263 Type t = this.nullAttributes();
1264 t.mod = MODFlags.shared_ | MODFlags.wildconst;
1265 return t;
1266 }
1267
1268 Type makeMutable()
1269 {
1270 Type t = this.nullAttributes();
1271 t.mod = mod & MODFlags.shared_;
1272 return t;
1273 }
1274
1275 /*******************************
1276 * If this is a shell around another type,
1277 * get that other type.
1278 */
1279 final Type toBasetype()
1280 {
1281 /* This function is used heavily.
1282 * De-virtualize it so it can be easily inlined.
1283 */
1284 TypeEnum te;
1285 return ((te = isTypeEnum()) !is null) ? te.toBasetype2() : this;
1286 }
1287
1288 /********************************
1289 * Determine if 'this' can be implicitly converted
1290 * to type 'to'.
1291 * Returns:
1292 * MATCH.nomatch, MATCH.convert, MATCH.constant, MATCH.exact
1293 */
1294 MATCH implicitConvTo(Type to)
1295 {
1296 //printf("Type::implicitConvTo(this=%p, to=%p)\n", this, to);
1297 //printf("from: %s\n", toChars());
1298 //printf("to : %s\n", to.toChars());
1299 if (this.equals(to))
1300 return MATCH.exact;
1301 return MATCH.nomatch;
1302 }
1303
1304 /*******************************
1305 * Determine if converting 'this' to 'to' is an identity operation,
1306 * a conversion to const operation, or the types aren't the same.
1307 * Returns:
1308 * MATCH.exact 'this' == 'to'
1309 * MATCH.constant 'to' is const
1310 * MATCH.nomatch conversion to mutable or invariant
1311 */
1312 MATCH constConv(Type to)
1313 {
1314 //printf("Type::constConv(this = %s, to = %s)\n", toChars(), to.toChars());
1315 if (equals(to))
1316 return MATCH.exact;
1317 if (ty == to.ty && MODimplicitConv(mod, to.mod))
1318 return MATCH.constant;
1319 return MATCH.nomatch;
1320 }
1321
1322 /***************************************
1323 * Compute MOD bits matching `this` argument type to wild parameter type.
1324 * Params:
1325 * t = corresponding parameter type
1326 * isRef = parameter is `ref` or `out`
1327 * Returns:
1328 * MOD bits
1329 */
1330 MOD deduceWild(Type t, bool isRef)
1331 {
1332 //printf("Type::deduceWild this = '%s', tprm = '%s'\n", toChars(), tprm.toChars());
1333 if (t.isWild())
1334 {
1335 if (isImmutable())
1336 return MODFlags.immutable_;
1337 else if (isWildConst())
1338 {
1339 if (t.isWildConst())
1340 return MODFlags.wild;
1341 else
1342 return MODFlags.wildconst;
1343 }
1344 else if (isWild())
1345 return MODFlags.wild;
1346 else if (isConst())
1347 return MODFlags.const_;
1348 else if (isMutable())
1349 return MODFlags.mutable;
1350 else
1351 assert(0);
1352 }
1353 return 0;
1354 }
1355
1356 inout(ClassDeclaration) isClassHandle() inout
1357 {
1358 return null;
1359 }
1360
1361 /************************************
1362 * Return alignment to use for this type.
1363 */
1364 structalign_t alignment()
1365 {
1366 structalign_t s;
1367 s.setDefault();
1368 return s;
1369 }
1370
1371 /***************************************
1372 * Use when we prefer the default initializer to be a literal,
1373 * rather than a global immutable variable.
1374 */
1375 Expression defaultInitLiteral(const ref Loc loc)
1376 {
1377 static if (LOGDEFAULTINIT)
1378 {
1379 printf("Type::defaultInitLiteral() '%s'\n", toChars());
1380 }
1381 return defaultInit(this, loc);
1382 }
1383
1384 // if initializer is 0
1385 bool isZeroInit(const ref Loc loc)
1386 {
1387 return false; // assume not
1388 }
1389
1390 /***************************************
1391 * Return !=0 if the type or any of its subtypes is wild.
1392 */
1393 int hasWild() const
1394 {
1395 return mod & MODFlags.wild;
1396 }
1397
1398 /*************************************
1399 * Detect if type has pointer fields that are initialized to void.
1400 * Local stack variables with such void fields can remain uninitialized,
1401 * leading to pointer bugs.
1402 * Returns:
1403 * true if so
1404 */
1405 bool hasVoidInitPointers()
1406 {
1407 return false;
1408 }
1409
1410 /*************************************
1411 * Detect if this is an unsafe type because of the presence of `@system` members
1412 * Returns:
1413 * true if so
1414 */
1415 bool hasSystemFields()
1416 {
1417 return false;
1418 }
1419
1420 /***************************************
1421 * Returns: true if type has any invariants
1422 */
1423 bool hasInvariant()
1424 {
1425 //printf("Type::hasInvariant() %s, %d\n", toChars(), ty);
1426 return false;
1427 }
1428
1429 /*************************************
1430 * If this is a type of something, return that something.
1431 */
1432 Type nextOf()
1433 {
1434 return null;
1435 }
1436
1437 /*************************************
1438 * If this is a type of static array, return its base element type.
1439 */
1440 final Type baseElemOf()
1441 {
1442 Type t = toBasetype();
1443 TypeSArray tsa;
1444 while ((tsa = t.isTypeSArray()) !is null)
1445 t = tsa.next.toBasetype();
1446 return t;
1447 }
1448
1449 /*******************************************
1450 * Compute number of elements for a (possibly multidimensional) static array,
1451 * or 1 for other types.
1452 * Params:
1453 * loc = for error message
1454 * Returns:
1455 * number of elements, uint.max on overflow
1456 */
1457 final uint numberOfElems(const ref Loc loc)
1458 {
1459 //printf("Type::numberOfElems()\n");
1460 uinteger_t n = 1;
1461 Type tb = this;
1462 while ((tb = tb.toBasetype()).ty == Tsarray)
1463 {
1464 bool overflow = false;
1465 n = mulu(n, (cast(TypeSArray)tb).dim.toUInteger(), overflow);
1466 if (overflow || n >= uint.max)
1467 {
1468 error(loc, "static array `%s` size overflowed to %llu", toChars(), cast(ulong)n);
1469 return uint.max;
1470 }
1471 tb = (cast(TypeSArray)tb).next;
1472 }
1473 return cast(uint)n;
1474 }
1475
1476 /****************************************
1477 * Return the mask that an integral type will
1478 * fit into.
1479 */
1480 extern (D) final uinteger_t sizemask()
1481 {
1482 uinteger_t m;
1483 switch (toBasetype().ty)
1484 {
1485 case Tbool:
1486 m = 1;
1487 break;
1488 case Tchar:
1489 case Tint8:
1490 case Tuns8:
1491 m = 0xFF;
1492 break;
1493 case Twchar:
1494 case Tint16:
1495 case Tuns16:
1496 m = 0xFFFFU;
1497 break;
1498 case Tdchar:
1499 case Tint32:
1500 case Tuns32:
1501 m = 0xFFFFFFFFU;
1502 break;
1503 case Tint64:
1504 case Tuns64:
1505 m = 0xFFFFFFFFFFFFFFFFUL;
1506 break;
1507 default:
1508 assert(0);
1509 }
1510 return m;
1511 }
1512
1513 /********************************
1514 * true if when type goes out of scope, it needs a destructor applied.
1515 * Only applies to value types, not ref types.
1516 */
1517 bool needsDestruction()
1518 {
1519 return false;
1520 }
1521
1522 /********************************
1523 * true if when type is copied, it needs a copy constructor or postblit
1524 * applied. Only applies to value types, not ref types.
1525 */
1526 bool needsCopyOrPostblit()
1527 {
1528 return false;
1529 }
1530
1531 /*********************************
1532 *
1533 */
1534 bool needsNested()
1535 {
1536 return false;
1537 }
1538
1539 // For eliminating dynamic_cast
1540 TypeBasic isTypeBasic()
1541 {
1542 return null;
1543 }
1544
1545 final pure inout nothrow @nogc
1546 {
1547 /****************
1548 * Is this type a pointer to a function?
1549 * Returns:
1550 * the function type if it is
1551 */
1552 inout(TypeFunction) isPtrToFunction()
1553 {
1554 return (ty == Tpointer && (cast(TypePointer)this).next.ty == Tfunction)
1555 ? cast(typeof(return))(cast(TypePointer)this).next
1556 : null;
1557 }
1558
1559 /*****************
1560 * Is this type a function, delegate, or pointer to a function?
1561 * Returns:
1562 * the function type if it is
1563 */
1564 inout(TypeFunction) isFunction_Delegate_PtrToFunction()
1565 {
1566 return ty == Tfunction ? cast(typeof(return))this :
1567
1568 ty == Tdelegate ? cast(typeof(return))(cast(TypePointer)this).next :
1569
1570 ty == Tpointer && (cast(TypePointer)this).next.ty == Tfunction ?
1571 cast(typeof(return))(cast(TypePointer)this).next :
1572
1573 null;
1574 }
1575 }
1576
1577 final pure inout nothrow @nogc @safe
1578 {
1579 inout(TypeError) isTypeError() { return ty == Terror ? cast(typeof(return))this : null; }
1580 inout(TypeVector) isTypeVector() { return ty == Tvector ? cast(typeof(return))this : null; }
1581 inout(TypeSArray) isTypeSArray() { return ty == Tsarray ? cast(typeof(return))this : null; }
1582 inout(TypeDArray) isTypeDArray() { return ty == Tarray ? cast(typeof(return))this : null; }
1583 inout(TypeAArray) isTypeAArray() { return ty == Taarray ? cast(typeof(return))this : null; }
1584 inout(TypePointer) isTypePointer() { return ty == Tpointer ? cast(typeof(return))this : null; }
1585 inout(TypeReference) isTypeReference() { return ty == Treference ? cast(typeof(return))this : null; }
1586 inout(TypeFunction) isTypeFunction() { return ty == Tfunction ? cast(typeof(return))this : null; }
1587 inout(TypeDelegate) isTypeDelegate() { return ty == Tdelegate ? cast(typeof(return))this : null; }
1588 inout(TypeIdentifier) isTypeIdentifier() { return ty == Tident ? cast(typeof(return))this : null; }
1589 inout(TypeInstance) isTypeInstance() { return ty == Tinstance ? cast(typeof(return))this : null; }
1590 inout(TypeTypeof) isTypeTypeof() { return ty == Ttypeof ? cast(typeof(return))this : null; }
1591 inout(TypeReturn) isTypeReturn() { return ty == Treturn ? cast(typeof(return))this : null; }
1592 inout(TypeStruct) isTypeStruct() { return ty == Tstruct ? cast(typeof(return))this : null; }
1593 inout(TypeEnum) isTypeEnum() { return ty == Tenum ? cast(typeof(return))this : null; }
1594 inout(TypeClass) isTypeClass() { return ty == Tclass ? cast(typeof(return))this : null; }
1595 inout(TypeTuple) isTypeTuple() { return ty == Ttuple ? cast(typeof(return))this : null; }
1596 inout(TypeSlice) isTypeSlice() { return ty == Tslice ? cast(typeof(return))this : null; }
1597 inout(TypeNull) isTypeNull() { return ty == Tnull ? cast(typeof(return))this : null; }
1598 inout(TypeMixin) isTypeMixin() { return ty == Tmixin ? cast(typeof(return))this : null; }
1599 inout(TypeTraits) isTypeTraits() { return ty == Ttraits ? cast(typeof(return))this : null; }
1600 inout(TypeNoreturn) isTypeNoreturn() { return ty == Tnoreturn ? cast(typeof(return))this : null; }
1601 inout(TypeTag) isTypeTag() { return ty == Ttag ? cast(typeof(return))this : null; }
1602 }
1603
1604 override void accept(Visitor v)
1605 {
1606 v.visit(this);
1607 }
1608
1609 final TypeFunction toTypeFunction()
1610 {
1611 if (ty != Tfunction)
1612 assert(0);
1613 return cast(TypeFunction)this;
1614 }
1615
1616 extern (D) static Types* arraySyntaxCopy(Types* types)
1617 {
1618 Types* a = null;
1619 if (types)
1620 {
1621 a = new Types(types.length);
1622 foreach (i, t; *types)
1623 {
1624 (*a)[i] = t ? t.syntaxCopy() : null;
1625 }
1626 }
1627 return a;
1628 }
1629 }
1630
1631 /***********************************************************
1632 */
1633 extern (C++) final class TypeError : Type
1634 {
1635 extern (D) this() @safe
1636 {
1637 super(Terror);
1638 }
1639
1640 override const(char)* kind() const
1641 {
1642 return "error";
1643 }
1644
1645 override TypeError syntaxCopy()
1646 {
1647 // No semantic analysis done, no need to copy
1648 return this;
1649 }
1650
1651 override uinteger_t size(const ref Loc loc)
1652 {
1653 return SIZE_INVALID;
1654 }
1655
1656 override Expression defaultInitLiteral(const ref Loc loc)
1657 {
1658 return ErrorExp.get();
1659 }
1660
1661 override void accept(Visitor v)
1662 {
1663 v.visit(this);
1664 }
1665 }
1666
1667 /***********************************************************
1668 */
1669 extern (C++) abstract class TypeNext : Type
1670 {
1671 Type next;
1672
1673 final extern (D) this(TY ty, Type next) @safe
1674 {
1675 super(ty);
1676 this.next = next;
1677 }
1678
1679 override final int hasWild() const
1680 {
1681 if (ty == Tfunction)
1682 return 0;
1683 if (ty == Tdelegate)
1684 return Type.hasWild();
1685 return mod & MODFlags.wild || (next && next.hasWild());
1686 }
1687
1688 /*******************************
1689 * For TypeFunction, nextOf() can return NULL if the function return
1690 * type is meant to be inferred, and semantic() hasn't yet ben run
1691 * on the function. After semantic(), it must no longer be NULL.
1692 */
1693 override final Type nextOf()
1694 {
1695 return next;
1696 }
1697
1698 override final Type makeConst()
1699 {
1700 //printf("TypeNext::makeConst() %p, %s\n", this, toChars());
1701 if (mcache && mcache.cto)
1702 {
1703 assert(mcache.cto.mod == MODFlags.const_);
1704 return mcache.cto;
1705 }
1706 TypeNext t = cast(TypeNext)Type.makeConst();
1707 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable())
1708 {
1709 if (next.isShared())
1710 {
1711 if (next.isWild())
1712 t.next = next.sharedWildConstOf();
1713 else
1714 t.next = next.sharedConstOf();
1715 }
1716 else
1717 {
1718 if (next.isWild())
1719 t.next = next.wildConstOf();
1720 else
1721 t.next = next.constOf();
1722 }
1723 }
1724 //printf("TypeNext::makeConst() returns %p, %s\n", t, t.toChars());
1725 return t;
1726 }
1727
1728 override final Type makeImmutable()
1729 {
1730 //printf("TypeNext::makeImmutable() %s\n", toChars());
1731 if (mcache && mcache.ito)
1732 {
1733 assert(mcache.ito.isImmutable());
1734 return mcache.ito;
1735 }
1736 TypeNext t = cast(TypeNext)Type.makeImmutable();
1737 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable())
1738 {
1739 t.next = next.immutableOf();
1740 }
1741 return t;
1742 }
1743
1744 override final Type makeShared()
1745 {
1746 //printf("TypeNext::makeShared() %s\n", toChars());
1747 if (mcache && mcache.sto)
1748 {
1749 assert(mcache.sto.mod == MODFlags.shared_);
1750 return mcache.sto;
1751 }
1752 TypeNext t = cast(TypeNext)Type.makeShared();
1753 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable())
1754 {
1755 if (next.isWild())
1756 {
1757 if (next.isConst())
1758 t.next = next.sharedWildConstOf();
1759 else
1760 t.next = next.sharedWildOf();
1761 }
1762 else
1763 {
1764 if (next.isConst())
1765 t.next = next.sharedConstOf();
1766 else
1767 t.next = next.sharedOf();
1768 }
1769 }
1770 //printf("TypeNext::makeShared() returns %p, %s\n", t, t.toChars());
1771 return t;
1772 }
1773
1774 override final Type makeSharedConst()
1775 {
1776 //printf("TypeNext::makeSharedConst() %s\n", toChars());
1777 if (mcache && mcache.scto)
1778 {
1779 assert(mcache.scto.mod == (MODFlags.shared_ | MODFlags.const_));
1780 return mcache.scto;
1781 }
1782 TypeNext t = cast(TypeNext)Type.makeSharedConst();
1783 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable())
1784 {
1785 if (next.isWild())
1786 t.next = next.sharedWildConstOf();
1787 else
1788 t.next = next.sharedConstOf();
1789 }
1790 //printf("TypeNext::makeSharedConst() returns %p, %s\n", t, t.toChars());
1791 return t;
1792 }
1793
1794 override final Type makeWild()
1795 {
1796 //printf("TypeNext::makeWild() %s\n", toChars());
1797 if (mcache && mcache.wto)
1798 {
1799 assert(mcache.wto.mod == MODFlags.wild);
1800 return mcache.wto;
1801 }
1802 TypeNext t = cast(TypeNext)Type.makeWild();
1803 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable())
1804 {
1805 if (next.isShared())
1806 {
1807 if (next.isConst())
1808 t.next = next.sharedWildConstOf();
1809 else
1810 t.next = next.sharedWildOf();
1811 }
1812 else
1813 {
1814 if (next.isConst())
1815 t.next = next.wildConstOf();
1816 else
1817 t.next = next.wildOf();
1818 }
1819 }
1820 //printf("TypeNext::makeWild() returns %p, %s\n", t, t.toChars());
1821 return t;
1822 }
1823
1824 override final Type makeWildConst()
1825 {
1826 //printf("TypeNext::makeWildConst() %s\n", toChars());
1827 if (mcache && mcache.wcto)
1828 {
1829 assert(mcache.wcto.mod == MODFlags.wildconst);
1830 return mcache.wcto;
1831 }
1832 TypeNext t = cast(TypeNext)Type.makeWildConst();
1833 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable())
1834 {
1835 if (next.isShared())
1836 t.next = next.sharedWildConstOf();
1837 else
1838 t.next = next.wildConstOf();
1839 }
1840 //printf("TypeNext::makeWildConst() returns %p, %s\n", t, t.toChars());
1841 return t;
1842 }
1843
1844 override final Type makeSharedWild()
1845 {
1846 //printf("TypeNext::makeSharedWild() %s\n", toChars());
1847 if (mcache && mcache.swto)
1848 {
1849 assert(mcache.swto.isSharedWild());
1850 return mcache.swto;
1851 }
1852 TypeNext t = cast(TypeNext)Type.makeSharedWild();
1853 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable())
1854 {
1855 if (next.isConst())
1856 t.next = next.sharedWildConstOf();
1857 else
1858 t.next = next.sharedWildOf();
1859 }
1860 //printf("TypeNext::makeSharedWild() returns %p, %s\n", t, t.toChars());
1861 return t;
1862 }
1863
1864 override final Type makeSharedWildConst()
1865 {
1866 //printf("TypeNext::makeSharedWildConst() %s\n", toChars());
1867 if (mcache && mcache.swcto)
1868 {
1869 assert(mcache.swcto.mod == (MODFlags.shared_ | MODFlags.wildconst));
1870 return mcache.swcto;
1871 }
1872 TypeNext t = cast(TypeNext)Type.makeSharedWildConst();
1873 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable())
1874 {
1875 t.next = next.sharedWildConstOf();
1876 }
1877 //printf("TypeNext::makeSharedWildConst() returns %p, %s\n", t, t.toChars());
1878 return t;
1879 }
1880
1881 override final Type makeMutable()
1882 {
1883 //printf("TypeNext::makeMutable() %p, %s\n", this, toChars());
1884 TypeNext t = cast(TypeNext)Type.makeMutable();
1885 if (ty == Tsarray)
1886 {
1887 t.next = next.mutableOf();
1888 }
1889 //printf("TypeNext::makeMutable() returns %p, %s\n", t, t.toChars());
1890 return t;
1891 }
1892
1893 override MATCH constConv(Type to)
1894 {
1895 //printf("TypeNext::constConv from = %s, to = %s\n", toChars(), to.toChars());
1896 if (equals(to))
1897 return MATCH.exact;
1898
1899 if (!(ty == to.ty && MODimplicitConv(mod, to.mod)))
1900 return MATCH.nomatch;
1901
1902 Type tn = to.nextOf();
1903 if (!(tn && next.ty == tn.ty))
1904 return MATCH.nomatch;
1905
1906 MATCH m;
1907 if (to.isConst()) // whole tail const conversion
1908 {
1909 // Recursive shared level check
1910 m = next.constConv(tn);
1911 if (m == MATCH.exact)
1912 m = MATCH.constant;
1913 }
1914 else
1915 {
1916 //printf("\tnext => %s, to.next => %s\n", next.toChars(), tn.toChars());
1917 m = next.equals(tn) ? MATCH.constant : MATCH.nomatch;
1918 }
1919 return m;
1920 }
1921
1922 override final MOD deduceWild(Type t, bool isRef)
1923 {
1924 if (ty == Tfunction)
1925 return 0;
1926
1927 ubyte wm;
1928
1929 Type tn = t.nextOf();
1930 if (!isRef && (ty == Tarray || ty == Tpointer) && tn)
1931 {
1932 wm = next.deduceWild(tn, true);
1933 if (!wm)
1934 wm = Type.deduceWild(t, true);
1935 }
1936 else
1937 {
1938 wm = Type.deduceWild(t, isRef);
1939 if (!wm && tn)
1940 wm = next.deduceWild(tn, true);
1941 }
1942
1943 return wm;
1944 }
1945
1946 final void transitive()
1947 {
1948 /* Invoke transitivity of type attributes
1949 */
1950 next = next.addMod(mod);
1951 }
1952
1953 override void accept(Visitor v)
1954 {
1955 v.visit(this);
1956 }
1957 }
1958
1959 /***********************************************************
1960 */
1961 extern (C++) final class TypeBasic : Type
1962 {
1963 const(char)* dstring;
1964 uint flags;
1965
1966 extern (D) this(TY ty) scope
1967 {
1968 super(ty);
1969 const(char)* d;
1970 uint flags = 0;
1971 switch (ty)
1972 {
1973 case Tvoid:
1974 d = Token.toChars(TOK.void_);
1975 break;
1976
1977 case Tint8:
1978 d = Token.toChars(TOK.int8);
1979 flags |= TFlags.integral;
1980 break;
1981
1982 case Tuns8:
1983 d = Token.toChars(TOK.uns8);
1984 flags |= TFlags.integral | TFlags.unsigned;
1985 break;
1986
1987 case Tint16:
1988 d = Token.toChars(TOK.int16);
1989 flags |= TFlags.integral;
1990 break;
1991
1992 case Tuns16:
1993 d = Token.toChars(TOK.uns16);
1994 flags |= TFlags.integral | TFlags.unsigned;
1995 break;
1996
1997 case Tint32:
1998 d = Token.toChars(TOK.int32);
1999 flags |= TFlags.integral;
2000 break;
2001
2002 case Tuns32:
2003 d = Token.toChars(TOK.uns32);
2004 flags |= TFlags.integral | TFlags.unsigned;
2005 break;
2006
2007 case Tfloat32:
2008 d = Token.toChars(TOK.float32);
2009 flags |= TFlags.floating | TFlags.real_;
2010 break;
2011
2012 case Tint64:
2013 d = Token.toChars(TOK.int64);
2014 flags |= TFlags.integral;
2015 break;
2016
2017 case Tuns64:
2018 d = Token.toChars(TOK.uns64);
2019 flags |= TFlags.integral | TFlags.unsigned;
2020 break;
2021
2022 case Tint128:
2023 d = Token.toChars(TOK.int128);
2024 flags |= TFlags.integral;
2025 break;
2026
2027 case Tuns128:
2028 d = Token.toChars(TOK.uns128);
2029 flags |= TFlags.integral | TFlags.unsigned;
2030 break;
2031
2032 case Tfloat64:
2033 d = Token.toChars(TOK.float64);
2034 flags |= TFlags.floating | TFlags.real_;
2035 break;
2036
2037 case Tfloat80:
2038 d = Token.toChars(TOK.float80);
2039 flags |= TFlags.floating | TFlags.real_;
2040 break;
2041
2042 case Timaginary32:
2043 d = Token.toChars(TOK.imaginary32);
2044 flags |= TFlags.floating | TFlags.imaginary;
2045 break;
2046
2047 case Timaginary64:
2048 d = Token.toChars(TOK.imaginary64);
2049 flags |= TFlags.floating | TFlags.imaginary;
2050 break;
2051
2052 case Timaginary80:
2053 d = Token.toChars(TOK.imaginary80);
2054 flags |= TFlags.floating | TFlags.imaginary;
2055 break;
2056
2057 case Tcomplex32:
2058 d = Token.toChars(TOK.complex32);
2059 flags |= TFlags.floating | TFlags.complex;
2060 break;
2061
2062 case Tcomplex64:
2063 d = Token.toChars(TOK.complex64);
2064 flags |= TFlags.floating | TFlags.complex;
2065 break;
2066
2067 case Tcomplex80:
2068 d = Token.toChars(TOK.complex80);
2069 flags |= TFlags.floating | TFlags.complex;
2070 break;
2071
2072 case Tbool:
2073 d = "bool";
2074 flags |= TFlags.integral | TFlags.unsigned;
2075 break;
2076
2077 case Tchar:
2078 d = Token.toChars(TOK.char_);
2079 flags |= TFlags.integral | TFlags.unsigned;
2080 break;
2081
2082 case Twchar:
2083 d = Token.toChars(TOK.wchar_);
2084 flags |= TFlags.integral | TFlags.unsigned;
2085 break;
2086
2087 case Tdchar:
2088 d = Token.toChars(TOK.dchar_);
2089 flags |= TFlags.integral | TFlags.unsigned;
2090 break;
2091
2092 default:
2093 assert(0);
2094 }
2095 this.dstring = d;
2096 this.flags = flags;
2097 merge(this);
2098 }
2099
2100 override const(char)* kind() const
2101 {
2102 return dstring;
2103 }
2104
2105 override TypeBasic syntaxCopy()
2106 {
2107 // No semantic analysis done on basic types, no need to copy
2108 return this;
2109 }
2110
2111 override uinteger_t size(const ref Loc loc)
2112 {
2113 uint size;
2114 //printf("TypeBasic::size()\n");
2115 switch (ty)
2116 {
2117 case Tint8:
2118 case Tuns8:
2119 size = 1;
2120 break;
2121
2122 case Tint16:
2123 case Tuns16:
2124 size = 2;
2125 break;
2126
2127 case Tint32:
2128 case Tuns32:
2129 case Tfloat32:
2130 case Timaginary32:
2131 size = 4;
2132 break;
2133
2134 case Tint64:
2135 case Tuns64:
2136 case Tfloat64:
2137 case Timaginary64:
2138 size = 8;
2139 break;
2140
2141 case Tfloat80:
2142 case Timaginary80:
2143 size = target.realsize;
2144 break;
2145
2146 case Tcomplex32:
2147 size = 8;
2148 break;
2149
2150 case Tcomplex64:
2151 case Tint128:
2152 case Tuns128:
2153 size = 16;
2154 break;
2155
2156 case Tcomplex80:
2157 size = target.realsize * 2;
2158 break;
2159
2160 case Tvoid:
2161 //size = Type::size(); // error message
2162 size = 1;
2163 break;
2164
2165 case Tbool:
2166 size = 1;
2167 break;
2168
2169 case Tchar:
2170 size = 1;
2171 break;
2172
2173 case Twchar:
2174 size = 2;
2175 break;
2176
2177 case Tdchar:
2178 size = 4;
2179 break;
2180
2181 default:
2182 assert(0);
2183 }
2184 //printf("TypeBasic::size() = %d\n", size);
2185 return size;
2186 }
2187
2188 override uint alignsize()
2189 {
2190 return target.alignsize(this);
2191 }
2192
2193 override bool isintegral()
2194 {
2195 //printf("TypeBasic::isintegral('%s') x%x\n", toChars(), flags);
2196 return (flags & TFlags.integral) != 0;
2197 }
2198
2199 override bool isfloating()
2200 {
2201 return (flags & TFlags.floating) != 0;
2202 }
2203
2204 override bool isreal()
2205 {
2206 return (flags & TFlags.real_) != 0;
2207 }
2208
2209 override bool isimaginary()
2210 {
2211 return (flags & TFlags.imaginary) != 0;
2212 }
2213
2214 override bool iscomplex()
2215 {
2216 return (flags & TFlags.complex) != 0;
2217 }
2218
2219 override bool isscalar()
2220 {
2221 return (flags & (TFlags.integral | TFlags.floating)) != 0;
2222 }
2223
2224 override bool isunsigned()
2225 {
2226 return (flags & TFlags.unsigned) != 0;
2227 }
2228
2229 override MATCH implicitConvTo(Type to)
2230 {
2231 //printf("TypeBasic::implicitConvTo(%s) from %s\n", to.toChars(), toChars());
2232 if (this == to)
2233 return MATCH.exact;
2234
2235 if (ty == to.ty)
2236 {
2237 if (mod == to.mod)
2238 return MATCH.exact;
2239 else if (MODimplicitConv(mod, to.mod))
2240 return MATCH.constant;
2241 else if (!((mod ^ to.mod) & MODFlags.shared_)) // for wild matching
2242 return MATCH.constant;
2243 else
2244 return MATCH.convert;
2245 }
2246
2247 if (ty == Tvoid || to.ty == Tvoid)
2248 return MATCH.nomatch;
2249 if (to.ty == Tbool)
2250 return MATCH.nomatch;
2251
2252 TypeBasic tob;
2253 if (to.ty == Tvector && to.deco)
2254 {
2255 TypeVector tv = cast(TypeVector)to;
2256 tob = tv.elementType();
2257 }
2258 else if (auto te = to.isTypeEnum())
2259 {
2260 EnumDeclaration ed = te.sym;
2261 if (ed.isSpecial())
2262 {
2263 /* Special enums that allow implicit conversions to them
2264 * with a MATCH.convert
2265 */
2266 tob = to.toBasetype().isTypeBasic();
2267 }
2268 else
2269 return MATCH.nomatch;
2270 }
2271 else
2272 tob = to.isTypeBasic();
2273 if (!tob)
2274 return MATCH.nomatch;
2275
2276 if (flags & TFlags.integral)
2277 {
2278 // Disallow implicit conversion of integers to imaginary or complex
2279 if (tob.flags & (TFlags.imaginary | TFlags.complex))
2280 return MATCH.nomatch;
2281
2282 // If converting from integral to integral
2283 if (tob.flags & TFlags.integral)
2284 {
2285 const sz = size(Loc.initial);
2286 const tosz = tob.size(Loc.initial);
2287
2288 /* Can't convert to smaller size
2289 */
2290 if (sz > tosz)
2291 return MATCH.nomatch;
2292 /* Can't change sign if same size
2293 */
2294 //if (sz == tosz && (flags ^ tob.flags) & TFlags.unsigned)
2295 // return MATCH.nomatch;
2296 }
2297 }
2298 else if (flags & TFlags.floating)
2299 {
2300 // Disallow implicit conversion of floating point to integer
2301 if (tob.flags & TFlags.integral)
2302 return MATCH.nomatch;
2303
2304 assert(tob.flags & TFlags.floating || to.ty == Tvector);
2305
2306 // Disallow implicit conversion from complex to non-complex
2307 if (flags & TFlags.complex && !(tob.flags & TFlags.complex))
2308 return MATCH.nomatch;
2309
2310 // Disallow implicit conversion of real or imaginary to complex
2311 if (flags & (TFlags.real_ | TFlags.imaginary) && tob.flags & TFlags.complex)
2312 return MATCH.nomatch;
2313
2314 // Disallow implicit conversion to-from real and imaginary
2315 if ((flags & (TFlags.real_ | TFlags.imaginary)) != (tob.flags & (TFlags.real_ | TFlags.imaginary)))
2316 return MATCH.nomatch;
2317 }
2318 return MATCH.convert;
2319 }
2320
2321 override bool isZeroInit(const ref Loc loc)
2322 {
2323 switch (ty)
2324 {
2325 case Tchar:
2326 case Twchar:
2327 case Tdchar:
2328 case Timaginary32:
2329 case Timaginary64:
2330 case Timaginary80:
2331 case Tfloat32:
2332 case Tfloat64:
2333 case Tfloat80:
2334 case Tcomplex32:
2335 case Tcomplex64:
2336 case Tcomplex80:
2337 return false; // no
2338 default:
2339 return true; // yes
2340 }
2341 }
2342
2343 // For eliminating dynamic_cast
2344 override TypeBasic isTypeBasic()
2345 {
2346 return this;
2347 }
2348
2349 override void accept(Visitor v)
2350 {
2351 v.visit(this);
2352 }
2353 }
2354
2355 /***********************************************************
2356 * The basetype must be one of:
2357 * byte[16],ubyte[16],short[8],ushort[8],int[4],uint[4],long[2],ulong[2],float[4],double[2]
2358 * For AVX:
2359 * byte[32],ubyte[32],short[16],ushort[16],int[8],uint[8],long[4],ulong[4],float[8],double[4]
2360 */
2361 extern (C++) final class TypeVector : Type
2362 {
2363 Type basetype;
2364
2365 extern (D) this(Type basetype) @safe
2366 {
2367 super(Tvector);
2368 this.basetype = basetype;
2369 }
2370
2371 static TypeVector create(Type basetype) @safe
2372 {
2373 return new TypeVector(basetype);
2374 }
2375
2376 override const(char)* kind() const
2377 {
2378 return "vector";
2379 }
2380
2381 override TypeVector syntaxCopy()
2382 {
2383 return new TypeVector(basetype.syntaxCopy());
2384 }
2385
2386 override uinteger_t size(const ref Loc loc)
2387 {
2388 return basetype.size();
2389 }
2390
2391 override uint alignsize()
2392 {
2393 return cast(uint)basetype.size();
2394 }
2395
2396 override bool isintegral()
2397 {
2398 //printf("TypeVector::isintegral('%s') x%x\n", toChars(), flags);
2399 return basetype.nextOf().isintegral();
2400 }
2401
2402 override bool isfloating()
2403 {
2404 return basetype.nextOf().isfloating();
2405 }
2406
2407 override bool isscalar()
2408 {
2409 return basetype.nextOf().isscalar();
2410 }
2411
2412 override bool isunsigned()
2413 {
2414 return basetype.nextOf().isunsigned();
2415 }
2416
2417 override bool isBoolean()
2418 {
2419 return false;
2420 }
2421
2422 override MATCH implicitConvTo(Type to)
2423 {
2424 //printf("TypeVector::implicitConvTo(%s) from %s\n", to.toChars(), toChars());
2425 if (this == to)
2426 return MATCH.exact;
2427 if (to.ty != Tvector)
2428 return MATCH.nomatch;
2429
2430 TypeVector tv = cast(TypeVector)to;
2431 assert(basetype.ty == Tsarray && tv.basetype.ty == Tsarray);
2432
2433 // Can't convert to a vector which has different size.
2434 if (basetype.size() != tv.basetype.size())
2435 return MATCH.nomatch;
2436
2437 // Allow conversion to void[]
2438 if (tv.basetype.nextOf().ty == Tvoid)
2439 return MATCH.convert;
2440
2441 // Otherwise implicitly convertible only if basetypes are.
2442 return basetype.implicitConvTo(tv.basetype);
2443 }
2444
2445 override Expression defaultInitLiteral(const ref Loc loc)
2446 {
2447 //printf("TypeVector::defaultInitLiteral()\n");
2448 assert(basetype.ty == Tsarray);
2449 Expression e = basetype.defaultInitLiteral(loc);
2450 auto ve = new VectorExp(loc, e, this);
2451 ve.type = this;
2452 ve.dim = cast(int)(basetype.size(loc) / elementType().size(loc));
2453 return ve;
2454 }
2455
2456 TypeBasic elementType()
2457 {
2458 assert(basetype.ty == Tsarray);
2459 TypeSArray t = cast(TypeSArray)basetype;
2460 TypeBasic tb = t.nextOf().isTypeBasic();
2461 assert(tb);
2462 return tb;
2463 }
2464
2465 override bool isZeroInit(const ref Loc loc)
2466 {
2467 return basetype.isZeroInit(loc);
2468 }
2469
2470 override void accept(Visitor v)
2471 {
2472 v.visit(this);
2473 }
2474 }
2475
2476 /***********************************************************
2477 */
2478 extern (C++) abstract class TypeArray : TypeNext
2479 {
2480 final extern (D) this(TY ty, Type next) @safe
2481 {
2482 super(ty, next);
2483 }
2484
2485 override void accept(Visitor v)
2486 {
2487 v.visit(this);
2488 }
2489 }
2490
2491 /***********************************************************
2492 * Static array, one with a fixed dimension
2493 */
2494 extern (C++) final class TypeSArray : TypeArray
2495 {
2496 Expression dim;
2497
2498 extern (D) this(Type t, Expression dim) @safe
2499 {
2500 super(Tsarray, t);
2501 //printf("TypeSArray(%s)\n", dim.toChars());
2502 this.dim = dim;
2503 }
2504
2505 extern (D) this(Type t) // for incomplete type
2506 {
2507 super(Tsarray, t);
2508 //printf("TypeSArray()\n");
2509 this.dim = new IntegerExp(0);
2510 }
2511
2512 override const(char)* kind() const
2513 {
2514 return "sarray";
2515 }
2516
2517 override TypeSArray syntaxCopy()
2518 {
2519 Type t = next.syntaxCopy();
2520 Expression e = dim.syntaxCopy();
2521 auto result = new TypeSArray(t, e);
2522 result.mod = mod;
2523 return result;
2524 }
2525
2526 /***
2527 * C11 6.7.6.2-4 incomplete array type
2528 * Returns: true if incomplete type
2529 */
2530 bool isIncomplete()
2531 {
2532 return dim.isIntegerExp() && dim.isIntegerExp().getInteger() == 0;
2533 }
2534
2535 override uinteger_t size(const ref Loc loc)
2536 {
2537 //printf("TypeSArray::size()\n");
2538 const n = numberOfElems(loc);
2539 const elemsize = baseElemOf().size(loc);
2540 bool overflow = false;
2541 const sz = mulu(n, elemsize, overflow);
2542 if (overflow || sz >= uint.max)
2543 {
2544 if (elemsize != SIZE_INVALID && n != uint.max)
2545 error(loc, "static array `%s` size overflowed to %lld", toChars(), cast(long)sz);
2546 return SIZE_INVALID;
2547 }
2548 return sz;
2549 }
2550
2551 override uint alignsize()
2552 {
2553 return next.alignsize();
2554 }
2555
2556 override bool isString()
2557 {
2558 TY nty = next.toBasetype().ty;
2559 return nty.isSomeChar;
2560 }
2561
2562 override bool isZeroInit(const ref Loc loc)
2563 {
2564 return next.isZeroInit(loc);
2565 }
2566
2567 override structalign_t alignment()
2568 {
2569 return next.alignment();
2570 }
2571
2572 override MATCH constConv(Type to)
2573 {
2574 if (auto tsa = to.isTypeSArray())
2575 {
2576 if (!dim.equals(tsa.dim))
2577 return MATCH.nomatch;
2578 }
2579 return TypeNext.constConv(to);
2580 }
2581
2582 override MATCH implicitConvTo(Type to)
2583 {
2584 //printf("TypeSArray::implicitConvTo(to = %s) this = %s\n", to.toChars(), toChars());
2585 if (auto ta = to.isTypeDArray())
2586 {
2587 if (!MODimplicitConv(next.mod, ta.next.mod))
2588 return MATCH.nomatch;
2589
2590 /* Allow conversion to void[]
2591 */
2592 if (ta.next.ty == Tvoid)
2593 {
2594 return MATCH.convert;
2595 }
2596
2597 MATCH m = next.constConv(ta.next);
2598 if (m > MATCH.nomatch)
2599 {
2600 return MATCH.convert;
2601 }
2602 return MATCH.nomatch;
2603 }
2604 if (auto tsa = to.isTypeSArray())
2605 {
2606 if (this == to)
2607 return MATCH.exact;
2608
2609 if (dim.equals(tsa.dim))
2610 {
2611 MATCH m = next.implicitConvTo(tsa.next);
2612
2613 /* Allow conversion to non-interface base class.
2614 */
2615 if (m == MATCH.convert &&
2616 next.ty == Tclass)
2617 {
2618 if (auto toc = tsa.next.isTypeClass)
2619 {
2620 if (!toc.sym.isInterfaceDeclaration)
2621 return MATCH.convert;
2622 }
2623 }
2624
2625 /* Since static arrays are value types, allow
2626 * conversions from const elements to non-const
2627 * ones, just like we allow conversion from const int
2628 * to int.
2629 */
2630 if (m >= MATCH.constant)
2631 {
2632 if (mod != to.mod)
2633 m = MATCH.constant;
2634 return m;
2635 }
2636 }
2637 }
2638 return MATCH.nomatch;
2639 }
2640
2641 override Expression defaultInitLiteral(const ref Loc loc)
2642 {
2643 static if (LOGDEFAULTINIT)
2644 {
2645 printf("TypeSArray::defaultInitLiteral() '%s'\n", toChars());
2646 }
2647 size_t d = cast(size_t)dim.toInteger();
2648 Expression elementinit;
2649 if (next.ty == Tvoid)
2650 elementinit = tuns8.defaultInitLiteral(loc);
2651 else
2652 elementinit = next.defaultInitLiteral(loc);
2653 auto elements = new Expressions(d);
2654 foreach (ref e; *elements)
2655 e = null;
2656 auto ae = new ArrayLiteralExp(Loc.initial, this, elementinit, elements);
2657 return ae;
2658 }
2659
2660 override bool hasSystemFields()
2661 {
2662 return next.hasSystemFields();
2663 }
2664
2665 override bool hasVoidInitPointers()
2666 {
2667 return next.hasVoidInitPointers();
2668 }
2669
2670 override bool hasInvariant()
2671 {
2672 return next.hasInvariant();
2673 }
2674
2675 override bool needsDestruction()
2676 {
2677 return next.needsDestruction();
2678 }
2679
2680 override bool needsCopyOrPostblit()
2681 {
2682 return next.needsCopyOrPostblit();
2683 }
2684
2685 /*********************************
2686 *
2687 */
2688 override bool needsNested()
2689 {
2690 return next.needsNested();
2691 }
2692
2693 override void accept(Visitor v)
2694 {
2695 v.visit(this);
2696 }
2697 }
2698
2699 /***********************************************************
2700 * Dynamic array, no dimension
2701 */
2702 extern (C++) final class TypeDArray : TypeArray
2703 {
2704 extern (D) this(Type t) @safe
2705 {
2706 super(Tarray, t);
2707 //printf("TypeDArray(t = %p)\n", t);
2708 }
2709
2710 override const(char)* kind() const
2711 {
2712 return "darray";
2713 }
2714
2715 override TypeDArray syntaxCopy()
2716 {
2717 Type t = next.syntaxCopy();
2718 if (t == next)
2719 return this;
2720
2721 auto result = new TypeDArray(t);
2722 result.mod = mod;
2723 return result;
2724 }
2725
2726 override uinteger_t size(const ref Loc loc)
2727 {
2728 //printf("TypeDArray::size()\n");
2729 return target.ptrsize * 2;
2730 }
2731
2732 override uint alignsize()
2733 {
2734 // A DArray consists of two ptr-sized values, so align it on pointer size
2735 // boundary
2736 return target.ptrsize;
2737 }
2738
2739 override bool isString()
2740 {
2741 TY nty = next.toBasetype().ty;
2742 return nty.isSomeChar;
2743 }
2744
2745 override bool isZeroInit(const ref Loc loc)
2746 {
2747 return true;
2748 }
2749
2750 override bool isBoolean()
2751 {
2752 return true;
2753 }
2754
2755 override MATCH implicitConvTo(Type to)
2756 {
2757 //printf("TypeDArray::implicitConvTo(to = %s) this = %s\n", to.toChars(), toChars());
2758 if (equals(to))
2759 return MATCH.exact;
2760
2761 if (auto ta = to.isTypeDArray())
2762 {
2763 if (!MODimplicitConv(next.mod, ta.next.mod))
2764 return MATCH.nomatch; // not const-compatible
2765
2766 /* Allow conversion to void[]
2767 */
2768 if (next.ty != Tvoid && ta.next.ty == Tvoid)
2769 {
2770 return MATCH.convert;
2771 }
2772
2773 MATCH m = next.constConv(ta.next);
2774 if (m > MATCH.nomatch)
2775 {
2776 if (m == MATCH.exact && mod != to.mod)
2777 m = MATCH.constant;
2778 return m;
2779 }
2780 }
2781 return Type.implicitConvTo(to);
2782 }
2783
2784 override void accept(Visitor v)
2785 {
2786 v.visit(this);
2787 }
2788 }
2789
2790 /***********************************************************
2791 */
2792 extern (C++) final class TypeAArray : TypeArray
2793 {
2794 Type index; // key type
2795 Loc loc;
2796
2797 extern (D) this(Type t, Type index) @safe
2798 {
2799 super(Taarray, t);
2800 this.index = index;
2801 }
2802
2803 static TypeAArray create(Type t, Type index) @safe
2804 {
2805 return new TypeAArray(t, index);
2806 }
2807
2808 override const(char)* kind() const
2809 {
2810 return "aarray";
2811 }
2812
2813 override TypeAArray syntaxCopy()
2814 {
2815 Type t = next.syntaxCopy();
2816 Type ti = index.syntaxCopy();
2817 if (t == next && ti == index)
2818 return this;
2819
2820 auto result = new TypeAArray(t, ti);
2821 result.mod = mod;
2822 return result;
2823 }
2824
2825 override uinteger_t size(const ref Loc loc)
2826 {
2827 return target.ptrsize;
2828 }
2829
2830 override bool isZeroInit(const ref Loc loc)
2831 {
2832 return true;
2833 }
2834
2835 override bool isBoolean()
2836 {
2837 return true;
2838 }
2839
2840 override MATCH implicitConvTo(Type to)
2841 {
2842 //printf("TypeAArray::implicitConvTo(to = %s) this = %s\n", to.toChars(), toChars());
2843 if (equals(to))
2844 return MATCH.exact;
2845
2846 if (auto ta = to.isTypeAArray())
2847 {
2848 if (!MODimplicitConv(next.mod, ta.next.mod))
2849 return MATCH.nomatch; // not const-compatible
2850
2851 if (!MODimplicitConv(index.mod, ta.index.mod))
2852 return MATCH.nomatch; // not const-compatible
2853
2854 MATCH m = next.constConv(ta.next);
2855 MATCH mi = index.constConv(ta.index);
2856 if (m > MATCH.nomatch && mi > MATCH.nomatch)
2857 {
2858 return MODimplicitConv(mod, to.mod) ? MATCH.constant : MATCH.nomatch;
2859 }
2860 }
2861 return Type.implicitConvTo(to);
2862 }
2863
2864 override MATCH constConv(Type to)
2865 {
2866 if (auto taa = to.isTypeAArray())
2867 {
2868 MATCH mindex = index.constConv(taa.index);
2869 MATCH mkey = next.constConv(taa.next);
2870 // Pick the worst match
2871 return mkey < mindex ? mkey : mindex;
2872 }
2873 return Type.constConv(to);
2874 }
2875
2876 override void accept(Visitor v)
2877 {
2878 v.visit(this);
2879 }
2880 }
2881
2882 /***********************************************************
2883 */
2884 extern (C++) final class TypePointer : TypeNext
2885 {
2886 extern (D) this(Type t) @safe
2887 {
2888 super(Tpointer, t);
2889 }
2890
2891 static TypePointer create(Type t) @safe
2892 {
2893 return new TypePointer(t);
2894 }
2895
2896 override const(char)* kind() const
2897 {
2898 return "pointer";
2899 }
2900
2901 override TypePointer syntaxCopy()
2902 {
2903 Type t = next.syntaxCopy();
2904 if (t == next)
2905 return this;
2906
2907 auto result = new TypePointer(t);
2908 result.mod = mod;
2909 return result;
2910 }
2911
2912 override uinteger_t size(const ref Loc loc)
2913 {
2914 return target.ptrsize;
2915 }
2916
2917 override MATCH implicitConvTo(Type to)
2918 {
2919 //printf("TypePointer::implicitConvTo(to = %s) %s\n", to.toChars(), toChars());
2920 if (equals(to))
2921 return MATCH.exact;
2922
2923 // Only convert between pointers
2924 auto tp = to.isTypePointer();
2925 if (!tp)
2926 return MATCH.nomatch;
2927
2928 assert(this.next);
2929 assert(tp.next);
2930
2931 // Conversion to void*
2932 if (tp.next.ty == Tvoid)
2933 {
2934 // Function pointer conversion doesn't check constness?
2935 if (this.next.ty == Tfunction)
2936 return MATCH.convert;
2937
2938 if (!MODimplicitConv(next.mod, tp.next.mod))
2939 return MATCH.nomatch; // not const-compatible
2940
2941 return this.next.ty == Tvoid ? MATCH.constant : MATCH.convert;
2942 }
2943
2944 // Conversion between function pointers
2945 if (auto thisTf = this.next.isTypeFunction())
2946 return thisTf.implicitPointerConv(tp.next);
2947
2948 // Default, no implicit conversion between the pointer targets
2949 MATCH m = next.constConv(tp.next);
2950
2951 if (m == MATCH.exact && mod != to.mod)
2952 m = MATCH.constant;
2953 return m;
2954 }
2955
2956 override MATCH constConv(Type to)
2957 {
2958 if (next.ty == Tfunction)
2959 {
2960 if (to.nextOf() && next.equals((cast(TypeNext)to).next))
2961 return Type.constConv(to);
2962 else
2963 return MATCH.nomatch;
2964 }
2965 return TypeNext.constConv(to);
2966 }
2967
2968 override bool isscalar()
2969 {
2970 return true;
2971 }
2972
2973 override bool isZeroInit(const ref Loc loc)
2974 {
2975 return true;
2976 }
2977
2978 override void accept(Visitor v)
2979 {
2980 v.visit(this);
2981 }
2982 }
2983
2984 /***********************************************************
2985 */
2986 extern (C++) final class TypeReference : TypeNext
2987 {
2988 extern (D) this(Type t) @safe
2989 {
2990 super(Treference, t);
2991 // BUG: what about references to static arrays?
2992 }
2993
2994 override const(char)* kind() const
2995 {
2996 return "reference";
2997 }
2998
2999 override TypeReference syntaxCopy()
3000 {
3001 Type t = next.syntaxCopy();
3002 if (t == next)
3003 return this;
3004
3005 auto result = new TypeReference(t);
3006 result.mod = mod;
3007 return result;
3008 }
3009
3010 override uinteger_t size(const ref Loc loc)
3011 {
3012 return target.ptrsize;
3013 }
3014
3015 override bool isZeroInit(const ref Loc loc)
3016 {
3017 return true;
3018 }
3019
3020 override void accept(Visitor v)
3021 {
3022 v.visit(this);
3023 }
3024 }
3025
3026 enum RET : int
3027 {
3028 regs = 1, // returned in registers
3029 stack = 2, // returned on stack
3030 }
3031
3032 enum TRUSTformat : int
3033 {
3034 TRUSTformatDefault, // do not emit @system when trust == TRUST.default_
3035 TRUSTformatSystem, // emit @system when trust == TRUST.default_
3036 }
3037
3038 alias TRUSTformatDefault = TRUSTformat.TRUSTformatDefault;
3039 alias TRUSTformatSystem = TRUSTformat.TRUSTformatSystem;
3040
3041 /***********************************************************
3042 */
3043 extern (C++) final class TypeFunction : TypeNext
3044 {
3045 // .next is the return type
3046
3047 ParameterList parameterList; // function parameters
3048
3049 // These flags can be accessed like `bool` properties,
3050 // getters and setters are generated for them
3051 private extern (D) static struct BitFields
3052 {
3053 bool isnothrow; /// nothrow
3054 bool isnogc; /// is @nogc
3055 bool isproperty; /// can be called without parentheses
3056 bool isref; /// returns a reference
3057 bool isreturn; /// 'this' is returned by ref
3058 bool isScopeQual; /// 'this' is scope
3059 bool isreturninferred; /// 'this' is return from inference
3060 bool isscopeinferred; /// 'this' is scope from inference
3061 bool islive; /// is @live
3062 bool incomplete; /// return type or default arguments removed
3063 bool isInOutParam; /// inout on the parameters
3064 bool isInOutQual; /// inout on the qualifier
3065 bool isctor; /// the function is a constructor
3066 bool isreturnscope; /// `this` is returned by value
3067 }
3068
3069 import dmd.common.bitfields : generateBitFields;
3070 mixin(generateBitFields!(BitFields, ushort));
3071
3072 LINK linkage; // calling convention
3073 TRUST trust; // level of trust
3074 PURE purity = PURE.impure;
3075 byte inuse;
3076 Expressions* fargs; // function arguments
3077
3078 extern (D) this(ParameterList pl, Type treturn, LINK linkage, StorageClass stc = 0) @safe
3079 {
3080 super(Tfunction, treturn);
3081 //if (!treturn) *(char*)0=0;
3082 // assert(treturn);
3083 assert(VarArg.none <= pl.varargs && pl.varargs <= VarArg.max);
3084 this.parameterList = pl;
3085 this.linkage = linkage;
3086
3087 if (stc & STC.pure_)
3088 this.purity = PURE.fwdref;
3089 if (stc & STC.nothrow_)
3090 this.isnothrow = true;
3091 if (stc & STC.nogc)
3092 this.isnogc = true;
3093 if (stc & STC.property)
3094 this.isproperty = true;
3095 if (stc & STC.live)
3096 this.islive = true;
3097
3098 if (stc & STC.ref_)
3099 this.isref = true;
3100 if (stc & STC.return_)
3101 this.isreturn = true;
3102 if (stc & STC.returnScope)
3103 this.isreturnscope = true;
3104 if (stc & STC.returninferred)
3105 this.isreturninferred = true;
3106 if (stc & STC.scope_)
3107 this.isScopeQual = true;
3108 if (stc & STC.scopeinferred)
3109 this.isscopeinferred = true;
3110
3111 this.trust = TRUST.default_;
3112 if (stc & STC.safe)
3113 this.trust = TRUST.safe;
3114 else if (stc & STC.system)
3115 this.trust = TRUST.system;
3116 else if (stc & STC.trusted)
3117 this.trust = TRUST.trusted;
3118 }
3119
3120 static TypeFunction create(Parameters* parameters, Type treturn, ubyte varargs, LINK linkage, StorageClass stc = 0) @safe
3121 {
3122 return new TypeFunction(ParameterList(parameters, cast(VarArg)varargs), treturn, linkage, stc);
3123 }
3124
3125 override const(char)* kind() const
3126 {
3127 return "function";
3128 }
3129
3130 override TypeFunction syntaxCopy()
3131 {
3132 Type treturn = next ? next.syntaxCopy() : null;
3133 auto t = new TypeFunction(parameterList.syntaxCopy(), treturn, linkage);
3134 t.mod = mod;
3135 t.isnothrow = isnothrow;
3136 t.isnogc = isnogc;
3137 t.islive = islive;
3138 t.purity = purity;
3139 t.isproperty = isproperty;
3140 t.isref = isref;
3141 t.isreturn = isreturn;
3142 t.isreturnscope = isreturnscope;
3143 t.isScopeQual = isScopeQual;
3144 t.isreturninferred = isreturninferred;
3145 t.isscopeinferred = isscopeinferred;
3146 t.isInOutParam = isInOutParam;
3147 t.isInOutQual = isInOutQual;
3148 t.trust = trust;
3149 t.fargs = fargs;
3150 t.isctor = isctor;
3151 return t;
3152 }
3153
3154 /********************************************
3155 * Return true if there are lazy parameters.
3156 */
3157 bool hasLazyParameters()
3158 {
3159 foreach (i, fparam; parameterList)
3160 {
3161 if (fparam.isLazy())
3162 return true;
3163 }
3164 return false;
3165 }
3166
3167 /*******************************
3168 * Check for `extern (D) U func(T t, ...)` variadic function type,
3169 * which has `_arguments[]` added as the first argument.
3170 * Returns:
3171 * true if D-style variadic
3172 */
3173 bool isDstyleVariadic() const pure nothrow
3174 {
3175 return linkage == LINK.d && parameterList.varargs == VarArg.variadic;
3176 }
3177
3178 extern(D) static const(char)* getMatchError(A...)(const(char)* format, A args)
3179 {
3180 if (global.gag && !global.params.v.showGaggedErrors)
3181 return null;
3182 OutBuffer buf;
3183 buf.printf(format, args);
3184 return buf.extractChars();
3185 }
3186
3187 /********************************
3188 * Convert an `argumentList`, which may contain named arguments, into
3189 * a list of arguments in the order of the parameter list.
3190 *
3191 * Params:
3192 * argumentList = array of function arguments
3193 * pMessage = address to store error message, or `null`
3194 * Returns: re-ordered argument list, or `null` on error
3195 */
3196 extern(D) Expressions* resolveNamedArgs(ArgumentList argumentList, const(char)** pMessage)
3197 {
3198 Expression[] args = argumentList.arguments ? (*argumentList.arguments)[] : null;
3199 Identifier[] names = argumentList.names ? (*argumentList.names)[] : null;
3200 auto newArgs = new Expressions(parameterList.length);
3201 newArgs.zero();
3202 size_t ci = 0;
3203 bool hasNamedArgs = false;
3204 foreach (i, arg; args)
3205 {
3206 if (!arg)
3207 {
3208 ci++;
3209 continue;
3210 }
3211 auto name = i < names.length ? names[i] : null;
3212 if (name)
3213 {
3214 hasNamedArgs = true;
3215 const pi = findParameterIndex(name);
3216 if (pi == -1)
3217 {
3218 if (pMessage)
3219 *pMessage = getMatchError("no parameter named `%s`", name.toChars());
3220 return null;
3221 }
3222 ci = pi;
3223 }
3224 if (ci >= newArgs.length)
3225 {
3226 if (!parameterList.varargs)
3227 {
3228 // Without named args, let the caller diagnose argument overflow
3229 if (hasNamedArgs && pMessage)
3230 *pMessage = getMatchError("argument `%s` goes past end of parameter list", arg.toChars());
3231 return null;
3232 }
3233 while (ci >= newArgs.length)
3234 newArgs.push(null);
3235 }
3236
3237 if ((*newArgs)[ci])
3238 {
3239 if (pMessage)
3240 *pMessage = getMatchError("parameter `%s` assigned twice", parameterList[ci].toChars());
3241 return null;
3242 }
3243 (*newArgs)[ci++] = arg;
3244 }
3245 foreach (i, arg; (*newArgs)[])
3246 {
3247 if (arg || parameterList[i].defaultArg)
3248 continue;
3249
3250 if (parameterList.varargs != VarArg.none && i + 1 == newArgs.length)
3251 continue;
3252
3253 if (pMessage)
3254 *pMessage = getMatchError("missing argument for parameter #%d: `%s`",
3255 i + 1, parameterToChars(parameterList[i], this, false));
3256 return null;
3257 }
3258 // strip trailing nulls from default arguments
3259 size_t e = newArgs.length;
3260 while (e > 0 && (*newArgs)[e - 1] is null)
3261 {
3262 --e;
3263 }
3264 newArgs.setDim(e);
3265 return newArgs;
3266 }
3267
3268 /+
3269 + Checks whether this function type is convertible to ` to`
3270 + when used in a function pointer / delegate.
3271 +
3272 + Params:
3273 + to = target type
3274 +
3275 + Returns:
3276 + MATCH.nomatch: `to` is not a covaraint function
3277 + MATCH.convert: `to` is a covaraint function
3278 + MATCH.exact: `to` is identical to this function
3279 +/
3280 private MATCH implicitPointerConv(Type to)
3281 {
3282 assert(to);
3283
3284 if (this.equals(to))
3285 return MATCH.constant;
3286
3287 if (this.covariant(to) == Covariant.yes)
3288 {
3289 Type tret = this.nextOf();
3290 Type toret = to.nextOf();
3291 if (tret.ty == Tclass && toret.ty == Tclass)
3292 {
3293 /* https://issues.dlang.org/show_bug.cgi?id=10219
3294 * Check covariant interface return with offset tweaking.
3295 * interface I {}
3296 * class C : Object, I {}
3297 * I function() dg = function C() {} // should be error
3298 */
3299 int offset = 0;
3300 if (toret.isBaseOf(tret, &offset) && offset != 0)
3301 return MATCH.nomatch;
3302 }
3303 return MATCH.convert;
3304 }
3305
3306 return MATCH.nomatch;
3307 }
3308
3309 /** Extends TypeNext.constConv by also checking for matching attributes **/
3310 override MATCH constConv(Type to)
3311 {
3312 // Attributes need to match exactly, otherwise it's an implicit conversion
3313 if (this.ty != to.ty || !this.attributesEqual(cast(TypeFunction) to))
3314 return MATCH.nomatch;
3315
3316 return super.constConv(to);
3317 }
3318
3319 extern (D) bool checkRetType(const ref Loc loc)
3320 {
3321 Type tb = next.toBasetype();
3322 if (tb.ty == Tfunction)
3323 {
3324 error(loc, "functions cannot return a function");
3325 next = Type.terror;
3326 }
3327 if (tb.ty == Ttuple)
3328 {
3329 error(loc, "functions cannot return a sequence (use `std.typecons.Tuple`)");
3330 next = Type.terror;
3331 }
3332 if (!isref && (tb.ty == Tstruct || tb.ty == Tsarray))
3333 {
3334 if (auto ts = tb.baseElemOf().isTypeStruct())
3335 {
3336 if (!ts.sym.members)
3337 {
3338 error(loc, "functions cannot return opaque type `%s` by value", tb.toChars());
3339 next = Type.terror;
3340 }
3341 }
3342 }
3343 if (tb.ty == Terror)
3344 return true;
3345 return false;
3346 }
3347
3348
3349 /// Returns: `true` the function is `isInOutQual` or `isInOutParam` ,`false` otherwise.
3350 bool iswild() const pure nothrow @safe @nogc
3351 {
3352 return isInOutParam || isInOutQual;
3353 }
3354
3355 /// Returns: whether `this` function type has the same attributes (`@safe`,...) as `other`
3356 extern (D) bool attributesEqual(const scope TypeFunction other, bool trustSystemEqualsDefault = true) const pure nothrow @safe @nogc
3357 {
3358 // @@@DEPRECATED_2.112@@@
3359 // See semantic2.d Semantic2Visitor.visit(FuncDeclaration):
3360 // Two overloads that are identical except for one having an explicit `@system`
3361 // attribute is currently in deprecation, and will become an error in 2.104 for
3362 // `extern(C)`, and 2.112 for `extern(D)` code respectively. Once the deprecation
3363 // period has passed, the trustSystemEqualsDefault=true behaviour should be made
3364 // the default, then we can remove the `cannot overload extern(...) function`
3365 // errors as they will become dead code as a result.
3366 return (this.trust == other.trust ||
3367 (trustSystemEqualsDefault && this.trust <= TRUST.system && other.trust <= TRUST.system)) &&
3368 this.purity == other.purity &&
3369 this.isnothrow == other.isnothrow &&
3370 this.isnogc == other.isnogc &&
3371 this.islive == other.islive;
3372 }
3373
3374 override void accept(Visitor v)
3375 {
3376 v.visit(this);
3377 }
3378
3379 /**
3380 * Look for the index of parameter `ident` in the parameter list
3381 *
3382 * Params:
3383 * ident = identifier of parameter to search for
3384 * Returns: index of parameter with name `ident` or -1 if not found
3385 */
3386 private extern(D) ptrdiff_t findParameterIndex(Identifier ident)
3387 {
3388 foreach (i, p; this.parameterList)
3389 {
3390 if (p.ident == ident)
3391 return i;
3392 }
3393 return -1;
3394 }
3395 }
3396
3397 /***********************************************************
3398 */
3399 extern (C++) final class TypeDelegate : TypeNext
3400 {
3401 // .next is a TypeFunction
3402
3403 extern (D) this(TypeFunction t) @safe
3404 {
3405 super(Tfunction, t);
3406 ty = Tdelegate;
3407 }
3408
3409 static TypeDelegate create(TypeFunction t) @safe
3410 {
3411 return new TypeDelegate(t);
3412 }
3413
3414 override const(char)* kind() const
3415 {
3416 return "delegate";
3417 }
3418
3419 override TypeDelegate syntaxCopy()
3420 {
3421 auto tf = next.syntaxCopy().isTypeFunction();
3422 if (tf == next)
3423 return this;
3424
3425 auto result = new TypeDelegate(tf);
3426 result.mod = mod;
3427 return result;
3428 }
3429
3430 override uinteger_t size(const ref Loc loc)
3431 {
3432 return target.ptrsize * 2;
3433 }
3434
3435 override uint alignsize()
3436 {
3437 return target.ptrsize;
3438 }
3439
3440 override MATCH implicitConvTo(Type to)
3441 {
3442 //printf("TypeDelegate.implicitConvTo(this=%p, to=%p)\n", this, to);
3443 //printf("from: %s\n", toChars());
3444 //printf("to : %s\n", to.toChars());
3445 if (this.equals(to))
3446 return MATCH.exact;
3447
3448 if (auto toDg = to.isTypeDelegate())
3449 {
3450 MATCH m = this.next.isTypeFunction().implicitPointerConv(toDg.next);
3451
3452 // Retain the old behaviour for this refactoring
3453 // Should probably be changed to constant to match function pointers
3454 if (m > MATCH.convert)
3455 m = MATCH.convert;
3456
3457 return m;
3458 }
3459
3460 return MATCH.nomatch;
3461 }
3462
3463 override bool isZeroInit(const ref Loc loc)
3464 {
3465 return true;
3466 }
3467
3468 override bool isBoolean()
3469 {
3470 return true;
3471 }
3472
3473 override void accept(Visitor v)
3474 {
3475 v.visit(this);
3476 }
3477 }
3478
3479 /**
3480 * This is a shell containing a TraitsExp that can be
3481 * either resolved to a type or to a symbol.
3482 *
3483 * The point is to allow AliasDeclarationY to use `__traits()`, see https://issues.dlang.org/show_bug.cgi?id=7804.
3484 */
3485 extern (C++) final class TypeTraits : Type
3486 {
3487 Loc loc;
3488 /// The expression to resolve as type or symbol.
3489 TraitsExp exp;
3490 /// Cached type/symbol after semantic analysis.
3491 RootObject obj;
3492
3493 final extern (D) this(const ref Loc loc, TraitsExp exp) @safe
3494 {
3495 super(Ttraits);
3496 this.loc = loc;
3497 this.exp = exp;
3498 }
3499
3500 override const(char)* kind() const
3501 {
3502 return "traits";
3503 }
3504
3505 override TypeTraits syntaxCopy()
3506 {
3507 TraitsExp te = exp.syntaxCopy();
3508 TypeTraits tt = new TypeTraits(loc, te);
3509 tt.mod = mod;
3510 return tt;
3511 }
3512
3513 override void accept(Visitor v)
3514 {
3515 v.visit(this);
3516 }
3517
3518 override uinteger_t size(const ref Loc loc)
3519 {
3520 return SIZE_INVALID;
3521 }
3522 }
3523
3524 /******
3525 * Implements mixin types.
3526 *
3527 * Semantic analysis will convert it to a real type.
3528 */
3529 extern (C++) final class TypeMixin : Type
3530 {
3531 Loc loc;
3532 Expressions* exps;
3533 RootObject obj; // cached result of semantic analysis.
3534
3535 extern (D) this(const ref Loc loc, Expressions* exps) @safe
3536 {
3537 super(Tmixin);
3538 this.loc = loc;
3539 this.exps = exps;
3540 }
3541
3542 override const(char)* kind() const
3543 {
3544 return "mixin";
3545 }
3546
3547 override TypeMixin syntaxCopy()
3548 {
3549 return new TypeMixin(loc, Expression.arraySyntaxCopy(exps));
3550 }
3551
3552 override void accept(Visitor v)
3553 {
3554 v.visit(this);
3555 }
3556 }
3557
3558 /***********************************************************
3559 */
3560 extern (C++) abstract class TypeQualified : Type
3561 {
3562 Loc loc;
3563
3564 // array of Identifier and TypeInstance,
3565 // representing ident.ident!tiargs.ident. ... etc.
3566 Objects idents;
3567
3568 final extern (D) this(TY ty, Loc loc)
3569 {
3570 super(ty);
3571 this.loc = loc;
3572 }
3573
3574 // abstract override so that using `TypeQualified.syntaxCopy` gets
3575 // us a `TypeQualified`
3576 abstract override TypeQualified syntaxCopy();
3577
3578 extern (D) final void syntaxCopyHelper(TypeQualified t)
3579 {
3580 //printf("TypeQualified::syntaxCopyHelper(%s) %s\n", t.toChars(), toChars());
3581 idents.setDim(t.idents.length);
3582 for (size_t i = 0; i < idents.length; i++)
3583 {
3584 RootObject id = t.idents[i];
3585 with (DYNCAST) final switch (id.dyncast())
3586 {
3587 case object:
3588 break;
3589 case expression:
3590 Expression e = cast(Expression)id;
3591 e = e.syntaxCopy();
3592 id = e;
3593 break;
3594 case dsymbol:
3595 TemplateInstance ti = cast(TemplateInstance)id;
3596 ti = ti.syntaxCopy(null);
3597 id = ti;
3598 break;
3599 case type:
3600 Type tx = cast(Type)id;
3601 tx = tx.syntaxCopy();
3602 id = tx;
3603 break;
3604 case identifier:
3605 case tuple:
3606 case parameter:
3607 case statement:
3608 case condition:
3609 case templateparameter:
3610 case initializer:
3611 }
3612 idents[i] = id;
3613 }
3614 }
3615
3616 extern (D) final void addIdent(Identifier ident)
3617 {
3618 idents.push(ident);
3619 }
3620
3621 extern (D) final void addInst(TemplateInstance inst)
3622 {
3623 idents.push(inst);
3624 }
3625
3626 extern (D) final void addIndex(RootObject e)
3627 {
3628 idents.push(e);
3629 }
3630
3631 override uinteger_t size(const ref Loc loc)
3632 {
3633 error(this.loc, "size of type `%s` is not known", toChars());
3634 return SIZE_INVALID;
3635 }
3636
3637 override void accept(Visitor v)
3638 {
3639 v.visit(this);
3640 }
3641 }
3642
3643 /***********************************************************
3644 */
3645 extern (C++) final class TypeIdentifier : TypeQualified
3646 {
3647 Identifier ident;
3648
3649 // The symbol representing this identifier, before alias resolution
3650 Dsymbol originalSymbol;
3651
3652 extern (D) this(const ref Loc loc, Identifier ident)
3653 {
3654 super(Tident, loc);
3655 this.ident = ident;
3656 }
3657
3658 static TypeIdentifier create(const ref Loc loc, Identifier ident)
3659 {
3660 return new TypeIdentifier(loc, ident);
3661 }
3662
3663 override const(char)* kind() const
3664 {
3665 return "identifier";
3666 }
3667
3668 override TypeIdentifier syntaxCopy()
3669 {
3670 auto t = new TypeIdentifier(loc, ident);
3671 t.syntaxCopyHelper(this);
3672 t.mod = mod;
3673 return t;
3674 }
3675
3676 override void accept(Visitor v)
3677 {
3678 v.visit(this);
3679 }
3680 }
3681
3682 /***********************************************************
3683 * Similar to TypeIdentifier, but with a TemplateInstance as the root
3684 */
3685 extern (C++) final class TypeInstance : TypeQualified
3686 {
3687 TemplateInstance tempinst;
3688
3689 extern (D) this(const ref Loc loc, TemplateInstance tempinst)
3690 {
3691 super(Tinstance, loc);
3692 this.tempinst = tempinst;
3693 }
3694
3695 override const(char)* kind() const
3696 {
3697 return "instance";
3698 }
3699
3700 override TypeInstance syntaxCopy()
3701 {
3702 //printf("TypeInstance::syntaxCopy() %s, %d\n", toChars(), idents.length);
3703 auto t = new TypeInstance(loc, tempinst.syntaxCopy(null));
3704 t.syntaxCopyHelper(this);
3705 t.mod = mod;
3706 return t;
3707 }
3708
3709 override void accept(Visitor v)
3710 {
3711 v.visit(this);
3712 }
3713 }
3714
3715 /***********************************************************
3716 */
3717 extern (C++) final class TypeTypeof : TypeQualified
3718 {
3719 Expression exp;
3720 int inuse;
3721
3722 extern (D) this(const ref Loc loc, Expression exp)
3723 {
3724 super(Ttypeof, loc);
3725 this.exp = exp;
3726 }
3727
3728 override const(char)* kind() const
3729 {
3730 return "typeof";
3731 }
3732
3733 override TypeTypeof syntaxCopy()
3734 {
3735 //printf("TypeTypeof::syntaxCopy() %s\n", toChars());
3736 auto t = new TypeTypeof(loc, exp.syntaxCopy());
3737 t.syntaxCopyHelper(this);
3738 t.mod = mod;
3739 return t;
3740 }
3741
3742 override uinteger_t size(const ref Loc loc)
3743 {
3744 if (exp.type)
3745 return exp.type.size(loc);
3746 else
3747 return TypeQualified.size(loc);
3748 }
3749
3750 override void accept(Visitor v)
3751 {
3752 v.visit(this);
3753 }
3754 }
3755
3756 /***********************************************************
3757 */
3758 extern (C++) final class TypeReturn : TypeQualified
3759 {
3760 extern (D) this(const ref Loc loc)
3761 {
3762 super(Treturn, loc);
3763 }
3764
3765 override const(char)* kind() const
3766 {
3767 return "return";
3768 }
3769
3770 override TypeReturn syntaxCopy()
3771 {
3772 auto t = new TypeReturn(loc);
3773 t.syntaxCopyHelper(this);
3774 t.mod = mod;
3775 return t;
3776 }
3777
3778 override void accept(Visitor v)
3779 {
3780 v.visit(this);
3781 }
3782 }
3783
3784 /***********************************************************
3785 */
3786 extern (C++) final class TypeStruct : Type
3787 {
3788 StructDeclaration sym;
3789 AliasThisRec att = AliasThisRec.fwdref;
3790 bool inuse = false; // struct currently subject of recursive method call
3791
3792 extern (D) this(StructDeclaration sym) @safe
3793 {
3794 super(Tstruct);
3795 this.sym = sym;
3796 }
3797
3798 static TypeStruct create(StructDeclaration sym) @safe
3799 {
3800 return new TypeStruct(sym);
3801 }
3802
3803 override const(char)* kind() const
3804 {
3805 return "struct";
3806 }
3807
3808 override uinteger_t size(const ref Loc loc)
3809 {
3810 return sym.size(loc);
3811 }
3812
3813 override uint alignsize()
3814 {
3815 sym.size(Loc.initial); // give error for forward references
3816 return sym.alignsize;
3817 }
3818
3819 override TypeStruct syntaxCopy()
3820 {
3821 return this;
3822 }
3823
3824 override structalign_t alignment()
3825 {
3826 if (sym.alignment.isUnknown())
3827 sym.size(sym.loc);
3828 return sym.alignment;
3829 }
3830
3831 /***************************************
3832 * Use when we prefer the default initializer to be a literal,
3833 * rather than a global immutable variable.
3834 */
3835 override Expression defaultInitLiteral(const ref Loc loc)
3836 {
3837 static if (LOGDEFAULTINIT)
3838 {
3839 printf("TypeStruct::defaultInitLiteral() '%s'\n", toChars());
3840 }
3841 sym.size(loc);
3842 if (sym.sizeok != Sizeok.done)
3843 return ErrorExp.get();
3844
3845 auto structelems = new Expressions(sym.nonHiddenFields());
3846 uint offset = 0;
3847 foreach (j; 0 .. structelems.length)
3848 {
3849 VarDeclaration vd = sym.fields[j];
3850 Expression e;
3851 if (vd.inuse)
3852 {
3853 error(loc, "circular reference to `%s`", vd.toPrettyChars());
3854 return ErrorExp.get();
3855 }
3856 if (vd.offset < offset || vd.type.size() == 0)
3857 e = null;
3858 else if (vd._init)
3859 {
3860 if (vd._init.isVoidInitializer())
3861 e = null;
3862 else
3863 e = vd.getConstInitializer(false);
3864 }
3865 else
3866 e = vd.type.defaultInitLiteral(loc);
3867 if (e && e.op == EXP.error)
3868 return e;
3869 if (e)
3870 offset = vd.offset + cast(uint)vd.type.size();
3871 (*structelems)[j] = e;
3872 }
3873 auto structinit = new StructLiteralExp(loc, sym, structelems);
3874
3875 /* Copy from the initializer symbol for larger symbols,
3876 * otherwise the literals expressed as code get excessively large.
3877 */
3878 if (size(loc) > target.ptrsize * 4 && !needsNested())
3879 structinit.useStaticInit = true;
3880
3881 structinit.type = this;
3882 return structinit;
3883 }
3884
3885 override bool isZeroInit(const ref Loc loc)
3886 {
3887 // Determine zeroInit here, as this can be called before semantic2
3888 sym.determineSize(sym.loc);
3889 return sym.zeroInit;
3890 }
3891
3892 override bool isAssignable()
3893 {
3894 bool assignable = true;
3895 uint offset = ~0; // dead-store initialize to prevent spurious warning
3896
3897 sym.determineSize(sym.loc);
3898
3899 /* If any of the fields are const or immutable,
3900 * then one cannot assign this struct.
3901 */
3902 for (size_t i = 0; i < sym.fields.length; i++)
3903 {
3904 VarDeclaration v = sym.fields[i];
3905 //printf("%s [%d] v = (%s) %s, v.offset = %d, v.parent = %s\n", sym.toChars(), i, v.kind(), v.toChars(), v.offset, v.parent.kind());
3906 if (i == 0)
3907 {
3908 }
3909 else if (v.offset == offset)
3910 {
3911 /* If any fields of anonymous union are assignable,
3912 * then regard union as assignable.
3913 * This is to support unsafe things like Rebindable templates.
3914 */
3915 if (assignable)
3916 continue;
3917 }
3918 else
3919 {
3920 if (!assignable)
3921 return false;
3922 }
3923 assignable = v.type.isMutable() && v.type.isAssignable();
3924 offset = v.offset;
3925 //printf(" -> assignable = %d\n", assignable);
3926 }
3927
3928 return assignable;
3929 }
3930
3931 override bool isBoolean()
3932 {
3933 return false;
3934 }
3935
3936 override bool needsDestruction()
3937 {
3938 return sym.dtor !is null;
3939 }
3940
3941 override bool needsCopyOrPostblit()
3942 {
3943 return sym.hasCopyCtor || sym.postblit;
3944 }
3945
3946 override bool needsNested()
3947 {
3948 if (inuse) return false; // circular type, error instead of crashing
3949
3950 inuse = true;
3951 scope(exit) inuse = false;
3952
3953 if (sym.isNested())
3954 return true;
3955
3956 for (size_t i = 0; i < sym.fields.length; i++)
3957 {
3958 VarDeclaration v = sym.fields[i];
3959 if (!v.isDataseg() && v.type.needsNested())
3960 return true;
3961 }
3962 return false;
3963 }
3964
3965 override bool hasVoidInitPointers()
3966 {
3967 sym.size(Loc.initial); // give error for forward references
3968 sym.determineTypeProperties();
3969 return sym.hasVoidInitPointers;
3970 }
3971
3972 override bool hasSystemFields()
3973 {
3974 sym.size(Loc.initial); // give error for forward references
3975 sym.determineTypeProperties();
3976 return sym.hasSystemFields;
3977 }
3978
3979 override bool hasInvariant()
3980 {
3981 sym.size(Loc.initial); // give error for forward references
3982 sym.determineTypeProperties();
3983 return sym.hasInvariant() || sym.hasFieldWithInvariant;
3984 }
3985
3986 extern (D) MATCH implicitConvToWithoutAliasThis(Type to)
3987 {
3988 MATCH m;
3989
3990 if (ty == to.ty && sym == (cast(TypeStruct)to).sym)
3991 {
3992 m = MATCH.exact; // exact match
3993 if (mod != to.mod)
3994 {
3995 m = MATCH.constant;
3996 if (MODimplicitConv(mod, to.mod))
3997 {
3998 }
3999 else
4000 {
4001 /* Check all the fields. If they can all be converted,
4002 * allow the conversion.
4003 */
4004 uint offset = ~0; // dead-store to prevent spurious warning
4005 for (size_t i = 0; i < sym.fields.length; i++)
4006 {
4007 VarDeclaration v = sym.fields[i];
4008 if (i == 0)
4009 {
4010 }
4011 else if (v.offset == offset)
4012 {
4013 if (m > MATCH.nomatch)
4014 continue;
4015 }
4016 else
4017 {
4018 if (m == MATCH.nomatch)
4019 return m;
4020 }
4021
4022 // 'from' type
4023 Type tvf = v.type.addMod(mod);
4024
4025 // 'to' type
4026 Type tv = v.type.addMod(to.mod);
4027
4028 // field match
4029 MATCH mf = tvf.implicitConvTo(tv);
4030 //printf("\t%s => %s, match = %d\n", v.type.toChars(), tv.toChars(), mf);
4031
4032 if (mf == MATCH.nomatch)
4033 return mf;
4034 if (mf < m) // if field match is worse
4035 m = mf;
4036 offset = v.offset;
4037 }
4038 }
4039 }
4040 }
4041 return m;
4042 }
4043
4044 extern (D) MATCH implicitConvToThroughAliasThis(Type to)
4045 {
4046 MATCH m;
4047 if (!(ty == to.ty && sym == (cast(TypeStruct)to).sym) && sym.aliasthis && !(att & AliasThisRec.tracing))
4048 {
4049 if (auto ato = aliasthisOf(this))
4050 {
4051 att = cast(AliasThisRec)(att | AliasThisRec.tracing);
4052 m = ato.implicitConvTo(to);
4053 att = cast(AliasThisRec)(att & ~AliasThisRec.tracing);
4054 }
4055 else
4056 m = MATCH.nomatch; // no match
4057 }
4058 return m;
4059 }
4060
4061 override MATCH implicitConvTo(Type to)
4062 {
4063 //printf("TypeStruct::implicitConvTo(%s => %s)\n", toChars(), to.toChars());
4064 MATCH m = implicitConvToWithoutAliasThis(to);
4065 return m ? m : implicitConvToThroughAliasThis(to);
4066 }
4067
4068 override MATCH constConv(Type to)
4069 {
4070 if (equals(to))
4071 return MATCH.exact;
4072 if (ty == to.ty && sym == (cast(TypeStruct)to).sym && MODimplicitConv(mod, to.mod))
4073 return MATCH.constant;
4074 return MATCH.nomatch;
4075 }
4076
4077 override MOD deduceWild(Type t, bool isRef)
4078 {
4079 if (ty == t.ty && sym == (cast(TypeStruct)t).sym)
4080 return Type.deduceWild(t, isRef);
4081
4082 ubyte wm = 0;
4083
4084 if (t.hasWild() && sym.aliasthis && !(att & AliasThisRec.tracing))
4085 {
4086 if (auto ato = aliasthisOf(this))
4087 {
4088 att = cast(AliasThisRec)(att | AliasThisRec.tracing);
4089 wm = ato.deduceWild(t, isRef);
4090 att = cast(AliasThisRec)(att & ~AliasThisRec.tracing);
4091 }
4092 }
4093
4094 return wm;
4095 }
4096
4097 override void accept(Visitor v)
4098 {
4099 v.visit(this);
4100 }
4101 }
4102
4103 /***********************************************************
4104 */
4105 extern (C++) final class TypeEnum : Type
4106 {
4107 EnumDeclaration sym;
4108
4109 extern (D) this(EnumDeclaration sym) @safe
4110 {
4111 super(Tenum);
4112 this.sym = sym;
4113 }
4114
4115 override const(char)* kind() const
4116 {
4117 return "enum";
4118 }
4119
4120 override TypeEnum syntaxCopy()
4121 {
4122 return this;
4123 }
4124
4125 override uinteger_t size(const ref Loc loc)
4126 {
4127 return sym.getMemtype(loc).size(loc);
4128 }
4129
4130 Type memType()
4131 {
4132 return sym.getMemtype(Loc.initial);
4133 }
4134
4135 override uint alignsize()
4136 {
4137 Type t = memType();
4138 if (t.ty == Terror)
4139 return 4;
4140 return t.alignsize();
4141 }
4142
4143 override bool isintegral()
4144 {
4145 return memType().isintegral();
4146 }
4147
4148 override bool isfloating()
4149 {
4150 return memType().isfloating();
4151 }
4152
4153 override bool isreal()
4154 {
4155 return memType().isreal();
4156 }
4157
4158 override bool isimaginary()
4159 {
4160 return memType().isimaginary();
4161 }
4162
4163 override bool iscomplex()
4164 {
4165 return memType().iscomplex();
4166 }
4167
4168 override bool isscalar()
4169 {
4170 return memType().isscalar();
4171 }
4172
4173 override bool isunsigned()
4174 {
4175 return memType().isunsigned();
4176 }
4177
4178 override bool isBoolean()
4179 {
4180 return memType().isBoolean();
4181 }
4182
4183 override bool isString()
4184 {
4185 return memType().isString();
4186 }
4187
4188 override bool isAssignable()
4189 {
4190 return memType().isAssignable();
4191 }
4192
4193 override bool needsDestruction()
4194 {
4195 return memType().needsDestruction();
4196 }
4197
4198 override bool needsCopyOrPostblit()
4199 {
4200 return memType().needsCopyOrPostblit();
4201 }
4202
4203 override bool needsNested()
4204 {
4205 return memType().needsNested();
4206 }
4207
4208 override MATCH implicitConvTo(Type to)
4209 {
4210 MATCH m;
4211 //printf("TypeEnum::implicitConvTo() %s to %s\n", toChars(), to.toChars());
4212 if (ty == to.ty && sym == (cast(TypeEnum)to).sym)
4213 m = (mod == to.mod) ? MATCH.exact : MATCH.constant;
4214 else if (sym.getMemtype(Loc.initial).implicitConvTo(to))
4215 m = MATCH.convert; // match with conversions
4216 else
4217 m = MATCH.nomatch; // no match
4218 return m;
4219 }
4220
4221 override MATCH constConv(Type to)
4222 {
4223 if (equals(to))
4224 return MATCH.exact;
4225 if (ty == to.ty && sym == (cast(TypeEnum)to).sym && MODimplicitConv(mod, to.mod))
4226 return MATCH.constant;
4227 return MATCH.nomatch;
4228 }
4229
4230 extern (D) Type toBasetype2()
4231 {
4232 if (!sym.members && !sym.memtype)
4233 return this;
4234 auto tb = sym.getMemtype(Loc.initial).toBasetype();
4235 return tb.castMod(mod); // retain modifier bits from 'this'
4236 }
4237
4238 override bool isZeroInit(const ref Loc loc)
4239 {
4240 return sym.getDefaultValue(loc).toBool().hasValue(false);
4241 }
4242
4243 override bool hasVoidInitPointers()
4244 {
4245 return memType().hasVoidInitPointers();
4246 }
4247
4248 override bool hasSystemFields()
4249 {
4250 return memType().hasSystemFields();
4251 }
4252
4253 override bool hasInvariant()
4254 {
4255 return memType().hasInvariant();
4256 }
4257
4258 override Type nextOf()
4259 {
4260 return memType().nextOf();
4261 }
4262
4263 override void accept(Visitor v)
4264 {
4265 v.visit(this);
4266 }
4267 }
4268
4269 /***********************************************************
4270 */
4271 extern (C++) final class TypeClass : Type
4272 {
4273 ClassDeclaration sym;
4274 AliasThisRec att = AliasThisRec.fwdref;
4275 CPPMANGLE cppmangle = CPPMANGLE.def;
4276
4277 extern (D) this(ClassDeclaration sym) @safe
4278 {
4279 super(Tclass);
4280 this.sym = sym;
4281 }
4282
4283 override const(char)* kind() const
4284 {
4285 return "class";
4286 }
4287
4288 override uinteger_t size(const ref Loc loc)
4289 {
4290 return target.ptrsize;
4291 }
4292
4293 override TypeClass syntaxCopy()
4294 {
4295 return this;
4296 }
4297
4298 override inout(ClassDeclaration) isClassHandle() inout
4299 {
4300 return sym;
4301 }
4302
4303 extern (D) MATCH implicitConvToWithoutAliasThis(Type to)
4304 {
4305 ClassDeclaration cdto = to.isClassHandle();
4306 MATCH m = constConv(to);
4307 if (m > MATCH.nomatch)
4308 return m;
4309
4310 if (cdto && cdto.isBaseOf(sym, null) && MODimplicitConv(mod, to.mod))
4311 {
4312 //printf("'to' is base\n");
4313 return MATCH.convert;
4314 }
4315 return MATCH.nomatch;
4316 }
4317
4318 extern (D) MATCH implicitConvToThroughAliasThis(Type to)
4319 {
4320 MATCH m;
4321 if (sym.aliasthis && !(att & AliasThisRec.tracing))
4322 {
4323 if (auto ato = aliasthisOf(this))
4324 {
4325 att = cast(AliasThisRec)(att | AliasThisRec.tracing);
4326 m = ato.implicitConvTo(to);
4327 att = cast(AliasThisRec)(att & ~AliasThisRec.tracing);
4328 }
4329 }
4330 return m;
4331 }
4332
4333 override MATCH implicitConvTo(Type to)
4334 {
4335 //printf("TypeClass::implicitConvTo(to = '%s') %s\n", to.toChars(), toChars());
4336 MATCH m = implicitConvToWithoutAliasThis(to);
4337 return m ? m : implicitConvToThroughAliasThis(to);
4338 }
4339
4340 override MATCH constConv(Type to)
4341 {
4342 if (equals(to))
4343 return MATCH.exact;
4344 if (ty == to.ty && sym == (cast(TypeClass)to).sym && MODimplicitConv(mod, to.mod))
4345 return MATCH.constant;
4346
4347 /* Conversion derived to const(base)
4348 */
4349 int offset = 0;
4350 if (to.isBaseOf(this, &offset) && offset == 0 && MODimplicitConv(mod, to.mod))
4351 {
4352 // Disallow:
4353 // derived to base
4354 // inout(derived) to inout(base)
4355 if (!to.isMutable() && !to.isWild())
4356 return MATCH.convert;
4357 }
4358
4359 return MATCH.nomatch;
4360 }
4361
4362 override MOD deduceWild(Type t, bool isRef)
4363 {
4364 ClassDeclaration cd = t.isClassHandle();
4365 if (cd && (sym == cd || cd.isBaseOf(sym, null)))
4366 return Type.deduceWild(t, isRef);
4367
4368 ubyte wm = 0;
4369
4370 if (t.hasWild() && sym.aliasthis && !(att & AliasThisRec.tracing))
4371 {
4372 if (auto ato = aliasthisOf(this))
4373 {
4374 att = cast(AliasThisRec)(att | AliasThisRec.tracing);
4375 wm = ato.deduceWild(t, isRef);
4376 att = cast(AliasThisRec)(att & ~AliasThisRec.tracing);
4377 }
4378 }
4379
4380 return wm;
4381 }
4382
4383 override bool isZeroInit(const ref Loc loc)
4384 {
4385 return true;
4386 }
4387
4388 override bool isscope()
4389 {
4390 return sym.stack;
4391 }
4392
4393 override bool isBoolean()
4394 {
4395 return true;
4396 }
4397
4398 override void accept(Visitor v)
4399 {
4400 v.visit(this);
4401 }
4402 }
4403
4404 /***********************************************************
4405 */
4406 extern (C++) final class TypeTuple : Type
4407 {
4408 // 'logically immutable' cached global - don't modify!
4409 __gshared TypeTuple empty = new TypeTuple();
4410
4411 Parameters* arguments; // types making up the tuple
4412
4413 extern (D) this(Parameters* arguments) @safe
4414 {
4415 super(Ttuple);
4416 //printf("TypeTuple(this = %p)\n", this);
4417 this.arguments = arguments;
4418 //printf("TypeTuple() %p, %s\n", this, toChars());
4419 debug
4420 {
4421 if (arguments)
4422 {
4423 for (size_t i = 0; i < arguments.length; i++)
4424 {
4425 Parameter arg = (*arguments)[i];
4426 assert(arg && arg.type);
4427 }
4428 }
4429 }
4430 }
4431
4432 /****************
4433 * Form TypeTuple from the types of the expressions.
4434 * Assume exps[] is already tuple expanded.
4435 */
4436 extern (D) this(Expressions* exps)
4437 {
4438 super(Ttuple);
4439 auto arguments = new Parameters(exps ? exps.length : 0);
4440 if (exps)
4441 {
4442 for (size_t i = 0; i < exps.length; i++)
4443 {
4444 Expression e = (*exps)[i];
4445 if (e.type.ty == Ttuple)
4446 error(e.loc, "cannot form sequence of sequences");
4447 auto arg = new Parameter(e.loc, STC.undefined_, e.type, null, null, null);
4448 (*arguments)[i] = arg;
4449 }
4450 }
4451 this.arguments = arguments;
4452 //printf("TypeTuple() %p, %s\n", this, toChars());
4453 }
4454
4455 static TypeTuple create(Parameters* arguments) @safe
4456 {
4457 return new TypeTuple(arguments);
4458 }
4459
4460 /*******************************************
4461 * Type tuple with 0, 1 or 2 types in it.
4462 */
4463 extern (D) this() @safe
4464 {
4465 super(Ttuple);
4466 arguments = new Parameters();
4467 }
4468
4469 extern (D) this(Type t1)
4470 {
4471 super(Ttuple);
4472 arguments = new Parameters();
4473 arguments.push(new Parameter(Loc.initial, 0, t1, null, null, null));
4474 }
4475
4476 extern (D) this(Type t1, Type t2)
4477 {
4478 super(Ttuple);
4479 arguments = new Parameters();
4480 arguments.push(new Parameter(Loc.initial, 0, t1, null, null, null));
4481 arguments.push(new Parameter(Loc.initial, 0, t2, null, null, null));
4482 }
4483
4484 static TypeTuple create() @safe
4485 {
4486 return new TypeTuple();
4487 }
4488
4489 static TypeTuple create(Type t1)
4490 {
4491 return new TypeTuple(t1);
4492 }
4493
4494 static TypeTuple create(Type t1, Type t2)
4495 {
4496 return new TypeTuple(t1, t2);
4497 }
4498
4499 override const(char)* kind() const
4500 {
4501 return "sequence";
4502 }
4503
4504 override TypeTuple syntaxCopy()
4505 {
4506 Parameters* args = Parameter.arraySyntaxCopy(arguments);
4507 auto t = new TypeTuple(args);
4508 t.mod = mod;
4509 return t;
4510 }
4511
4512 override bool equals(const RootObject o) const
4513 {
4514 Type t = cast(Type)o;
4515 //printf("TypeTuple::equals(%s, %s)\n", toChars(), t.toChars());
4516 if (this == t)
4517 return true;
4518 if (auto tt = t.isTypeTuple())
4519 {
4520 if (arguments.length == tt.arguments.length)
4521 {
4522 for (size_t i = 0; i < tt.arguments.length; i++)
4523 {
4524 const Parameter arg1 = (*arguments)[i];
4525 Parameter arg2 = (*tt.arguments)[i];
4526 if (!arg1.type.equals(arg2.type))
4527 return false;
4528 }
4529 return true;
4530 }
4531 }
4532 return false;
4533 }
4534
4535 override MATCH implicitConvTo(Type to)
4536 {
4537 if (this == to)
4538 return MATCH.exact;
4539 if (auto tt = to.isTypeTuple())
4540 {
4541 if (arguments.length == tt.arguments.length)
4542 {
4543 MATCH m = MATCH.exact;
4544 for (size_t i = 0; i < tt.arguments.length; i++)
4545 {
4546 Parameter arg1 = (*arguments)[i];
4547 Parameter arg2 = (*tt.arguments)[i];
4548 MATCH mi = arg1.type.implicitConvTo(arg2.type);
4549 if (mi < m)
4550 m = mi;
4551 }
4552 return m;
4553 }
4554 }
4555 return MATCH.nomatch;
4556 }
4557
4558 override void accept(Visitor v)
4559 {
4560 v.visit(this);
4561 }
4562 }
4563
4564 /***********************************************************
4565 * This is so we can slice a TypeTuple
4566 */
4567 extern (C++) final class TypeSlice : TypeNext
4568 {
4569 Expression lwr;
4570 Expression upr;
4571
4572 extern (D) this(Type next, Expression lwr, Expression upr) @safe
4573 {
4574 super(Tslice, next);
4575 //printf("TypeSlice[%s .. %s]\n", lwr.toChars(), upr.toChars());
4576 this.lwr = lwr;
4577 this.upr = upr;
4578 }
4579
4580 override const(char)* kind() const
4581 {
4582 return "slice";
4583 }
4584
4585 override TypeSlice syntaxCopy()
4586 {
4587 auto t = new TypeSlice(next.syntaxCopy(), lwr.syntaxCopy(), upr.syntaxCopy());
4588 t.mod = mod;
4589 return t;
4590 }
4591
4592 override void accept(Visitor v)
4593 {
4594 v.visit(this);
4595 }
4596 }
4597
4598 /***********************************************************
4599 */
4600 extern (C++) final class TypeNull : Type
4601 {
4602 extern (D) this() @safe
4603 {
4604 //printf("TypeNull %p\n", this);
4605 super(Tnull);
4606 }
4607
4608 override const(char)* kind() const
4609 {
4610 return "null";
4611 }
4612
4613 override TypeNull syntaxCopy()
4614 {
4615 // No semantic analysis done, no need to copy
4616 return this;
4617 }
4618
4619 override MATCH implicitConvTo(Type to)
4620 {
4621 //printf("TypeNull::implicitConvTo(this=%p, to=%p)\n", this, to);
4622 //printf("from: %s\n", toChars());
4623 //printf("to : %s\n", to.toChars());
4624 MATCH m = Type.implicitConvTo(to);
4625 if (m != MATCH.nomatch)
4626 return m;
4627
4628 // NULL implicitly converts to any pointer type or dynamic array
4629 //if (type.ty == Tpointer && type.nextOf().ty == Tvoid)
4630 {
4631 Type tb = to.toBasetype();
4632 if (tb.ty == Tnull || tb.ty == Tpointer || tb.ty == Tarray || tb.ty == Taarray || tb.ty == Tclass || tb.ty == Tdelegate)
4633 return MATCH.constant;
4634 }
4635
4636 return MATCH.nomatch;
4637 }
4638
4639 override bool isBoolean()
4640 {
4641 return true;
4642 }
4643
4644 override uinteger_t size(const ref Loc loc)
4645 {
4646 return tvoidptr.size(loc);
4647 }
4648
4649 override void accept(Visitor v)
4650 {
4651 v.visit(this);
4652 }
4653 }
4654
4655 /***********************************************************
4656 */
4657 extern (C++) final class TypeNoreturn : Type
4658 {
4659 extern (D) this() @safe
4660 {
4661 //printf("TypeNoreturn %p\n", this);
4662 super(Tnoreturn);
4663 }
4664
4665 override const(char)* kind() const
4666 {
4667 return "noreturn";
4668 }
4669
4670 override TypeNoreturn syntaxCopy()
4671 {
4672 // No semantic analysis done, no need to copy
4673 return this;
4674 }
4675
4676 override MATCH implicitConvTo(Type to)
4677 {
4678 //printf("TypeNoreturn::implicitConvTo(this=%p, to=%p)\n", this, to);
4679 //printf("from: %s\n", toChars());
4680 //printf("to : %s\n", to.toChars());
4681 if (this.equals(to))
4682 return MATCH.exact;
4683
4684 // Different qualifiers?
4685 if (to.ty == Tnoreturn)
4686 return MATCH.constant;
4687
4688 // Implicitly convertible to any type
4689 return MATCH.convert;
4690 }
4691
4692 override MATCH constConv(Type to)
4693 {
4694 // Either another noreturn or conversion to any type
4695 return this.implicitConvTo(to);
4696 }
4697
4698 override bool isBoolean()
4699 {
4700 return true; // bottom type can be implicitly converted to any other type
4701 }
4702
4703 override uinteger_t size(const ref Loc loc)
4704 {
4705 return 0;
4706 }
4707
4708 override uint alignsize()
4709 {
4710 return 0;
4711 }
4712
4713 override void accept(Visitor v)
4714 {
4715 v.visit(this);
4716 }
4717 }
4718
4719 /***********************************************************
4720 * Unlike D, C can declare/define struct/union/enum tag names
4721 * inside Declarators, instead of separately as in D.
4722 * The order these appear in the symbol table must be in lexical
4723 * order. There isn't enough info at the parsing stage to determine if
4724 * it's a declaration or a reference to an existing name, so this Type
4725 * collects the necessary info and defers it to semantic().
4726 */
4727 extern (C++) final class TypeTag : Type
4728 {
4729 Loc loc; /// location of declaration
4730 TOK tok; /// TOK.struct_, TOK.union_, TOK.enum_
4731 structalign_t packalign; /// alignment of struct/union fields
4732 Identifier id; /// tag name identifier
4733 Type base; /// base type for enums otherwise null
4734 Dsymbols* members; /// members of struct, null if none
4735
4736 Type resolved; /// type after semantic() in case there are more others
4737 /// pointing to this instance, which can happen with
4738 /// struct S { int a; } s1, *s2;
4739 MOD mod; /// modifiers to apply after type is resolved (only MODFlags.const_ at the moment)
4740
4741 extern (D) this(const ref Loc loc, TOK tok, Identifier id, structalign_t packalign, Type base, Dsymbols* members) @safe
4742 {
4743 //printf("TypeTag ctor %s %p\n", id ? id.toChars() : "null".ptr, this);
4744 super(Ttag);
4745 this.loc = loc;
4746 this.tok = tok;
4747 this.id = id;
4748 this.packalign = packalign;
4749 this.base = base;
4750 this.members = members;
4751 this.mod = 0;
4752 }
4753
4754 override const(char)* kind() const
4755 {
4756 return "tag";
4757 }
4758
4759 override TypeTag syntaxCopy()
4760 {
4761 //printf("TypeTag syntaxCopy()\n");
4762 // No semantic analysis done, no need to copy
4763 return this;
4764 }
4765
4766 override void accept(Visitor v)
4767 {
4768 v.visit(this);
4769 }
4770 }
4771
4772 /***********************************************************
4773 * Represents a function's formal parameters + variadics info.
4774 * Length, indexing and iteration are based on a depth-first tuple expansion.
4775 * https://dlang.org/spec/function.html#ParameterList
4776 */
4777 extern (C++) struct ParameterList
4778 {
4779 /// The raw (unexpanded) formal parameters, possibly containing tuples.
4780 Parameters* parameters;
4781 StorageClass stc; // storage class of ...
4782 VarArg varargs = VarArg.none;
4783 bool hasIdentifierList; // true if C identifier-list style
4784
4785 this(Parameters* parameters, VarArg varargs = VarArg.none, StorageClass stc = 0) @safe
4786 {
4787 this.parameters = parameters;
4788 this.varargs = varargs;
4789 this.stc = stc;
4790 }
4791
4792 /// Returns the number of expanded parameters. Complexity: O(N).
4793 size_t length()
4794 {
4795 return Parameter.dim(parameters);
4796 }
4797
4798 /// Returns the expanded parameter at the given index, or null if out of
4799 /// bounds. Complexity: O(i).
4800 Parameter opIndex(size_t i)
4801 {
4802 return Parameter.getNth(parameters, i);
4803 }
4804
4805 /// Iterates over the expanded parameters. Complexity: O(N).
4806 /// Prefer this to avoid the O(N + N^2/2) complexity of calculating length
4807 /// and calling N times opIndex.
4808 extern (D) int opApply(scope Parameter.ForeachDg dg)
4809 {
4810 return Parameter._foreach(parameters, dg);
4811 }
4812
4813 /// Iterates over the expanded parameters, matching them with the unexpanded
4814 /// ones, for semantic processing
4815 extern (D) int opApply(scope Parameter.SemanticForeachDg dg)
4816 {
4817 return Parameter._foreach(this.parameters, dg);
4818 }
4819
4820 extern (D) ParameterList syntaxCopy()
4821 {
4822 return ParameterList(Parameter.arraySyntaxCopy(parameters), varargs);
4823 }
4824
4825 /// Compares this to another ParameterList (and expands tuples if necessary)
4826 extern (D) bool opEquals(scope ref ParameterList other) const
4827 {
4828 if (stc != other.stc || varargs != other.varargs || (!parameters != !other.parameters))
4829 return false;
4830
4831 if (this.parameters is other.parameters)
4832 return true;
4833
4834 size_t idx;
4835 bool diff;
4836
4837 // Pairwise compare each parameter
4838 // Can this avoid the O(n) indexing for the second list?
4839 foreach (_, p1; cast() this)
4840 {
4841 auto p2 = other[idx++];
4842 if (!p2 || p1 != p2) {
4843 diff = true;
4844 break;
4845 }
4846 }
4847
4848 // Ensure no remaining parameters in `other`
4849 return !diff && other[idx] is null;
4850 }
4851
4852 /// Returns: `true` if any parameter has a default argument
4853 extern(D) bool hasDefaultArgs()
4854 {
4855 foreach (oidx, oparam, eidx, eparam; this)
4856 {
4857 if (eparam.defaultArg)
4858 return true;
4859 }
4860 return false;
4861 }
4862
4863 // Returns: `true` if any parameter doesn't have a default argument
4864 extern(D) bool hasArgsWithoutDefault()
4865 {
4866 foreach (oidx, oparam, eidx, eparam; this)
4867 {
4868 if (!eparam.defaultArg)
4869 return true;
4870 }
4871 return false;
4872 }
4873 }
4874
4875
4876 /***********************************************************
4877 */
4878 extern (C++) final class Parameter : ASTNode
4879 {
4880 import dmd.attrib : UserAttributeDeclaration;
4881
4882 Loc loc;
4883 StorageClass storageClass;
4884 Type type;
4885 Identifier ident;
4886 Expression defaultArg;
4887 UserAttributeDeclaration userAttribDecl; // user defined attributes
4888
4889 extern (D) this(const ref Loc loc, StorageClass storageClass, Type type, Identifier ident, Expression defaultArg, UserAttributeDeclaration userAttribDecl) @safe
4890 {
4891 this.loc = loc;
4892 this.type = type;
4893 this.ident = ident;
4894 this.storageClass = storageClass;
4895 this.defaultArg = defaultArg;
4896 this.userAttribDecl = userAttribDecl;
4897 }
4898
4899 static Parameter create(const ref Loc loc, StorageClass storageClass, Type type, Identifier ident, Expression defaultArg, UserAttributeDeclaration userAttribDecl) @safe
4900 {
4901 return new Parameter(loc, storageClass, type, ident, defaultArg, userAttribDecl);
4902 }
4903
4904 Parameter syntaxCopy()
4905 {
4906 return new Parameter(loc, storageClass, type ? type.syntaxCopy() : null, ident, defaultArg ? defaultArg.syntaxCopy() : null, userAttribDecl ? userAttribDecl.syntaxCopy(null) : null);
4907 }
4908
4909 /****************************************************
4910 * Determine if parameter is a lazy array of delegates.
4911 * If so, return the return type of those delegates.
4912 * If not, return NULL.
4913 *
4914 * Returns T if the type is one of the following forms:
4915 * T delegate()[]
4916 * T delegate()[dim]
4917 */
4918 Type isLazyArray()
4919 {
4920 Type tb = type.toBasetype();
4921 if (tb.ty == Tsarray || tb.ty == Tarray)
4922 {
4923 Type tel = (cast(TypeArray)tb).next.toBasetype();
4924 if (auto td = tel.isTypeDelegate())
4925 {
4926 TypeFunction tf = td.next.toTypeFunction();
4927 if (tf.parameterList.varargs == VarArg.none && tf.parameterList.length == 0)
4928 {
4929 return tf.next; // return type of delegate
4930 }
4931 }
4932 }
4933 return null;
4934 }
4935
4936 /// Returns: Whether the function parameter is lazy
4937 bool isLazy() const @safe pure nothrow @nogc
4938 {
4939 return (this.storageClass & (STC.lazy_)) != 0;
4940 }
4941
4942 /// Returns: Whether the function parameter is a reference (out / ref)
4943 bool isReference() const @safe pure nothrow @nogc
4944 {
4945 return (this.storageClass & (STC.ref_ | STC.out_)) != 0;
4946 }
4947
4948 // kludge for template.isType()
4949 override DYNCAST dyncast() const
4950 {
4951 return DYNCAST.parameter;
4952 }
4953
4954 override void accept(Visitor v)
4955 {
4956 v.visit(this);
4957 }
4958
4959 extern (D) static Parameters* arraySyntaxCopy(Parameters* parameters)
4960 {
4961 Parameters* params = null;
4962 if (parameters)
4963 {
4964 params = new Parameters(parameters.length);
4965 for (size_t i = 0; i < params.length; i++)
4966 (*params)[i] = (*parameters)[i].syntaxCopy();
4967 }
4968 return params;
4969 }
4970
4971 /***************************************
4972 * Determine number of arguments, folding in tuples.
4973 */
4974 static size_t dim(Parameters* parameters)
4975 {
4976 size_t nargs = 0;
4977
4978 int dimDg(size_t n, Parameter p)
4979 {
4980 ++nargs;
4981 return 0;
4982 }
4983
4984 _foreach(parameters, &dimDg);
4985 return nargs;
4986 }
4987
4988 /**
4989 * Get nth `Parameter`, folding in tuples.
4990 *
4991 * Since `parameters` can include tuples, which would increase its
4992 * length, this function allows to get the `nth` parameter as if
4993 * all tuples transitively contained in `parameters` were flattened.
4994 *
4995 * Params:
4996 * parameters = Array of `Parameter` to iterate over
4997 * nth = Index of the desired parameter.
4998 *
4999 * Returns:
5000 * The parameter at index `nth` (taking tuples into account),
5001 * or `null` if out of bound.
5002 */
5003 static Parameter getNth(Parameters* parameters, size_t nth)
5004 {
5005 Parameter param;
5006
5007 int getNthParamDg(size_t n, Parameter p)
5008 {
5009 if (n == nth)
5010 {
5011 param = p;
5012 return 1;
5013 }
5014 return 0;
5015 }
5016
5017 int res = _foreach(parameters, &getNthParamDg);
5018 return res ? param : null;
5019 }
5020
5021 /// Type of delegate when iterating solely on the parameters
5022 alias ForeachDg = extern (D) int delegate(size_t paramidx, Parameter param);
5023 /// Type of delegate when iterating on both the original set of parameters,
5024 /// and the type tuple. Useful for semantic analysis.
5025 /// 'o' stands for 'original' and 'e' stands for 'expanded'.
5026 alias SemanticForeachDg = extern (D) int delegate(
5027 size_t oidx, Parameter oparam, size_t eidx, Parameter eparam);
5028
5029 /***************************************
5030 * Expands tuples in args in depth first order. Calls
5031 * dg(void *ctx, size_t argidx, Parameter *arg) for each Parameter.
5032 * If dg returns !=0, stops and returns that value else returns 0.
5033 * Use this function to avoid the O(N + N^2/2) complexity of
5034 * calculating dim and calling N times getNth.
5035 */
5036 extern (D) static int _foreach(Parameters* parameters, scope ForeachDg dg)
5037 {
5038 assert(dg !is null);
5039 return _foreach(parameters, (_oidx, _oparam, idx, param) => dg(idx, param));
5040 }
5041
5042 /// Ditto
5043 extern (D) static int _foreach(
5044 Parameters* parameters, scope SemanticForeachDg dg)
5045 {
5046 assert(dg !is null);
5047 if (parameters is null)
5048 return 0;
5049
5050 size_t eidx;
5051 foreach (oidx; 0 .. parameters.length)
5052 {
5053 Parameter oparam = (*parameters)[oidx];
5054 if (auto r = _foreachImpl(dg, oidx, oparam, eidx, /* eparam */ oparam))
5055 return r;
5056 }
5057 return 0;
5058 }
5059
5060 /// Implementation of the iteration process, which recurses in itself
5061 /// and just forwards `oidx` and `oparam`.
5062 extern (D) private static int _foreachImpl(scope SemanticForeachDg dg,
5063 size_t oidx, Parameter oparam, ref size_t eidx, Parameter eparam)
5064 {
5065 if (eparam is null)
5066 return 0;
5067
5068 Type t = eparam.type.toBasetype();
5069 if (auto tu = t.isTypeTuple())
5070 {
5071 // Check for empty tuples
5072 if (tu.arguments is null)
5073 return 0;
5074
5075 foreach (nidx; 0 .. tu.arguments.length)
5076 {
5077 Parameter nextep = (*tu.arguments)[nidx];
5078 if (auto r = _foreachImpl(dg, oidx, oparam, eidx, nextep))
5079 return r;
5080 }
5081 }
5082 else
5083 {
5084 if (auto r = dg(oidx, oparam, eidx, eparam))
5085 return r;
5086 // The only place where we should increment eidx is here,
5087 // as a TypeTuple doesn't count as a parameter (for arity)
5088 // it it is empty.
5089 eidx++;
5090 }
5091 return 0;
5092 }
5093
5094 override const(char)* toChars() const
5095 {
5096 return ident ? ident.toChars() : "__anonymous_param";
5097 }
5098
5099 /*********************************
5100 * Compute covariance of parameters `this` and `p`
5101 * as determined by the storage classes of both.
5102 *
5103 * Params:
5104 * returnByRef = true if the function returns by ref
5105 * p = Parameter to compare with
5106 * Returns:
5107 * true = `this` can be used in place of `p`
5108 * false = nope
5109 */
5110 bool isCovariant(bool returnByRef, const Parameter p)
5111 const pure nothrow @nogc @safe
5112 {
5113 ulong thisSTC = this.storageClass;
5114 ulong otherSTC = p.storageClass;
5115
5116 if (thisSTC & STC.constscoperef)
5117 thisSTC |= STC.scope_;
5118 if (otherSTC & STC.constscoperef)
5119 otherSTC |= STC.scope_;
5120
5121 const mask = STC.ref_ | STC.out_ | STC.lazy_ | (((thisSTC | otherSTC) & STC.constscoperef) ? STC.in_ : 0);
5122 if ((thisSTC & mask) != (otherSTC & mask))
5123 return false;
5124 return isCovariantScope(returnByRef, thisSTC, otherSTC);
5125 }
5126
5127 extern (D) static bool isCovariantScope(bool returnByRef, StorageClass from, StorageClass to) pure nothrow @nogc @safe
5128 {
5129 // Workaround for failing covariance when finding a common type of delegates,
5130 // some of which have parameters with inferred scope
5131 // https://issues.dlang.org/show_bug.cgi?id=21285
5132 // The root cause is that scopeinferred is not part of the mangle, and mangle
5133 // is used for type equality checks
5134 if (to & STC.returninferred)
5135 to &= ~STC.return_;
5136 // note: f(return int* x) currently 'infers' scope without inferring `return`, in that case keep STC.scope
5137 if (to & STC.scopeinferred && !(to & STC.return_))
5138 to &= ~STC.scope_;
5139
5140 if (from == to)
5141 return true;
5142
5143 /* result is true if the 'from' can be used as a 'to'
5144 */
5145
5146 if ((from ^ to) & STC.ref_) // differing in 'ref' means no covariance
5147 return false;
5148
5149 /* workaround until we get STC.returnScope reliably set correctly
5150 */
5151 if (returnByRef)
5152 {
5153 from &= ~STC.returnScope;
5154 to &= ~STC.returnScope;
5155 }
5156 else
5157 {
5158 from |= STC.returnScope;
5159 to |= STC.returnScope;
5160 }
5161 return covariant[buildScopeRef(from)][buildScopeRef(to)];
5162 }
5163
5164 extern (D) private static bool[ScopeRef.max + 1][ScopeRef.max + 1] covariantInit() pure nothrow @nogc @safe
5165 {
5166 /* Initialize covariant[][] with this:
5167
5168 From\To n rs s
5169 None X
5170 ReturnScope X X
5171 Scope X X X
5172
5173 From\To r rr rs rr-s r-rs
5174 Ref X X
5175 ReturnRef X
5176 RefScope X X X X X
5177 ReturnRef-Scope X X
5178 Ref-ReturnScope X X X
5179 */
5180 bool[ScopeRef.max + 1][ScopeRef.max + 1] covariant;
5181
5182 foreach (i; 0 .. ScopeRef.max + 1)
5183 {
5184 covariant[i][i] = true;
5185 covariant[ScopeRef.RefScope][i] = true;
5186 }
5187 covariant[ScopeRef.ReturnScope][ScopeRef.None] = true;
5188 covariant[ScopeRef.Scope ][ScopeRef.None] = true;
5189 covariant[ScopeRef.Scope ][ScopeRef.ReturnScope] = true;
5190
5191 covariant[ScopeRef.Ref ][ScopeRef.ReturnRef] = true;
5192 covariant[ScopeRef.ReturnRef_Scope][ScopeRef.ReturnRef] = true;
5193 covariant[ScopeRef.Ref_ReturnScope][ScopeRef.Ref ] = true;
5194 covariant[ScopeRef.Ref_ReturnScope][ScopeRef.ReturnRef] = true;
5195
5196 return covariant;
5197 }
5198
5199 extern (D) private static immutable bool[ScopeRef.max + 1][ScopeRef.max + 1] covariant = covariantInit();
5200
5201 extern (D) bool opEquals(const Parameter other) const
5202 {
5203 return this.storageClass == other.storageClass
5204 && this.type == other.type;
5205 }
5206 }
5207
5208 /*************************************************************
5209 * For printing two types with qualification when necessary.
5210 * Params:
5211 * t1 = The first type to receive the type name for
5212 * t2 = The second type to receive the type name for
5213 * Returns:
5214 * The fully-qualified names of both types if the two type names are not the same,
5215 * or the unqualified names of both types if the two type names are the same.
5216 */
5217 const(char*)[2] toAutoQualChars(Type t1, Type t2)
5218 {
5219 auto s1 = t1.toChars();
5220 auto s2 = t2.toChars();
5221 // show qualification only if it's different
5222 if (!t1.equals(t2) && strcmp(s1, s2) == 0)
5223 {
5224 s1 = t1.toPrettyChars(true);
5225 s2 = t2.toPrettyChars(true);
5226 }
5227 return [s1, s2];
5228 }
5229
5230
5231 /**
5232 * For each active modifier (MODFlags.const_, MODFlags.immutable_, etc) call `fp` with a
5233 * void* for the work param and a string representation of the attribute.
5234 */
5235 void modifiersApply(const TypeFunction tf, void delegate(string) dg)
5236 {
5237 immutable ubyte[4] modsArr = [MODFlags.const_, MODFlags.immutable_, MODFlags.wild, MODFlags.shared_];
5238
5239 foreach (modsarr; modsArr)
5240 {
5241 if (tf.mod & modsarr)
5242 {
5243 dg(MODtoString(modsarr));
5244 }
5245 }
5246 }
5247
5248 /**
5249 * For each active attribute (ref/const/nogc/etc) call `fp` with a void* for the
5250 * work param and a string representation of the attribute.
5251 */
5252 void attributesApply(const TypeFunction tf, void delegate(string) dg, TRUSTformat trustFormat = TRUSTformatDefault)
5253 {
5254 if (tf.purity)
5255 dg("pure");
5256 if (tf.isnothrow)
5257 dg("nothrow");
5258 if (tf.isnogc)
5259 dg("@nogc");
5260 if (tf.isproperty)
5261 dg("@property");
5262 if (tf.isref)
5263 dg("ref");
5264 if (tf.isreturn && !tf.isreturninferred)
5265 dg("return");
5266 if (tf.isScopeQual && !tf.isscopeinferred)
5267 dg("scope");
5268 if (tf.islive)
5269 dg("@live");
5270
5271 TRUST trustAttrib = tf.trust;
5272
5273 if (trustAttrib == TRUST.default_)
5274 {
5275 if (trustFormat != TRUSTformatSystem)
5276 return;
5277 trustAttrib = TRUST.system; // avoid calling with an empty string
5278 }
5279
5280 dg(trustToString(trustAttrib));
5281 }
5282
5283 /**
5284 * If the type is a class or struct, returns the symbol for it,
5285 * else null.
5286 */
5287 AggregateDeclaration isAggregate(Type t)
5288 {
5289 t = t.toBasetype();
5290 if (t.ty == Tclass)
5291 return (cast(TypeClass)t).sym;
5292 if (t.ty == Tstruct)
5293 return (cast(TypeStruct)t).sym;
5294 return null;
5295 }
5296
5297 /***************************************************
5298 * Determine if type t can be indexed or sliced given that it is not an
5299 * aggregate with operator overloads.
5300 * Params:
5301 * t = type to check
5302 * Returns:
5303 * true if an expression of type t can be e1 in an array expression
5304 */
5305 bool isIndexableNonAggregate(Type t)
5306 {
5307 t = t.toBasetype();
5308 return (t.ty == Tpointer || t.ty == Tsarray || t.ty == Tarray || t.ty == Taarray ||
5309 t.ty == Ttuple || t.ty == Tvector);
5310 }
5311
5312 /***************************************
5313 * Computes how a parameter may be returned.
5314 * Shrinking the representation is necessary because StorageClass is so wide
5315 * Params:
5316 * stc = storage class of parameter
5317 * Returns:
5318 * value from enum ScopeRef
5319 */
5320 ScopeRef buildScopeRef(StorageClass stc) pure nothrow @nogc @safe
5321 {
5322 if (stc & STC.out_)
5323 stc |= STC.ref_; // treat `out` and `ref` the same
5324
5325 ScopeRef result;
5326 final switch (stc & (STC.ref_ | STC.scope_ | STC.return_))
5327 {
5328 case 0: result = ScopeRef.None; break;
5329
5330 /* can occur in case test/compilable/testsctreturn.d
5331 * related to https://issues.dlang.org/show_bug.cgi?id=20149
5332 * where inout adds `return` without `scope` or `ref`
5333 */
5334 case STC.return_: result = ScopeRef.Return; break;
5335
5336 case STC.ref_: result = ScopeRef.Ref; break;
5337 case STC.scope_: result = ScopeRef.Scope; break;
5338 case STC.return_ | STC.ref_: result = ScopeRef.ReturnRef; break;
5339 case STC.return_ | STC.scope_: result = ScopeRef.ReturnScope; break;
5340 case STC.ref_ | STC.scope_: result = ScopeRef.RefScope; break;
5341
5342 case STC.return_ | STC.ref_ | STC.scope_:
5343 result = stc & STC.returnScope ? ScopeRef.Ref_ReturnScope
5344 : ScopeRef.ReturnRef_Scope;
5345 break;
5346 }
5347 return result;
5348 }
5349
5350 /**
5351 * Classification of 'scope-return-ref' possibilities
5352 */
5353 enum ScopeRef
5354 {
5355 None,
5356 Scope,
5357 ReturnScope,
5358 Ref,
5359 ReturnRef,
5360 RefScope,
5361 ReturnRef_Scope,
5362 Ref_ReturnScope,
5363 Return,
5364 }
5365
5366 /*********************************
5367 * Give us a nice string for debugging purposes.
5368 * Params:
5369 * sr = value
5370 * Returns:
5371 * corresponding string
5372 */
5373 const(char)* ScopeRefToChars(ScopeRef sr) pure nothrow @nogc @safe
5374 {
5375 with (ScopeRef)
5376 {
5377 static immutable char*[ScopeRef.max + 1] names =
5378 [
5379 None: "None",
5380 Scope: "Scope",
5381 ReturnScope: "ReturnScope",
5382 Ref: "Ref",
5383 ReturnRef: "ReturnRef",
5384 RefScope: "RefScope",
5385 ReturnRef_Scope: "ReturnRef_Scope",
5386 Ref_ReturnScope: "Ref_ReturnScope",
5387 Return: "Return",
5388 ];
5389 return names[sr];
5390 }
5391 }
5392
5393 /**
5394 * Creates an appropriate vector type for `tv` that will hold one boolean
5395 * result for each element of the vector type. The result of vector comparisons
5396 * is a single or doubleword mask of all 1s (comparison true) or all 0s
5397 * (comparison false). This SIMD mask type does not have an equivalent D type,
5398 * however its closest equivalent would be an integer vector of the same unit
5399 * size and length.
5400 *
5401 * Params:
5402 * tv = The `TypeVector` to build a vector from.
5403 * Returns:
5404 * A vector type suitable for the result of a vector comparison operation.
5405 */
5406 TypeVector toBooleanVector(TypeVector tv)
5407 {
5408 Type telem = tv.elementType();
5409 switch (telem.ty)
5410 {
5411 case Tvoid:
5412 case Tint8:
5413 case Tuns8:
5414 case Tint16:
5415 case Tuns16:
5416 case Tint32:
5417 case Tuns32:
5418 case Tint64:
5419 case Tuns64:
5420 // No need to build an equivalent mask type.
5421 return tv;
5422
5423 case Tfloat32:
5424 telem = Type.tuns32;
5425 break;
5426
5427 case Tfloat64:
5428 telem = Type.tuns64;
5429 break;
5430
5431 default:
5432 assert(0);
5433 }
5434
5435 TypeSArray tsa = tv.basetype.isTypeSArray();
5436 assert(tsa !is null);
5437
5438 return new TypeVector(new TypeSArray(telem, tsa.dim));
5439 }
5440
5441 /*************************************************
5442 * Dispatch to function based on static type of Type.
5443 */
5444 mixin template VisitType(Result)
5445 {
5446 Result VisitType(Type t)
5447 {
5448 final switch (t.ty)
5449 {
5450 case TY.Tvoid:
5451 case TY.Tint8:
5452 case TY.Tuns8:
5453 case TY.Tint16:
5454 case TY.Tuns16:
5455 case TY.Tint32:
5456 case TY.Tuns32:
5457 case TY.Tint64:
5458 case TY.Tuns64:
5459 case TY.Tfloat32:
5460 case TY.Tfloat64:
5461 case TY.Tfloat80:
5462 case TY.Timaginary32:
5463 case TY.Timaginary64:
5464 case TY.Timaginary80:
5465 case TY.Tcomplex32:
5466 case TY.Tcomplex64:
5467 case TY.Tcomplex80:
5468 case TY.Tbool:
5469 case TY.Tchar:
5470 case TY.Twchar:
5471 case TY.Tdchar:
5472 case TY.Tint128:
5473 case TY.Tuns128: mixin(visitTYCase("Basic"));
5474 case TY.Tarray: mixin(visitTYCase("DArray"));
5475 case TY.Tsarray: mixin(visitTYCase("SArray"));
5476 case TY.Taarray: mixin(visitTYCase("AArray"));
5477 case TY.Tpointer: mixin(visitTYCase("Pointer"));
5478 case TY.Treference: mixin(visitTYCase("Reference"));
5479 case TY.Tfunction: mixin(visitTYCase("Function"));
5480 case TY.Tident: mixin(visitTYCase("Identifier"));
5481 case TY.Tclass: mixin(visitTYCase("Class"));
5482 case TY.Tstruct: mixin(visitTYCase("Struct"));
5483 case TY.Tenum: mixin(visitTYCase("Enum"));
5484 case TY.Tdelegate: mixin(visitTYCase("Delegate"));
5485 case TY.Terror: mixin(visitTYCase("Error"));
5486 case TY.Tinstance: mixin(visitTYCase("Instance"));
5487 case TY.Ttypeof: mixin(visitTYCase("Typeof"));
5488 case TY.Ttuple: mixin(visitTYCase("Tuple"));
5489 case TY.Tslice: mixin(visitTYCase("Slice"));
5490 case TY.Treturn: mixin(visitTYCase("Return"));
5491 case TY.Tnull: mixin(visitTYCase("Null"));
5492 case TY.Tvector: mixin(visitTYCase("Vector"));
5493 case TY.Ttraits: mixin(visitTYCase("Traits"));
5494 case TY.Tmixin: mixin(visitTYCase("Mixin"));
5495 case TY.Tnoreturn: mixin(visitTYCase("Noreturn"));
5496 case TY.Ttag: mixin(visitTYCase("Tag"));
5497 case TY.Tnone: assert(0);
5498 }
5499 }
5500 }
5501
5502 /****************************************
5503 * CTFE-only helper function for VisitInitializer.
5504 * Params:
5505 * handler = string for the name of the visit handler
5506 * Returns: boilerplate code for a case
5507 */
5508 pure string visitTYCase(string handler) @safe
5509 {
5510 if (__ctfe)
5511 {
5512 return
5513 "
5514 enum isVoid = is(Result == void);
5515 auto tx = t.isType"~handler~"();
5516 static if (__traits(compiles, visit"~handler~"(tx)))
5517 {
5518 static if (isVoid)
5519 {
5520 visit"~handler~"(tx);
5521 return;
5522 }
5523 else
5524 {
5525 if (Result r = visit"~handler~"(tx))
5526 return r;
5527 return Result.init;
5528 }
5529 }
5530 else static if (__traits(compiles, visitDefaultCase(t)))
5531 {
5532 static if (isVoid)
5533 {
5534 visitDefaultCase(tx);
5535 return;
5536 }
5537 else
5538 {
5539 if (Result r = visitDefaultCase(t))
5540 return r;
5541 return Result.init;
5542 }
5543 }
5544 else
5545 static assert(0, "~handler~");
5546 ";
5547 }
5548 assert(0);
5549 }
5550
5551
5552 /**
5553 * Returns:
5554 * `TypeIdentifier` corresponding to `object.Throwable`
5555 */
5556 TypeIdentifier getThrowable()
5557 {
5558 auto tid = new TypeIdentifier(Loc.initial, Id.empty);
5559 tid.addIdent(Id.object);
5560 tid.addIdent(Id.Throwable);
5561 return tid;
5562 }
5563
5564 /**
5565 * Returns:
5566 * TypeIdentifier corresponding to `object.Exception`
5567 */
5568 TypeIdentifier getException()
5569 {
5570 auto tid = new TypeIdentifier(Loc.initial, Id.empty);
5571 tid.addIdent(Id.object);
5572 tid.addIdent(Id.Exception);
5573 return tid;
5574 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org