1 /** 2 * Defines a D type. 3 * 4 * Copyright: Copyright (C) 1999-2020 by The D Language Foundation, All Rights Reserved 5 * Authors: $(LINK2 http://www.digitalmars.com, Walter Bright) 6 * License: $(LINK2 http://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.attrib; 23 import dmd.ast_node; 24 import dmd.gluelayer; 25 import dmd.dclass; 26 import dmd.declaration; 27 import dmd.denum; 28 import dmd.dmangle; 29 import dmd.dscope; 30 import dmd.dstruct; 31 import dmd.dsymbol; 32 import dmd.dsymbolsem; 33 import dmd.dtemplate; 34 import dmd.errors; 35 import dmd.expression; 36 import dmd.expressionsem; 37 import dmd.func; 38 import dmd.globals; 39 import dmd.hdrgen; 40 import dmd.id; 41 import dmd.identifier; 42 import dmd.init; 43 import dmd.opover; 44 import dmd.root.ctfloat; 45 import dmd.root.outbuffer; 46 import dmd.root.rmem; 47 import dmd.root.rootobject; 48 import dmd.root.stringtable; 49 import dmd.target; 50 import dmd.tokens; 51 import dmd.typesem; 52 import dmd.visitor; 53 54 enum LOGDOTEXP = 0; // log ::dotExp() 55 enum LOGDEFAULTINIT = 0; // log ::defaultInit() 56 57 enum SIZE_INVALID = (~cast(d_uns64)0); // error return from size() functions 58 59 60 /*************************** 61 * Return !=0 if modfrom can be implicitly converted to modto 62 */ 63 bool MODimplicitConv(MOD modfrom, MOD modto) pure nothrow @nogc @safe 64 { 65 if (modfrom == modto) 66 return true; 67 68 //printf("MODimplicitConv(from = %x, to = %x)\n", modfrom, modto); 69 auto X(T, U)(T m, U n) 70 { 71 return ((m << 4) | n); 72 } 73 74 switch (X(modfrom & ~MODFlags.shared_, modto & ~MODFlags.shared_)) 75 { 76 case X(0, MODFlags.const_): 77 case X(MODFlags.wild, MODFlags.const_): 78 case X(MODFlags.wild, MODFlags.wildconst): 79 case X(MODFlags.wildconst, MODFlags.const_): 80 return (modfrom & MODFlags.shared_) == (modto & MODFlags.shared_); 81 82 case X(MODFlags.immutable_, MODFlags.const_): 83 case X(MODFlags.immutable_, MODFlags.wildconst): 84 return true; 85 default: 86 return false; 87 } 88 } 89 90 /*************************** 91 * Return MATCH.exact or MATCH.constant if a method of type '() modfrom' can call a method of type '() modto'. 92 */ 93 MATCH MODmethodConv(MOD modfrom, MOD modto) pure nothrow @nogc @safe 94 { 95 if (modfrom == modto) 96 return MATCH.exact; 97 if (MODimplicitConv(modfrom, modto)) 98 return MATCH.constant; 99 100 auto X(T, U)(T m, U n) 101 { 102 return ((m << 4) | n); 103 } 104 105 switch (X(modfrom, modto)) 106 { 107 case X(0, MODFlags.wild): 108 case X(MODFlags.immutable_, MODFlags.wild): 109 case X(MODFlags.const_, MODFlags.wild): 110 case X(MODFlags.wildconst, MODFlags.wild): 111 case X(MODFlags.shared_, MODFlags.shared_ | MODFlags.wild): 112 case X(MODFlags.shared_ | MODFlags.immutable_, MODFlags.shared_ | MODFlags.wild): 113 case X(MODFlags.shared_ | MODFlags.const_, MODFlags.shared_ | MODFlags.wild): 114 case X(MODFlags.shared_ | MODFlags.wildconst, MODFlags.shared_ | MODFlags.wild): 115 return MATCH.constant; 116 117 default: 118 return MATCH.nomatch; 119 } 120 } 121 122 /*************************** 123 * Merge mod bits to form common mod. 124 */ 125 MOD MODmerge(MOD mod1, MOD mod2) pure nothrow @nogc @safe 126 { 127 if (mod1 == mod2) 128 return mod1; 129 130 //printf("MODmerge(1 = %x, 2 = %x)\n", mod1, mod2); 131 MOD result = 0; 132 if ((mod1 | mod2) & MODFlags.shared_) 133 { 134 // If either type is shared, the result will be shared 135 result |= MODFlags.shared_; 136 mod1 &= ~MODFlags.shared_; 137 mod2 &= ~MODFlags.shared_; 138 } 139 if (mod1 == 0 || mod1 == MODFlags.mutable || mod1 == MODFlags.const_ || mod2 == 0 || mod2 == MODFlags.mutable || mod2 == MODFlags.const_) 140 { 141 // If either type is mutable or const, the result will be const. 142 result |= MODFlags.const_; 143 } 144 else 145 { 146 // MODFlags.immutable_ vs MODFlags.wild 147 // MODFlags.immutable_ vs MODFlags.wildconst 148 // MODFlags.wild vs MODFlags.wildconst 149 assert(mod1 & MODFlags.wild || mod2 & MODFlags.wild); 150 result |= MODFlags.wildconst; 151 } 152 return result; 153 } 154 155 /********************************* 156 * Store modifier name into buf. 157 */ 158 void MODtoBuffer(OutBuffer* buf, MOD mod) nothrow 159 { 160 buf.writestring(MODtoString(mod)); 161 } 162 163 /********************************* 164 * Returns: 165 * a human readable representation of `mod`, 166 * which is the token `mod` corresponds to 167 */ 168 const(char)* MODtoChars(MOD mod) nothrow pure 169 { 170 /// Works because we return a literal 171 return MODtoString(mod).ptr; 172 } 173 174 /// Ditto 175 string MODtoString(MOD mod) nothrow pure 176 { 177 final switch (mod) 178 { 179 case 0: 180 return ""; 181 182 case MODFlags.immutable_: 183 return "immutable"; 184 185 case MODFlags.shared_: 186 return "shared"; 187 188 case MODFlags.shared_ | MODFlags.const_: 189 return "shared const"; 190 191 case MODFlags.const_: 192 return "const"; 193 194 case MODFlags.shared_ | MODFlags.wild: 195 return "shared inout"; 196 197 case MODFlags.wild: 198 return "inout"; 199 200 case MODFlags.shared_ | MODFlags.wildconst: 201 return "shared inout const"; 202 203 case MODFlags.wildconst: 204 return "inout const"; 205 } 206 } 207 208 209 /************************************ 210 * Convert MODxxxx to STCxxx 211 */ 212 StorageClass ModToStc(uint mod) pure nothrow @nogc @safe 213 { 214 StorageClass stc = 0; 215 if (mod & MODFlags.immutable_) 216 stc |= STC.immutable_; 217 if (mod & MODFlags.const_) 218 stc |= STC.const_; 219 if (mod & MODFlags.wild) 220 stc |= STC.wild; 221 if (mod & MODFlags.shared_) 222 stc |= STC.shared_; 223 return stc; 224 } 225 226 private enum TFlags 227 { 228 integral = 1, 229 floating = 2, 230 unsigned = 4, 231 real_ = 8, 232 imaginary = 0x10, 233 complex = 0x20, 234 } 235 236 enum ENUMTY : int 237 { 238 Tarray, // slice array, aka T[] 239 Tsarray, // static array, aka T[dimension] 240 Taarray, // associative array, aka T[type] 241 Tpointer, 242 Treference, 243 Tfunction, 244 Tident, 245 Tclass, 246 Tstruct, 247 Tenum, 248 249 Tdelegate, 250 Tnone, 251 Tvoid, 252 Tint8, 253 Tuns8, 254 Tint16, 255 Tuns16, 256 Tint32, 257 Tuns32, 258 Tint64, 259 260 Tuns64, 261 Tfloat32, 262 Tfloat64, 263 Tfloat80, 264 Timaginary32, 265 Timaginary64, 266 Timaginary80, 267 Tcomplex32, 268 Tcomplex64, 269 Tcomplex80, 270 271 Tbool, 272 Tchar, 273 Twchar, 274 Tdchar, 275 Terror, 276 Tinstance, 277 Ttypeof, 278 Ttuple, 279 Tslice, 280 Treturn, 281 282 Tnull, 283 Tvector, 284 Tint128, 285 Tuns128, 286 Ttraits, 287 Tmixin, 288 TMAX, 289 } 290 291 alias Tarray = ENUMTY.Tarray; 292 alias Tsarray = ENUMTY.Tsarray; 293 alias Taarray = ENUMTY.Taarray; 294 alias Tpointer = ENUMTY.Tpointer; 295 alias Treference = ENUMTY.Treference; 296 alias Tfunction = ENUMTY.Tfunction; 297 alias Tident = ENUMTY.Tident; 298 alias Tclass = ENUMTY.Tclass; 299 alias Tstruct = ENUMTY.Tstruct; 300 alias Tenum = ENUMTY.Tenum; 301 alias Tdelegate = ENUMTY.Tdelegate; 302 alias Tnone = ENUMTY.Tnone; 303 alias Tvoid = ENUMTY.Tvoid; 304 alias Tint8 = ENUMTY.Tint8; 305 alias Tuns8 = ENUMTY.Tuns8; 306 alias Tint16 = ENUMTY.Tint16; 307 alias Tuns16 = ENUMTY.Tuns16; 308 alias Tint32 = ENUMTY.Tint32; 309 alias Tuns32 = ENUMTY.Tuns32; 310 alias Tint64 = ENUMTY.Tint64; 311 alias Tuns64 = ENUMTY.Tuns64; 312 alias Tfloat32 = ENUMTY.Tfloat32; 313 alias Tfloat64 = ENUMTY.Tfloat64; 314 alias Tfloat80 = ENUMTY.Tfloat80; 315 alias Timaginary32 = ENUMTY.Timaginary32; 316 alias Timaginary64 = ENUMTY.Timaginary64; 317 alias Timaginary80 = ENUMTY.Timaginary80; 318 alias Tcomplex32 = ENUMTY.Tcomplex32; 319 alias Tcomplex64 = ENUMTY.Tcomplex64; 320 alias Tcomplex80 = ENUMTY.Tcomplex80; 321 alias Tbool = ENUMTY.Tbool; 322 alias Tchar = ENUMTY.Tchar; 323 alias Twchar = ENUMTY.Twchar; 324 alias Tdchar = ENUMTY.Tdchar; 325 alias Terror = ENUMTY.Terror; 326 alias Tinstance = ENUMTY.Tinstance; 327 alias Ttypeof = ENUMTY.Ttypeof; 328 alias Ttuple = ENUMTY.Ttuple; 329 alias Tslice = ENUMTY.Tslice; 330 alias Treturn = ENUMTY.Treturn; 331 alias Tnull = ENUMTY.Tnull; 332 alias Tvector = ENUMTY.Tvector; 333 alias Tint128 = ENUMTY.Tint128; 334 alias Tuns128 = ENUMTY.Tuns128; 335 alias Ttraits = ENUMTY.Ttraits; 336 alias Tmixin = ENUMTY.Tmixin; 337 alias TMAX = ENUMTY.TMAX; 338 339 alias TY = ubyte; 340 341 ///Returns true if ty is char, wchar, or dchar 342 bool isSomeChar(TY ty) pure nothrow @nogc @safe 343 { 344 return ty == Tchar || ty == Twchar || ty == Tdchar; 345 } 346 347 enum MODFlags : int 348 { 349 const_ = 1, // type is const 350 immutable_ = 4, // type is immutable 351 shared_ = 2, // type is shared 352 wild = 8, // type is wild 353 wildconst = (MODFlags.wild | MODFlags.const_), // type is wild const 354 mutable = 0x10, // type is mutable (only used in wildcard matching) 355 } 356 357 alias MOD = ubyte; 358 359 /**************** 360 * dotExp() bit flags 361 */ 362 enum DotExpFlag 363 { 364 gag = 1, // don't report "not a property" error and just return null 365 noDeref = 2, // the use of the expression will not attempt a dereference 366 } 367 368 /*************** 369 * Variadic argument lists 370 * https://dlang.org/spec/function.html#variadic 371 */ 372 enum VarArg 373 { 374 none = 0, /// fixed number of arguments 375 variadic = 1, /// (T t, ...) can be C-style (core.stdc.stdarg) or D-style (core.vararg) 376 typesafe = 2, /// (T t ...) typesafe https://dlang.org/spec/function.html#typesafe_variadic_functions 377 /// or https://dlang.org/spec/function.html#typesafe_variadic_functions 378 } 379 380 381 /*********************************************************** 382 */ 383 extern (C++) abstract class Type : ASTNode 384 { 385 TY ty; 386 MOD mod; // modifiers MODxxxx 387 char* deco; 388 389 /* These are cached values that are lazily evaluated by constOf(), immutableOf(), etc. 390 * They should not be referenced by anybody but mtype.c. 391 * They can be NULL if not lazily evaluated yet. 392 * Note that there is no "shared immutable", because that is just immutable 393 * Naked == no MOD bits 394 */ 395 Type cto; // MODFlags.const_ ? naked version of this type : const version 396 Type ito; // MODFlags.immutable_ ? naked version of this type : immutable version 397 Type sto; // MODFlags.shared_ ? naked version of this type : shared mutable version 398 Type scto; // MODFlags.shared_ | MODFlags.const_ ? naked version of this type : shared const version 399 Type wto; // MODFlags.wild ? naked version of this type : wild version 400 Type wcto; // MODFlags.wildconst ? naked version of this type : wild const version 401 Type swto; // MODFlags.shared_ | MODFlags.wild ? naked version of this type : shared wild version 402 Type swcto; // MODFlags.shared_ | MODFlags.wildconst ? naked version of this type : shared wild const version 403 404 Type pto; // merged pointer to this type 405 Type rto; // reference to this type 406 Type arrayof; // array of this type 407 408 TypeInfoDeclaration vtinfo; // TypeInfo object for this Type 409 410 type* ctype; // for back end 411 412 extern (C++) __gshared Type tvoid; 413 extern (C++) __gshared Type tint8; 414 extern (C++) __gshared Type tuns8; 415 extern (C++) __gshared Type tint16; 416 extern (C++) __gshared Type tuns16; 417 extern (C++) __gshared Type tint32; 418 extern (C++) __gshared Type tuns32; 419 extern (C++) __gshared Type tint64; 420 extern (C++) __gshared Type tuns64; 421 extern (C++) __gshared Type tint128; 422 extern (C++) __gshared Type tuns128; 423 extern (C++) __gshared Type tfloat32; 424 extern (C++) __gshared Type tfloat64; 425 extern (C++) __gshared Type tfloat80; 426 extern (C++) __gshared Type timaginary32; 427 extern (C++) __gshared Type timaginary64; 428 extern (C++) __gshared Type timaginary80; 429 extern (C++) __gshared Type tcomplex32; 430 extern (C++) __gshared Type tcomplex64; 431 extern (C++) __gshared Type tcomplex80; 432 extern (C++) __gshared Type tbool; 433 extern (C++) __gshared Type tchar; 434 extern (C++) __gshared Type twchar; 435 extern (C++) __gshared Type tdchar; 436 437 // Some special types 438 extern (C++) __gshared Type tshiftcnt; 439 extern (C++) __gshared Type tvoidptr; // void* 440 extern (C++) __gshared Type tstring; // immutable(char)[] 441 extern (C++) __gshared Type twstring; // immutable(wchar)[] 442 extern (C++) __gshared Type tdstring; // immutable(dchar)[] 443 extern (C++) __gshared Type tvalist; // va_list alias 444 extern (C++) __gshared Type terror; // for error recovery 445 extern (C++) __gshared Type tnull; // for null type 446 447 extern (C++) __gshared Type tsize_t; // matches size_t alias 448 extern (C++) __gshared Type tptrdiff_t; // matches ptrdiff_t alias 449 extern (C++) __gshared Type thash_t; // matches hash_t alias 450 451 extern (C++) __gshared ClassDeclaration dtypeinfo; 452 extern (C++) __gshared ClassDeclaration typeinfoclass; 453 extern (C++) __gshared ClassDeclaration typeinfointerface; 454 extern (C++) __gshared ClassDeclaration typeinfostruct; 455 extern (C++) __gshared ClassDeclaration typeinfopointer; 456 extern (C++) __gshared ClassDeclaration typeinfoarray; 457 extern (C++) __gshared ClassDeclaration typeinfostaticarray; 458 extern (C++) __gshared ClassDeclaration typeinfoassociativearray; 459 extern (C++) __gshared ClassDeclaration typeinfovector; 460 extern (C++) __gshared ClassDeclaration typeinfoenum; 461 extern (C++) __gshared ClassDeclaration typeinfofunction; 462 extern (C++) __gshared ClassDeclaration typeinfodelegate; 463 extern (C++) __gshared ClassDeclaration typeinfotypelist; 464 extern (C++) __gshared ClassDeclaration typeinfoconst; 465 extern (C++) __gshared ClassDeclaration typeinfoinvariant; 466 extern (C++) __gshared ClassDeclaration typeinfoshared; 467 extern (C++) __gshared ClassDeclaration typeinfowild; 468 469 extern (C++) __gshared TemplateDeclaration rtinfo; 470 471 extern (C++) __gshared Type[TMAX] basic; 472 473 extern (D) __gshared StringTable!Type stringtable; 474 extern (D) private __gshared ubyte[TMAX] sizeTy = () 475 { 476 ubyte[TMAX] sizeTy = __traits(classInstanceSize, TypeBasic); 477 sizeTy[Tsarray] = __traits(classInstanceSize, TypeSArray); 478 sizeTy[Tarray] = __traits(classInstanceSize, TypeDArray); 479 sizeTy[Taarray] = __traits(classInstanceSize, TypeAArray); 480 sizeTy[Tpointer] = __traits(classInstanceSize, TypePointer); 481 sizeTy[Treference] = __traits(classInstanceSize, TypeReference); 482 sizeTy[Tfunction] = __traits(classInstanceSize, TypeFunction); 483 sizeTy[Tdelegate] = __traits(classInstanceSize, TypeDelegate); 484 sizeTy[Tident] = __traits(classInstanceSize, TypeIdentifier); 485 sizeTy[Tinstance] = __traits(classInstanceSize, TypeInstance); 486 sizeTy[Ttypeof] = __traits(classInstanceSize, TypeTypeof); 487 sizeTy[Tenum] = __traits(classInstanceSize, TypeEnum); 488 sizeTy[Tstruct] = __traits(classInstanceSize, TypeStruct); 489 sizeTy[Tclass] = __traits(classInstanceSize, TypeClass); 490 sizeTy[Ttuple] = __traits(classInstanceSize, TypeTuple); 491 sizeTy[Tslice] = __traits(classInstanceSize, TypeSlice); 492 sizeTy[Treturn] = __traits(classInstanceSize, TypeReturn); 493 sizeTy[Terror] = __traits(classInstanceSize, TypeError); 494 sizeTy[Tnull] = __traits(classInstanceSize, TypeNull); 495 sizeTy[Tvector] = __traits(classInstanceSize, TypeVector); 496 sizeTy[Ttraits] = __traits(classInstanceSize, TypeTraits); 497 sizeTy[Tmixin] = __traits(classInstanceSize, TypeMixin); 498 return sizeTy; 499 }(); 500 501 final extern (D) this(TY ty) 502 { 503 this.ty = ty; 504 } 505 506 const(char)* kind() const nothrow pure @nogc @safe 507 { 508 assert(false); // should be overridden 509 } 510 511 final Type copy() nothrow const 512 { 513 Type t = cast(Type)mem.xmalloc(sizeTy[ty]); 514 memcpy(cast(void*)t, cast(void*)this, sizeTy[ty]); 515 return t; 516 } 517 518 Type syntaxCopy() 519 { 520 fprintf(stderr, "this = %s, ty = %d\n", toChars(), ty); 521 assert(0); 522 } 523 524 override bool equals(const RootObject o) const 525 { 526 Type t = cast(Type)o; 527 //printf("Type::equals(%s, %s)\n", toChars(), t.toChars()); 528 // deco strings are unique 529 // and semantic() has been run 530 if (this == o || ((t && deco == t.deco) && deco !is null)) 531 { 532 //printf("deco = '%s', t.deco = '%s'\n", deco, t.deco); 533 return true; 534 } 535 //if (deco && t && t.deco) printf("deco = '%s', t.deco = '%s'\n", deco, t.deco); 536 return false; 537 } 538 539 final bool equivalent(Type t) 540 { 541 return immutableOf().equals(t.immutableOf()); 542 } 543 544 // kludge for template.isType() 545 override final DYNCAST dyncast() const 546 { 547 return DYNCAST.type; 548 } 549 550 /******************************* 551 * Covariant means that 'this' can substitute for 't', 552 * i.e. a pure function is a match for an impure type. 553 * Params: 554 * t = type 'this' is covariant with 555 * pstc = if not null, store STCxxxx which would make it covariant 556 * fix17349 = enable fix https://issues.dlang.org/show_bug.cgi?id=17349 557 * Returns: 558 * 0 types are distinct 559 * 1 this is covariant with t 560 * 2 arguments match as far as overloading goes, 561 * but types are not covariant 562 * 3 cannot determine covariance because of forward references 563 * *pstc STCxxxx which would make it covariant 564 */ 565 final int covariant(Type t, StorageClass* pstc = null, bool fix17349 = true) 566 { 567 version (none) 568 { 569 printf("Type::covariant(t = %s) %s\n", t.toChars(), toChars()); 570 printf("deco = %p, %p\n", deco, t.deco); 571 // printf("ty = %d\n", next.ty); 572 printf("mod = %x, %x\n", mod, t.mod); 573 } 574 if (pstc) 575 *pstc = 0; 576 StorageClass stc = 0; 577 578 bool notcovariant = false; 579 580 if (equals(t)) 581 return 1; // covariant 582 583 TypeFunction t1 = this.isTypeFunction(); 584 TypeFunction t2 = t.isTypeFunction(); 585 586 if (!t1 || !t2) 587 goto Ldistinct; 588 589 if (t1.parameterList.varargs != t2.parameterList.varargs) 590 goto Ldistinct; 591 592 if (t1.parameterList.parameters && t2.parameterList.parameters) 593 { 594 size_t dim = t1.parameterList.length; 595 if (dim != t2.parameterList.length) 596 goto Ldistinct; 597 598 for (size_t i = 0; i < dim; i++) 599 { 600 Parameter fparam1 = t1.parameterList[i]; 601 Parameter fparam2 = t2.parameterList[i]; 602 603 if (!fparam1.type.equals(fparam2.type)) 604 { 605 if (!fix17349) 606 goto Ldistinct; 607 Type tp1 = fparam1.type; 608 Type tp2 = fparam2.type; 609 if (tp1.ty == tp2.ty) 610 { 611 if (auto tc1 = tp1.isTypeClass()) 612 { 613 if (tc1.sym == (cast(TypeClass)tp2).sym && MODimplicitConv(tp2.mod, tp1.mod)) 614 goto Lcov; 615 } 616 else if (auto ts1 = tp1.isTypeStruct()) 617 { 618 if (ts1.sym == (cast(TypeStruct)tp2).sym && MODimplicitConv(tp2.mod, tp1.mod)) 619 goto Lcov; 620 } 621 else if (tp1.ty == Tpointer) 622 { 623 if (tp2.implicitConvTo(tp1)) 624 goto Lcov; 625 } 626 else if (tp1.ty == Tarray) 627 { 628 if (tp2.implicitConvTo(tp1)) 629 goto Lcov; 630 } 631 else if (tp1.ty == Tdelegate) 632 { 633 if (tp1.implicitConvTo(tp2)) 634 goto Lcov; 635 } 636 } 637 goto Ldistinct; 638 } 639 Lcov: 640 notcovariant |= !fparam1.isCovariant(t1.isref, fparam2); 641 } 642 } 643 else if (t1.parameterList.parameters != t2.parameterList.parameters) 644 { 645 if (t1.parameterList.length || t2.parameterList.length) 646 goto Ldistinct; 647 } 648 649 // The argument lists match 650 if (notcovariant) 651 goto Lnotcovariant; 652 if (t1.linkage != t2.linkage) 653 goto Lnotcovariant; 654 655 { 656 // Return types 657 Type t1n = t1.next; 658 Type t2n = t2.next; 659 660 if (!t1n || !t2n) // happens with return type inference 661 goto Lnotcovariant; 662 663 if (t1n.equals(t2n)) 664 goto Lcovariant; 665 if (t1n.ty == Tclass && t2n.ty == Tclass) 666 { 667 /* If same class type, but t2n is const, then it's 668 * covariant. Do this test first because it can work on 669 * forward references. 670 */ 671 if ((cast(TypeClass)t1n).sym == (cast(TypeClass)t2n).sym && MODimplicitConv(t1n.mod, t2n.mod)) 672 goto Lcovariant; 673 674 // If t1n is forward referenced: 675 ClassDeclaration cd = (cast(TypeClass)t1n).sym; 676 if (cd.semanticRun < PASS.semanticdone && !cd.isBaseInfoComplete()) 677 cd.dsymbolSemantic(null); 678 if (!cd.isBaseInfoComplete()) 679 { 680 return 3; // forward references 681 } 682 } 683 if (t1n.ty == Tstruct && t2n.ty == Tstruct) 684 { 685 if ((cast(TypeStruct)t1n).sym == (cast(TypeStruct)t2n).sym && MODimplicitConv(t1n.mod, t2n.mod)) 686 goto Lcovariant; 687 } 688 else if (t1n.ty == t2n.ty && t1n.implicitConvTo(t2n)) 689 goto Lcovariant; 690 else if (t1n.ty == Tnull) 691 { 692 // NULL is covariant with any pointer type, but not with any 693 // dynamic arrays, associative arrays or delegates. 694 // https://issues.dlang.org/show_bug.cgi?id=8589 695 // https://issues.dlang.org/show_bug.cgi?id=19618 696 Type t2bn = t2n.toBasetype(); 697 if (t2bn.ty == Tnull || t2bn.ty == Tpointer || t2bn.ty == Tclass) 698 goto Lcovariant; 699 } 700 } 701 goto Lnotcovariant; 702 703 Lcovariant: 704 if (t1.isref != t2.isref) 705 goto Lnotcovariant; 706 707 if (!t1.isref && (t1.isscope || t2.isscope)) 708 { 709 StorageClass stc1 = t1.isscope ? STC.scope_ : 0; 710 StorageClass stc2 = t2.isscope ? STC.scope_ : 0; 711 if (t1.isreturn) 712 { 713 stc1 |= STC.return_; 714 if (!t1.isscope) 715 stc1 |= STC.ref_; 716 } 717 if (t2.isreturn) 718 { 719 stc2 |= STC.return_; 720 if (!t2.isscope) 721 stc2 |= STC.ref_; 722 } 723 if (!Parameter.isCovariantScope(t1.isref, stc1, stc2)) 724 goto Lnotcovariant; 725 } 726 727 // We can subtract 'return ref' from 'this', but cannot add it 728 else if (t1.isreturn && !t2.isreturn) 729 goto Lnotcovariant; 730 731 /* Can convert mutable to const 732 */ 733 if (!MODimplicitConv(t2.mod, t1.mod)) 734 { 735 version (none) 736 { 737 //stop attribute inference with const 738 // If adding 'const' will make it covariant 739 if (MODimplicitConv(t2.mod, MODmerge(t1.mod, MODFlags.const_))) 740 stc |= STC.const_; 741 else 742 goto Lnotcovariant; 743 } 744 else 745 { 746 goto Ldistinct; 747 } 748 } 749 750 /* Can convert pure to impure, nothrow to throw, and nogc to gc 751 */ 752 if (!t1.purity && t2.purity) 753 stc |= STC.pure_; 754 755 if (!t1.isnothrow && t2.isnothrow) 756 stc |= STC.nothrow_; 757 758 if (!t1.isnogc && t2.isnogc) 759 stc |= STC.nogc; 760 761 /* Can convert safe/trusted to system 762 */ 763 if (t1.trust <= TRUST.system && t2.trust >= TRUST.trusted) 764 { 765 // Should we infer trusted or safe? Go with safe. 766 stc |= STC.safe; 767 } 768 769 if (stc) 770 { 771 if (pstc) 772 *pstc = stc; 773 goto Lnotcovariant; 774 } 775 776 //printf("\tcovaraint: 1\n"); 777 return 1; 778 779 Ldistinct: 780 //printf("\tcovaraint: 0\n"); 781 return 0; 782 783 Lnotcovariant: 784 //printf("\tcovaraint: 2\n"); 785 return 2; 786 } 787 788 /******************************** 789 * For pretty-printing a type. 790 */ 791 final override const(char)* toChars() const 792 { 793 OutBuffer buf; 794 buf.reserve(16); 795 HdrGenState hgs; 796 hgs.fullQual = (ty == Tclass && !mod); 797 798 .toCBuffer(this, &buf, null, &hgs); 799 return buf.extractChars(); 800 } 801 802 /// ditto 803 final char* toPrettyChars(bool QualifyTypes = false) 804 { 805 OutBuffer buf; 806 buf.reserve(16); 807 HdrGenState hgs; 808 hgs.fullQual = QualifyTypes; 809 810 .toCBuffer(this, &buf, null, &hgs); 811 return buf.extractChars(); 812 } 813 814 static void _init() 815 { 816 stringtable._init(14000); 817 818 // Set basic types 819 __gshared TY* basetab = 820 [ 821 Tvoid, 822 Tint8, 823 Tuns8, 824 Tint16, 825 Tuns16, 826 Tint32, 827 Tuns32, 828 Tint64, 829 Tuns64, 830 Tint128, 831 Tuns128, 832 Tfloat32, 833 Tfloat64, 834 Tfloat80, 835 Timaginary32, 836 Timaginary64, 837 Timaginary80, 838 Tcomplex32, 839 Tcomplex64, 840 Tcomplex80, 841 Tbool, 842 Tchar, 843 Twchar, 844 Tdchar, 845 Terror 846 ]; 847 848 for (size_t i = 0; basetab[i] != Terror; i++) 849 { 850 Type t = new TypeBasic(basetab[i]); 851 t = t.merge(); 852 basic[basetab[i]] = t; 853 } 854 basic[Terror] = new TypeError(); 855 856 tvoid = basic[Tvoid]; 857 tint8 = basic[Tint8]; 858 tuns8 = basic[Tuns8]; 859 tint16 = basic[Tint16]; 860 tuns16 = basic[Tuns16]; 861 tint32 = basic[Tint32]; 862 tuns32 = basic[Tuns32]; 863 tint64 = basic[Tint64]; 864 tuns64 = basic[Tuns64]; 865 tint128 = basic[Tint128]; 866 tuns128 = basic[Tuns128]; 867 tfloat32 = basic[Tfloat32]; 868 tfloat64 = basic[Tfloat64]; 869 tfloat80 = basic[Tfloat80]; 870 871 timaginary32 = basic[Timaginary32]; 872 timaginary64 = basic[Timaginary64]; 873 timaginary80 = basic[Timaginary80]; 874 875 tcomplex32 = basic[Tcomplex32]; 876 tcomplex64 = basic[Tcomplex64]; 877 tcomplex80 = basic[Tcomplex80]; 878 879 tbool = basic[Tbool]; 880 tchar = basic[Tchar]; 881 twchar = basic[Twchar]; 882 tdchar = basic[Tdchar]; 883 884 tshiftcnt = tint32; 885 terror = basic[Terror]; 886 tnull = basic[Tnull]; 887 tnull = new TypeNull(); 888 tnull.deco = tnull.merge().deco; 889 890 tvoidptr = tvoid.pointerTo(); 891 tstring = tchar.immutableOf().arrayOf(); 892 twstring = twchar.immutableOf().arrayOf(); 893 tdstring = tdchar.immutableOf().arrayOf(); 894 tvalist = target.va_listType(); 895 896 const isLP64 = global.params.isLP64; 897 898 tsize_t = basic[isLP64 ? Tuns64 : Tuns32]; 899 tptrdiff_t = basic[isLP64 ? Tint64 : Tint32]; 900 thash_t = tsize_t; 901 } 902 903 /** 904 * Deinitializes the global state of the compiler. 905 * 906 * This can be used to restore the state set by `_init` to its original 907 * state. 908 */ 909 static void deinitialize() 910 { 911 stringtable = stringtable.init; 912 } 913 914 final d_uns64 size() 915 { 916 return size(Loc.initial); 917 } 918 919 d_uns64 size(const ref Loc loc) 920 { 921 error(loc, "no size for type `%s`", toChars()); 922 return SIZE_INVALID; 923 } 924 925 uint alignsize() 926 { 927 return cast(uint)size(Loc.initial); 928 } 929 930 final Type trySemantic(const ref Loc loc, Scope* sc) 931 { 932 //printf("+trySemantic(%s) %d\n", toChars(), global.errors); 933 934 // Needed to display any deprecations that were gagged 935 auto tcopy = this.syntaxCopy(); 936 937 const errors = global.startGagging(); 938 Type t = typeSemantic(this, loc, sc); 939 if (global.endGagging(errors) || t.ty == Terror) // if any errors happened 940 { 941 t = null; 942 } 943 else 944 { 945 // If `typeSemantic` succeeded, there may have been deprecations that 946 // were gagged due the the `startGagging` above. Run again to display 947 // those deprecations. https://issues.dlang.org/show_bug.cgi?id=19107 948 if (global.gaggedWarnings > 0) 949 typeSemantic(tcopy, loc, sc); 950 } 951 //printf("-trySemantic(%s) %d\n", toChars(), global.errors); 952 return t; 953 } 954 955 /************************************* 956 * This version does a merge even if the deco is already computed. 957 * Necessary for types that have a deco, but are not merged. 958 */ 959 final Type merge2() 960 { 961 //printf("merge2(%s)\n", toChars()); 962 Type t = this; 963 assert(t); 964 if (!t.deco) 965 return t.merge(); 966 967 auto sv = stringtable.lookup(t.deco, strlen(t.deco)); 968 if (sv && sv.value) 969 { 970 t = sv.value; 971 assert(t.deco); 972 } 973 else 974 assert(0); 975 return t; 976 } 977 978 /********************************* 979 * Store this type's modifier name into buf. 980 */ 981 final void modToBuffer(OutBuffer* buf) nothrow const 982 { 983 if (mod) 984 { 985 buf.writeByte(' '); 986 MODtoBuffer(buf, mod); 987 } 988 } 989 990 /********************************* 991 * Return this type's modifier name. 992 */ 993 final char* modToChars() nothrow const 994 { 995 OutBuffer buf; 996 buf.reserve(16); 997 modToBuffer(&buf); 998 return buf.extractChars(); 999 } 1000 1001 bool isintegral() 1002 { 1003 return false; 1004 } 1005 1006 // real, imaginary, or complex 1007 bool isfloating() 1008 { 1009 return false; 1010 } 1011 1012 bool isreal() 1013 { 1014 return false; 1015 } 1016 1017 bool isimaginary() 1018 { 1019 return false; 1020 } 1021 1022 bool iscomplex() 1023 { 1024 return false; 1025 } 1026 1027 bool isscalar() 1028 { 1029 return false; 1030 } 1031 1032 bool isunsigned() 1033 { 1034 return false; 1035 } 1036 1037 bool isscope() 1038 { 1039 return false; 1040 } 1041 1042 bool isString() 1043 { 1044 return false; 1045 } 1046 1047 /************************** 1048 * When T is mutable, 1049 * Given: 1050 * T a, b; 1051 * Can we bitwise assign: 1052 * a = b; 1053 * ? 1054 */ 1055 bool isAssignable() 1056 { 1057 return true; 1058 } 1059 1060 /************************** 1061 * Returns true if T can be converted to boolean value. 1062 */ 1063 bool isBoolean() 1064 { 1065 return isscalar(); 1066 } 1067 1068 /********************************* 1069 * Check type to see if it is based on a deprecated symbol. 1070 */ 1071 void checkDeprecated(const ref Loc loc, Scope* sc) 1072 { 1073 if (Dsymbol s = toDsymbol(sc)) 1074 { 1075 s.checkDeprecated(loc, sc); 1076 } 1077 } 1078 1079 final bool isConst() const nothrow pure @nogc @safe 1080 { 1081 return (mod & MODFlags.const_) != 0; 1082 } 1083 1084 final bool isImmutable() const nothrow pure @nogc @safe 1085 { 1086 return (mod & MODFlags.immutable_) != 0; 1087 } 1088 1089 final bool isMutable() const nothrow pure @nogc @safe 1090 { 1091 return (mod & (MODFlags.const_ | MODFlags.immutable_ | MODFlags.wild)) == 0; 1092 } 1093 1094 final bool isShared() const nothrow pure @nogc @safe 1095 { 1096 return (mod & MODFlags.shared_) != 0; 1097 } 1098 1099 final bool isSharedConst() const nothrow pure @nogc @safe 1100 { 1101 return (mod & (MODFlags.shared_ | MODFlags.const_)) == (MODFlags.shared_ | MODFlags.const_); 1102 } 1103 1104 final bool isWild() const nothrow pure @nogc @safe 1105 { 1106 return (mod & MODFlags.wild) != 0; 1107 } 1108 1109 final bool isWildConst() const nothrow pure @nogc @safe 1110 { 1111 return (mod & MODFlags.wildconst) == MODFlags.wildconst; 1112 } 1113 1114 final bool isSharedWild() const nothrow pure @nogc @safe 1115 { 1116 return (mod & (MODFlags.shared_ | MODFlags.wild)) == (MODFlags.shared_ | MODFlags.wild); 1117 } 1118 1119 final bool isNaked() const nothrow pure @nogc @safe 1120 { 1121 return mod == 0; 1122 } 1123 1124 /******************************** 1125 * Return a copy of this type with all attributes null-initialized. 1126 * Useful for creating a type with different modifiers. 1127 */ 1128 final Type nullAttributes() nothrow const 1129 { 1130 uint sz = sizeTy[ty]; 1131 Type t = cast(Type)mem.xmalloc(sz); 1132 memcpy(cast(void*)t, cast(void*)this, sz); 1133 // t.mod = NULL; // leave mod unchanged 1134 t.deco = null; 1135 t.arrayof = null; 1136 t.pto = null; 1137 t.rto = null; 1138 t.cto = null; 1139 t.ito = null; 1140 t.sto = null; 1141 t.scto = null; 1142 t.wto = null; 1143 t.wcto = null; 1144 t.swto = null; 1145 t.swcto = null; 1146 t.vtinfo = null; 1147 t.ctype = null; 1148 if (t.ty == Tstruct) 1149 (cast(TypeStruct)t).att = AliasThisRec.fwdref; 1150 if (t.ty == Tclass) 1151 (cast(TypeClass)t).att = AliasThisRec.fwdref; 1152 return t; 1153 } 1154 1155 /******************************** 1156 * Convert to 'const'. 1157 */ 1158 final Type constOf() 1159 { 1160 //printf("Type::constOf() %p %s\n", this, toChars()); 1161 if (mod == MODFlags.const_) 1162 return this; 1163 if (cto) 1164 { 1165 assert(cto.mod == MODFlags.const_); 1166 return cto; 1167 } 1168 Type t = makeConst(); 1169 t = t.merge(); 1170 t.fixTo(this); 1171 //printf("-Type::constOf() %p %s\n", t, t.toChars()); 1172 return t; 1173 } 1174 1175 /******************************** 1176 * Convert to 'immutable'. 1177 */ 1178 final Type immutableOf() 1179 { 1180 //printf("Type::immutableOf() %p %s\n", this, toChars()); 1181 if (isImmutable()) 1182 return this; 1183 if (ito) 1184 { 1185 assert(ito.isImmutable()); 1186 return ito; 1187 } 1188 Type t = makeImmutable(); 1189 t = t.merge(); 1190 t.fixTo(this); 1191 //printf("\t%p\n", t); 1192 return t; 1193 } 1194 1195 /******************************** 1196 * Make type mutable. 1197 */ 1198 final Type mutableOf() 1199 { 1200 //printf("Type::mutableOf() %p, %s\n", this, toChars()); 1201 Type t = this; 1202 if (isImmutable()) 1203 { 1204 t = ito; // immutable => naked 1205 assert(!t || (t.isMutable() && !t.isShared())); 1206 } 1207 else if (isConst()) 1208 { 1209 if (isShared()) 1210 { 1211 if (isWild()) 1212 t = swcto; // shared wild const -> shared 1213 else 1214 t = sto; // shared const => shared 1215 } 1216 else 1217 { 1218 if (isWild()) 1219 t = wcto; // wild const -> naked 1220 else 1221 t = cto; // const => naked 1222 } 1223 assert(!t || t.isMutable()); 1224 } 1225 else if (isWild()) 1226 { 1227 if (isShared()) 1228 t = sto; // shared wild => shared 1229 else 1230 t = wto; // wild => naked 1231 assert(!t || t.isMutable()); 1232 } 1233 if (!t) 1234 { 1235 t = makeMutable(); 1236 t = t.merge(); 1237 t.fixTo(this); 1238 } 1239 else 1240 t = t.merge(); 1241 assert(t.isMutable()); 1242 return t; 1243 } 1244 1245 final Type sharedOf() 1246 { 1247 //printf("Type::sharedOf() %p, %s\n", this, toChars()); 1248 if (mod == MODFlags.shared_) 1249 return this; 1250 if (sto) 1251 { 1252 assert(sto.mod == MODFlags.shared_); 1253 return sto; 1254 } 1255 Type t = makeShared(); 1256 t = t.merge(); 1257 t.fixTo(this); 1258 //printf("\t%p\n", t); 1259 return t; 1260 } 1261 1262 final Type sharedConstOf() 1263 { 1264 //printf("Type::sharedConstOf() %p, %s\n", this, toChars()); 1265 if (mod == (MODFlags.shared_ | MODFlags.const_)) 1266 return this; 1267 if (scto) 1268 { 1269 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_)); 1270 return scto; 1271 } 1272 Type t = makeSharedConst(); 1273 t = t.merge(); 1274 t.fixTo(this); 1275 //printf("\t%p\n", t); 1276 return t; 1277 } 1278 1279 /******************************** 1280 * Make type unshared. 1281 * 0 => 0 1282 * const => const 1283 * immutable => immutable 1284 * shared => 0 1285 * shared const => const 1286 * wild => wild 1287 * wild const => wild const 1288 * shared wild => wild 1289 * shared wild const => wild const 1290 */ 1291 final Type unSharedOf() 1292 { 1293 //printf("Type::unSharedOf() %p, %s\n", this, toChars()); 1294 Type t = this; 1295 1296 if (isShared()) 1297 { 1298 if (isWild()) 1299 { 1300 if (isConst()) 1301 t = wcto; // shared wild const => wild const 1302 else 1303 t = wto; // shared wild => wild 1304 } 1305 else 1306 { 1307 if (isConst()) 1308 t = cto; // shared const => const 1309 else 1310 t = sto; // shared => naked 1311 } 1312 assert(!t || !t.isShared()); 1313 } 1314 1315 if (!t) 1316 { 1317 t = this.nullAttributes(); 1318 t.mod = mod & ~MODFlags.shared_; 1319 t.ctype = ctype; 1320 t = t.merge(); 1321 t.fixTo(this); 1322 } 1323 else 1324 t = t.merge(); 1325 assert(!t.isShared()); 1326 return t; 1327 } 1328 1329 /******************************** 1330 * Convert to 'wild'. 1331 */ 1332 final Type wildOf() 1333 { 1334 //printf("Type::wildOf() %p %s\n", this, toChars()); 1335 if (mod == MODFlags.wild) 1336 return this; 1337 if (wto) 1338 { 1339 assert(wto.mod == MODFlags.wild); 1340 return wto; 1341 } 1342 Type t = makeWild(); 1343 t = t.merge(); 1344 t.fixTo(this); 1345 //printf("\t%p %s\n", t, t.toChars()); 1346 return t; 1347 } 1348 1349 final Type wildConstOf() 1350 { 1351 //printf("Type::wildConstOf() %p %s\n", this, toChars()); 1352 if (mod == MODFlags.wildconst) 1353 return this; 1354 if (wcto) 1355 { 1356 assert(wcto.mod == MODFlags.wildconst); 1357 return wcto; 1358 } 1359 Type t = makeWildConst(); 1360 t = t.merge(); 1361 t.fixTo(this); 1362 //printf("\t%p %s\n", t, t.toChars()); 1363 return t; 1364 } 1365 1366 final Type sharedWildOf() 1367 { 1368 //printf("Type::sharedWildOf() %p, %s\n", this, toChars()); 1369 if (mod == (MODFlags.shared_ | MODFlags.wild)) 1370 return this; 1371 if (swto) 1372 { 1373 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild)); 1374 return swto; 1375 } 1376 Type t = makeSharedWild(); 1377 t = t.merge(); 1378 t.fixTo(this); 1379 //printf("\t%p %s\n", t, t.toChars()); 1380 return t; 1381 } 1382 1383 final Type sharedWildConstOf() 1384 { 1385 //printf("Type::sharedWildConstOf() %p, %s\n", this, toChars()); 1386 if (mod == (MODFlags.shared_ | MODFlags.wildconst)) 1387 return this; 1388 if (swcto) 1389 { 1390 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst)); 1391 return swcto; 1392 } 1393 Type t = makeSharedWildConst(); 1394 t = t.merge(); 1395 t.fixTo(this); 1396 //printf("\t%p %s\n", t, t.toChars()); 1397 return t; 1398 } 1399 1400 /********************************** 1401 * For our new type 'this', which is type-constructed from t, 1402 * fill in the cto, ito, sto, scto, wto shortcuts. 1403 */ 1404 final void fixTo(Type t) 1405 { 1406 // If fixing this: immutable(T*) by t: immutable(T)*, 1407 // cache t to this.xto won't break transitivity. 1408 Type mto = null; 1409 Type tn = nextOf(); 1410 if (!tn || ty != Tsarray && tn.mod == t.nextOf().mod) 1411 { 1412 switch (t.mod) 1413 { 1414 case 0: 1415 mto = t; 1416 break; 1417 1418 case MODFlags.const_: 1419 cto = t; 1420 break; 1421 1422 case MODFlags.wild: 1423 wto = t; 1424 break; 1425 1426 case MODFlags.wildconst: 1427 wcto = t; 1428 break; 1429 1430 case MODFlags.shared_: 1431 sto = t; 1432 break; 1433 1434 case MODFlags.shared_ | MODFlags.const_: 1435 scto = t; 1436 break; 1437 1438 case MODFlags.shared_ | MODFlags.wild: 1439 swto = t; 1440 break; 1441 1442 case MODFlags.shared_ | MODFlags.wildconst: 1443 swcto = t; 1444 break; 1445 1446 case MODFlags.immutable_: 1447 ito = t; 1448 break; 1449 1450 default: 1451 break; 1452 } 1453 } 1454 assert(mod != t.mod); 1455 1456 auto X(T, U)(T m, U n) 1457 { 1458 return ((m << 4) | n); 1459 } 1460 1461 switch (mod) 1462 { 1463 case 0: 1464 break; 1465 1466 case MODFlags.const_: 1467 cto = mto; 1468 t.cto = this; 1469 break; 1470 1471 case MODFlags.wild: 1472 wto = mto; 1473 t.wto = this; 1474 break; 1475 1476 case MODFlags.wildconst: 1477 wcto = mto; 1478 t.wcto = this; 1479 break; 1480 1481 case MODFlags.shared_: 1482 sto = mto; 1483 t.sto = this; 1484 break; 1485 1486 case MODFlags.shared_ | MODFlags.const_: 1487 scto = mto; 1488 t.scto = this; 1489 break; 1490 1491 case MODFlags.shared_ | MODFlags.wild: 1492 swto = mto; 1493 t.swto = this; 1494 break; 1495 1496 case MODFlags.shared_ | MODFlags.wildconst: 1497 swcto = mto; 1498 t.swcto = this; 1499 break; 1500 1501 case MODFlags.immutable_: 1502 t.ito = this; 1503 if (t.cto) 1504 t.cto.ito = this; 1505 if (t.sto) 1506 t.sto.ito = this; 1507 if (t.scto) 1508 t.scto.ito = this; 1509 if (t.wto) 1510 t.wto.ito = this; 1511 if (t.wcto) 1512 t.wcto.ito = this; 1513 if (t.swto) 1514 t.swto.ito = this; 1515 if (t.swcto) 1516 t.swcto.ito = this; 1517 break; 1518 1519 default: 1520 assert(0); 1521 } 1522 1523 check(); 1524 t.check(); 1525 //printf("fixTo: %s, %s\n", toChars(), t.toChars()); 1526 } 1527 1528 /*************************** 1529 * Look for bugs in constructing types. 1530 */ 1531 final void check() 1532 { 1533 switch (mod) 1534 { 1535 case 0: 1536 if (cto) 1537 assert(cto.mod == MODFlags.const_); 1538 if (ito) 1539 assert(ito.mod == MODFlags.immutable_); 1540 if (sto) 1541 assert(sto.mod == MODFlags.shared_); 1542 if (scto) 1543 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_)); 1544 if (wto) 1545 assert(wto.mod == MODFlags.wild); 1546 if (wcto) 1547 assert(wcto.mod == MODFlags.wildconst); 1548 if (swto) 1549 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild)); 1550 if (swcto) 1551 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst)); 1552 break; 1553 1554 case MODFlags.const_: 1555 if (cto) 1556 assert(cto.mod == 0); 1557 if (ito) 1558 assert(ito.mod == MODFlags.immutable_); 1559 if (sto) 1560 assert(sto.mod == MODFlags.shared_); 1561 if (scto) 1562 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_)); 1563 if (wto) 1564 assert(wto.mod == MODFlags.wild); 1565 if (wcto) 1566 assert(wcto.mod == MODFlags.wildconst); 1567 if (swto) 1568 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild)); 1569 if (swcto) 1570 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst)); 1571 break; 1572 1573 case MODFlags.wild: 1574 if (cto) 1575 assert(cto.mod == MODFlags.const_); 1576 if (ito) 1577 assert(ito.mod == MODFlags.immutable_); 1578 if (sto) 1579 assert(sto.mod == MODFlags.shared_); 1580 if (scto) 1581 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_)); 1582 if (wto) 1583 assert(wto.mod == 0); 1584 if (wcto) 1585 assert(wcto.mod == MODFlags.wildconst); 1586 if (swto) 1587 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild)); 1588 if (swcto) 1589 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst)); 1590 break; 1591 1592 case MODFlags.wildconst: 1593 assert(!cto || cto.mod == MODFlags.const_); 1594 assert(!ito || ito.mod == MODFlags.immutable_); 1595 assert(!sto || sto.mod == MODFlags.shared_); 1596 assert(!scto || scto.mod == (MODFlags.shared_ | MODFlags.const_)); 1597 assert(!wto || wto.mod == MODFlags.wild); 1598 assert(!wcto || wcto.mod == 0); 1599 assert(!swto || swto.mod == (MODFlags.shared_ | MODFlags.wild)); 1600 assert(!swcto || swcto.mod == (MODFlags.shared_ | MODFlags.wildconst)); 1601 break; 1602 1603 case MODFlags.shared_: 1604 if (cto) 1605 assert(cto.mod == MODFlags.const_); 1606 if (ito) 1607 assert(ito.mod == MODFlags.immutable_); 1608 if (sto) 1609 assert(sto.mod == 0); 1610 if (scto) 1611 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_)); 1612 if (wto) 1613 assert(wto.mod == MODFlags.wild); 1614 if (wcto) 1615 assert(wcto.mod == MODFlags.wildconst); 1616 if (swto) 1617 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild)); 1618 if (swcto) 1619 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst)); 1620 break; 1621 1622 case MODFlags.shared_ | MODFlags.const_: 1623 if (cto) 1624 assert(cto.mod == MODFlags.const_); 1625 if (ito) 1626 assert(ito.mod == MODFlags.immutable_); 1627 if (sto) 1628 assert(sto.mod == MODFlags.shared_); 1629 if (scto) 1630 assert(scto.mod == 0); 1631 if (wto) 1632 assert(wto.mod == MODFlags.wild); 1633 if (wcto) 1634 assert(wcto.mod == MODFlags.wildconst); 1635 if (swto) 1636 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild)); 1637 if (swcto) 1638 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst)); 1639 break; 1640 1641 case MODFlags.shared_ | MODFlags.wild: 1642 if (cto) 1643 assert(cto.mod == MODFlags.const_); 1644 if (ito) 1645 assert(ito.mod == MODFlags.immutable_); 1646 if (sto) 1647 assert(sto.mod == MODFlags.shared_); 1648 if (scto) 1649 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_)); 1650 if (wto) 1651 assert(wto.mod == MODFlags.wild); 1652 if (wcto) 1653 assert(wcto.mod == MODFlags.wildconst); 1654 if (swto) 1655 assert(swto.mod == 0); 1656 if (swcto) 1657 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst)); 1658 break; 1659 1660 case MODFlags.shared_ | MODFlags.wildconst: 1661 assert(!cto || cto.mod == MODFlags.const_); 1662 assert(!ito || ito.mod == MODFlags.immutable_); 1663 assert(!sto || sto.mod == MODFlags.shared_); 1664 assert(!scto || scto.mod == (MODFlags.shared_ | MODFlags.const_)); 1665 assert(!wto || wto.mod == MODFlags.wild); 1666 assert(!wcto || wcto.mod == MODFlags.wildconst); 1667 assert(!swto || swto.mod == (MODFlags.shared_ | MODFlags.wild)); 1668 assert(!swcto || swcto.mod == 0); 1669 break; 1670 1671 case MODFlags.immutable_: 1672 if (cto) 1673 assert(cto.mod == MODFlags.const_); 1674 if (ito) 1675 assert(ito.mod == 0); 1676 if (sto) 1677 assert(sto.mod == MODFlags.shared_); 1678 if (scto) 1679 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_)); 1680 if (wto) 1681 assert(wto.mod == MODFlags.wild); 1682 if (wcto) 1683 assert(wcto.mod == MODFlags.wildconst); 1684 if (swto) 1685 assert(swto.mod == (MODFlags.shared_ | MODFlags.wild)); 1686 if (swcto) 1687 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst)); 1688 break; 1689 1690 default: 1691 assert(0); 1692 } 1693 1694 Type tn = nextOf(); 1695 if (tn && ty != Tfunction && tn.ty != Tfunction && ty != Tenum) 1696 { 1697 // Verify transitivity 1698 switch (mod) 1699 { 1700 case 0: 1701 case MODFlags.const_: 1702 case MODFlags.wild: 1703 case MODFlags.wildconst: 1704 case MODFlags.shared_: 1705 case MODFlags.shared_ | MODFlags.const_: 1706 case MODFlags.shared_ | MODFlags.wild: 1707 case MODFlags.shared_ | MODFlags.wildconst: 1708 case MODFlags.immutable_: 1709 assert(tn.mod == MODFlags.immutable_ || (tn.mod & mod) == mod); 1710 break; 1711 1712 default: 1713 assert(0); 1714 } 1715 tn.check(); 1716 } 1717 } 1718 1719 /************************************* 1720 * Apply STCxxxx bits to existing type. 1721 * Use *before* semantic analysis is run. 1722 */ 1723 final Type addSTC(StorageClass stc) 1724 { 1725 Type t = this; 1726 if (t.isImmutable()) 1727 { 1728 } 1729 else if (stc & STC.immutable_) 1730 { 1731 t = t.makeImmutable(); 1732 } 1733 else 1734 { 1735 if ((stc & STC.shared_) && !t.isShared()) 1736 { 1737 if (t.isWild()) 1738 { 1739 if (t.isConst()) 1740 t = t.makeSharedWildConst(); 1741 else 1742 t = t.makeSharedWild(); 1743 } 1744 else 1745 { 1746 if (t.isConst()) 1747 t = t.makeSharedConst(); 1748 else 1749 t = t.makeShared(); 1750 } 1751 } 1752 if ((stc & STC.const_) && !t.isConst()) 1753 { 1754 if (t.isShared()) 1755 { 1756 if (t.isWild()) 1757 t = t.makeSharedWildConst(); 1758 else 1759 t = t.makeSharedConst(); 1760 } 1761 else 1762 { 1763 if (t.isWild()) 1764 t = t.makeWildConst(); 1765 else 1766 t = t.makeConst(); 1767 } 1768 } 1769 if ((stc & STC.wild) && !t.isWild()) 1770 { 1771 if (t.isShared()) 1772 { 1773 if (t.isConst()) 1774 t = t.makeSharedWildConst(); 1775 else 1776 t = t.makeSharedWild(); 1777 } 1778 else 1779 { 1780 if (t.isConst()) 1781 t = t.makeWildConst(); 1782 else 1783 t = t.makeWild(); 1784 } 1785 } 1786 } 1787 return t; 1788 } 1789 1790 /************************************ 1791 * Apply MODxxxx bits to existing type. 1792 */ 1793 final Type castMod(MOD mod) 1794 { 1795 Type t; 1796 switch (mod) 1797 { 1798 case 0: 1799 t = unSharedOf().mutableOf(); 1800 break; 1801 1802 case MODFlags.const_: 1803 t = unSharedOf().constOf(); 1804 break; 1805 1806 case MODFlags.wild: 1807 t = unSharedOf().wildOf(); 1808 break; 1809 1810 case MODFlags.wildconst: 1811 t = unSharedOf().wildConstOf(); 1812 break; 1813 1814 case MODFlags.shared_: 1815 t = mutableOf().sharedOf(); 1816 break; 1817 1818 case MODFlags.shared_ | MODFlags.const_: 1819 t = sharedConstOf(); 1820 break; 1821 1822 case MODFlags.shared_ | MODFlags.wild: 1823 t = sharedWildOf(); 1824 break; 1825 1826 case MODFlags.shared_ | MODFlags.wildconst: 1827 t = sharedWildConstOf(); 1828 break; 1829 1830 case MODFlags.immutable_: 1831 t = immutableOf(); 1832 break; 1833 1834 default: 1835 assert(0); 1836 } 1837 return t; 1838 } 1839 1840 /************************************ 1841 * Add MODxxxx bits to existing type. 1842 * We're adding, not replacing, so adding const to 1843 * a shared type => "shared const" 1844 */ 1845 final Type addMod(MOD mod) 1846 { 1847 /* Add anything to immutable, and it remains immutable 1848 */ 1849 Type t = this; 1850 if (!t.isImmutable()) 1851 { 1852 //printf("addMod(%x) %s\n", mod, toChars()); 1853 switch (mod) 1854 { 1855 case 0: 1856 break; 1857 1858 case MODFlags.const_: 1859 if (isShared()) 1860 { 1861 if (isWild()) 1862 t = sharedWildConstOf(); 1863 else 1864 t = sharedConstOf(); 1865 } 1866 else 1867 { 1868 if (isWild()) 1869 t = wildConstOf(); 1870 else 1871 t = constOf(); 1872 } 1873 break; 1874 1875 case MODFlags.wild: 1876 if (isShared()) 1877 { 1878 if (isConst()) 1879 t = sharedWildConstOf(); 1880 else 1881 t = sharedWildOf(); 1882 } 1883 else 1884 { 1885 if (isConst()) 1886 t = wildConstOf(); 1887 else 1888 t = wildOf(); 1889 } 1890 break; 1891 1892 case MODFlags.wildconst: 1893 if (isShared()) 1894 t = sharedWildConstOf(); 1895 else 1896 t = wildConstOf(); 1897 break; 1898 1899 case MODFlags.shared_: 1900 if (isWild()) 1901 { 1902 if (isConst()) 1903 t = sharedWildConstOf(); 1904 else 1905 t = sharedWildOf(); 1906 } 1907 else 1908 { 1909 if (isConst()) 1910 t = sharedConstOf(); 1911 else 1912 t = sharedOf(); 1913 } 1914 break; 1915 1916 case MODFlags.shared_ | MODFlags.const_: 1917 if (isWild()) 1918 t = sharedWildConstOf(); 1919 else 1920 t = sharedConstOf(); 1921 break; 1922 1923 case MODFlags.shared_ | MODFlags.wild: 1924 if (isConst()) 1925 t = sharedWildConstOf(); 1926 else 1927 t = sharedWildOf(); 1928 break; 1929 1930 case MODFlags.shared_ | MODFlags.wildconst: 1931 t = sharedWildConstOf(); 1932 break; 1933 1934 case MODFlags.immutable_: 1935 t = immutableOf(); 1936 break; 1937 1938 default: 1939 assert(0); 1940 } 1941 } 1942 return t; 1943 } 1944 1945 /************************************ 1946 * Add storage class modifiers to type. 1947 */ 1948 Type addStorageClass(StorageClass stc) 1949 { 1950 /* Just translate to MOD bits and let addMod() do the work 1951 */ 1952 MOD mod = 0; 1953 if (stc & STC.immutable_) 1954 mod = MODFlags.immutable_; 1955 else 1956 { 1957 if (stc & (STC.const_ | STC.in_)) 1958 mod |= MODFlags.const_; 1959 if (stc & STC.wild) 1960 mod |= MODFlags.wild; 1961 if (stc & STC.shared_) 1962 mod |= MODFlags.shared_; 1963 } 1964 return addMod(mod); 1965 } 1966 1967 final Type pointerTo() 1968 { 1969 if (ty == Terror) 1970 return this; 1971 if (!pto) 1972 { 1973 Type t = new TypePointer(this); 1974 if (ty == Tfunction) 1975 { 1976 t.deco = t.merge().deco; 1977 pto = t; 1978 } 1979 else 1980 pto = t.merge(); 1981 } 1982 return pto; 1983 } 1984 1985 final Type referenceTo() 1986 { 1987 if (ty == Terror) 1988 return this; 1989 if (!rto) 1990 { 1991 Type t = new TypeReference(this); 1992 rto = t.merge(); 1993 } 1994 return rto; 1995 } 1996 1997 final Type arrayOf() 1998 { 1999 if (ty == Terror) 2000 return this; 2001 if (!arrayof) 2002 { 2003 Type t = new TypeDArray(this); 2004 arrayof = t.merge(); 2005 } 2006 return arrayof; 2007 } 2008 2009 // Make corresponding static array type without semantic 2010 final Type sarrayOf(dinteger_t dim) 2011 { 2012 assert(deco); 2013 Type t = new TypeSArray(this, new IntegerExp(Loc.initial, dim, Type.tsize_t)); 2014 // according to TypeSArray::semantic() 2015 t = t.addMod(mod); 2016 t = t.merge(); 2017 return t; 2018 } 2019 2020 final Type aliasthisOf() 2021 { 2022 auto ad = isAggregate(this); 2023 if (!ad || !ad.aliasthis) 2024 return null; 2025 2026 auto s = ad.aliasthis.sym; 2027 if (s.isAliasDeclaration()) 2028 s = s.toAlias(); 2029 2030 if (s.isTupleDeclaration()) 2031 return null; 2032 2033 if (auto vd = s.isVarDeclaration()) 2034 { 2035 auto t = vd.type; 2036 if (vd.needThis()) 2037 t = t.addMod(this.mod); 2038 return t; 2039 } 2040 if (auto fd = s.isFuncDeclaration()) 2041 { 2042 fd = resolveFuncCall(Loc.initial, null, fd, null, this, null, FuncResolveFlag.quiet); 2043 if (!fd || fd.errors || !fd.functionSemantic()) 2044 return Type.terror; 2045 2046 auto t = fd.type.nextOf(); 2047 if (!t) // issue 14185 2048 return Type.terror; 2049 t = t.substWildTo(mod == 0 ? MODFlags.mutable : mod); 2050 return t; 2051 } 2052 if (auto d = s.isDeclaration()) 2053 { 2054 assert(d.type); 2055 return d.type; 2056 } 2057 if (auto ed = s.isEnumDeclaration()) 2058 { 2059 return ed.type; 2060 } 2061 if (auto td = s.isTemplateDeclaration()) 2062 { 2063 assert(td._scope); 2064 auto fd = resolveFuncCall(Loc.initial, null, td, null, this, null, FuncResolveFlag.quiet); 2065 if (!fd || fd.errors || !fd.functionSemantic()) 2066 return Type.terror; 2067 2068 auto t = fd.type.nextOf(); 2069 if (!t) 2070 return Type.terror; 2071 t = t.substWildTo(mod == 0 ? MODFlags.mutable : mod); 2072 return t; 2073 } 2074 2075 //printf("%s\n", s.kind()); 2076 return null; 2077 } 2078 2079 extern (D) final bool checkAliasThisRec() 2080 { 2081 Type tb = toBasetype(); 2082 AliasThisRec* pflag; 2083 if (tb.ty == Tstruct) 2084 pflag = &(cast(TypeStruct)tb).att; 2085 else if (tb.ty == Tclass) 2086 pflag = &(cast(TypeClass)tb).att; 2087 else 2088 return false; 2089 2090 AliasThisRec flag = cast(AliasThisRec)(*pflag & AliasThisRec.typeMask); 2091 if (flag == AliasThisRec.fwdref) 2092 { 2093 Type att = aliasthisOf(); 2094 flag = att && att.implicitConvTo(this) ? AliasThisRec.yes : AliasThisRec.no; 2095 } 2096 *pflag = cast(AliasThisRec)(flag | (*pflag & ~AliasThisRec.typeMask)); 2097 return flag == AliasThisRec.yes; 2098 } 2099 2100 Type makeConst() 2101 { 2102 //printf("Type::makeConst() %p, %s\n", this, toChars()); 2103 if (cto) 2104 return cto; 2105 Type t = this.nullAttributes(); 2106 t.mod = MODFlags.const_; 2107 //printf("-Type::makeConst() %p, %s\n", t, toChars()); 2108 return t; 2109 } 2110 2111 Type makeImmutable() 2112 { 2113 if (ito) 2114 return ito; 2115 Type t = this.nullAttributes(); 2116 t.mod = MODFlags.immutable_; 2117 return t; 2118 } 2119 2120 Type makeShared() 2121 { 2122 if (sto) 2123 return sto; 2124 Type t = this.nullAttributes(); 2125 t.mod = MODFlags.shared_; 2126 return t; 2127 } 2128 2129 Type makeSharedConst() 2130 { 2131 if (scto) 2132 return scto; 2133 Type t = this.nullAttributes(); 2134 t.mod = MODFlags.shared_ | MODFlags.const_; 2135 return t; 2136 } 2137 2138 Type makeWild() 2139 { 2140 if (wto) 2141 return wto; 2142 Type t = this.nullAttributes(); 2143 t.mod = MODFlags.wild; 2144 return t; 2145 } 2146 2147 Type makeWildConst() 2148 { 2149 if (wcto) 2150 return wcto; 2151 Type t = this.nullAttributes(); 2152 t.mod = MODFlags.wildconst; 2153 return t; 2154 } 2155 2156 Type makeSharedWild() 2157 { 2158 if (swto) 2159 return swto; 2160 Type t = this.nullAttributes(); 2161 t.mod = MODFlags.shared_ | MODFlags.wild; 2162 return t; 2163 } 2164 2165 Type makeSharedWildConst() 2166 { 2167 if (swcto) 2168 return swcto; 2169 Type t = this.nullAttributes(); 2170 t.mod = MODFlags.shared_ | MODFlags.wildconst; 2171 return t; 2172 } 2173 2174 Type makeMutable() 2175 { 2176 Type t = this.nullAttributes(); 2177 t.mod = mod & MODFlags.shared_; 2178 return t; 2179 } 2180 2181 Dsymbol toDsymbol(Scope* sc) 2182 { 2183 return null; 2184 } 2185 2186 /******************************* 2187 * If this is a shell around another type, 2188 * get that other type. 2189 */ 2190 Type toBasetype() 2191 { 2192 return this; 2193 } 2194 2195 bool isBaseOf(Type t, int* poffset) 2196 { 2197 return 0; // assume not 2198 } 2199 2200 /******************************** 2201 * Determine if 'this' can be implicitly converted 2202 * to type 'to'. 2203 * Returns: 2204 * MATCH.nomatch, MATCH.convert, MATCH.constant, MATCH.exact 2205 */ 2206 MATCH implicitConvTo(Type to) 2207 { 2208 //printf("Type::implicitConvTo(this=%p, to=%p)\n", this, to); 2209 //printf("from: %s\n", toChars()); 2210 //printf("to : %s\n", to.toChars()); 2211 if (this.equals(to)) 2212 return MATCH.exact; 2213 return MATCH.nomatch; 2214 } 2215 2216 /******************************* 2217 * Determine if converting 'this' to 'to' is an identity operation, 2218 * a conversion to const operation, or the types aren't the same. 2219 * Returns: 2220 * MATCH.exact 'this' == 'to' 2221 * MATCH.constant 'to' is const 2222 * MATCH.nomatch conversion to mutable or invariant 2223 */ 2224 MATCH constConv(Type to) 2225 { 2226 //printf("Type::constConv(this = %s, to = %s)\n", toChars(), to.toChars()); 2227 if (equals(to)) 2228 return MATCH.exact; 2229 if (ty == to.ty && MODimplicitConv(mod, to.mod)) 2230 return MATCH.constant; 2231 return MATCH.nomatch; 2232 } 2233 2234 /*************************************** 2235 * Compute MOD bits matching `this` argument type to wild parameter type. 2236 * Params: 2237 * t = corresponding parameter type 2238 * isRef = parameter is `ref` or `out` 2239 * Returns: 2240 * MOD bits 2241 */ 2242 MOD deduceWild(Type t, bool isRef) 2243 { 2244 //printf("Type::deduceWild this = '%s', tprm = '%s'\n", toChars(), tprm.toChars()); 2245 if (t.isWild()) 2246 { 2247 if (isImmutable()) 2248 return MODFlags.immutable_; 2249 else if (isWildConst()) 2250 { 2251 if (t.isWildConst()) 2252 return MODFlags.wild; 2253 else 2254 return MODFlags.wildconst; 2255 } 2256 else if (isWild()) 2257 return MODFlags.wild; 2258 else if (isConst()) 2259 return MODFlags.const_; 2260 else if (isMutable()) 2261 return MODFlags.mutable; 2262 else 2263 assert(0); 2264 } 2265 return 0; 2266 } 2267 2268 Type substWildTo(uint mod) 2269 { 2270 //printf("+Type::substWildTo this = %s, mod = x%x\n", toChars(), mod); 2271 Type t; 2272 2273 if (Type tn = nextOf()) 2274 { 2275 // substitution has no effect on function pointer type. 2276 if (ty == Tpointer && tn.ty == Tfunction) 2277 { 2278 t = this; 2279 goto L1; 2280 } 2281 2282 t = tn.substWildTo(mod); 2283 if (t == tn) 2284 t = this; 2285 else 2286 { 2287 if (ty == Tpointer) 2288 t = t.pointerTo(); 2289 else if (ty == Tarray) 2290 t = t.arrayOf(); 2291 else if (ty == Tsarray) 2292 t = new TypeSArray(t, (cast(TypeSArray)this).dim.syntaxCopy()); 2293 else if (ty == Taarray) 2294 { 2295 t = new TypeAArray(t, (cast(TypeAArray)this).index.syntaxCopy()); 2296 (cast(TypeAArray)t).sc = (cast(TypeAArray)this).sc; // duplicate scope 2297 } 2298 else if (ty == Tdelegate) 2299 { 2300 t = new TypeDelegate(t); 2301 } 2302 else 2303 assert(0); 2304 2305 t = t.merge(); 2306 } 2307 } 2308 else 2309 t = this; 2310 2311 L1: 2312 if (isWild()) 2313 { 2314 if (mod == MODFlags.immutable_) 2315 { 2316 t = t.immutableOf(); 2317 } 2318 else if (mod == MODFlags.wildconst) 2319 { 2320 t = t.wildConstOf(); 2321 } 2322 else if (mod == MODFlags.wild) 2323 { 2324 if (isWildConst()) 2325 t = t.wildConstOf(); 2326 else 2327 t = t.wildOf(); 2328 } 2329 else if (mod == MODFlags.const_) 2330 { 2331 t = t.constOf(); 2332 } 2333 else 2334 { 2335 if (isWildConst()) 2336 t = t.constOf(); 2337 else 2338 t = t.mutableOf(); 2339 } 2340 } 2341 if (isConst()) 2342 t = t.addMod(MODFlags.const_); 2343 if (isShared()) 2344 t = t.addMod(MODFlags.shared_); 2345 2346 //printf("-Type::substWildTo t = %s\n", t.toChars()); 2347 return t; 2348 } 2349 2350 final Type unqualify(uint m) 2351 { 2352 Type t = mutableOf().unSharedOf(); 2353 2354 Type tn = ty == Tenum ? null : nextOf(); 2355 if (tn && tn.ty != Tfunction) 2356 { 2357 Type utn = tn.unqualify(m); 2358 if (utn != tn) 2359 { 2360 if (ty == Tpointer) 2361 t = utn.pointerTo(); 2362 else if (ty == Tarray) 2363 t = utn.arrayOf(); 2364 else if (ty == Tsarray) 2365 t = new TypeSArray(utn, (cast(TypeSArray)this).dim); 2366 else if (ty == Taarray) 2367 { 2368 t = new TypeAArray(utn, (cast(TypeAArray)this).index); 2369 (cast(TypeAArray)t).sc = (cast(TypeAArray)this).sc; // duplicate scope 2370 } 2371 else 2372 assert(0); 2373 2374 t = t.merge(); 2375 } 2376 } 2377 t = t.addMod(mod & ~m); 2378 return t; 2379 } 2380 2381 /************************** 2382 * Return type with the top level of it being mutable. 2383 */ 2384 inout(Type) toHeadMutable() inout 2385 { 2386 if (!mod) 2387 return this; 2388 Type unqualThis = cast(Type) this; 2389 // `mutableOf` needs a mutable `this` only for caching 2390 return cast(inout(Type)) unqualThis.mutableOf(); 2391 } 2392 2393 inout(ClassDeclaration) isClassHandle() inout 2394 { 2395 return null; 2396 } 2397 2398 /************************************ 2399 * Return alignment to use for this type. 2400 */ 2401 structalign_t alignment() 2402 { 2403 return STRUCTALIGN_DEFAULT; 2404 } 2405 2406 /*************************************** 2407 * Use when we prefer the default initializer to be a literal, 2408 * rather than a global immutable variable. 2409 */ 2410 Expression defaultInitLiteral(const ref Loc loc) 2411 { 2412 static if (LOGDEFAULTINIT) 2413 { 2414 printf("Type::defaultInitLiteral() '%s'\n", toChars()); 2415 } 2416 return defaultInit(this, loc); 2417 } 2418 2419 // if initializer is 0 2420 bool isZeroInit(const ref Loc loc) 2421 { 2422 return false; // assume not 2423 } 2424 2425 final Identifier getTypeInfoIdent() 2426 { 2427 // _init_10TypeInfo_%s 2428 OutBuffer buf; 2429 buf.reserve(32); 2430 mangleToBuffer(this, &buf); 2431 2432 const slice = buf[]; 2433 2434 // Allocate buffer on stack, fail over to using malloc() 2435 char[128] namebuf; 2436 const namelen = 19 + size_t.sizeof * 3 + slice.length + 1; 2437 auto name = namelen <= namebuf.length ? namebuf.ptr : cast(char*)Mem.check(malloc(namelen)); 2438 2439 const length = sprintf(name, "_D%lluTypeInfo_%.*s6__initZ", 2440 cast(ulong)(9 + slice.length), cast(int)slice.length, slice.ptr); 2441 //printf("%p %s, deco = %s, name = %s\n", this, toChars(), deco, name); 2442 assert(0 < length && length < namelen); // don't overflow the buffer 2443 2444 auto id = Identifier.idPool(name, length); 2445 2446 if (name != namebuf.ptr) 2447 free(name); 2448 return id; 2449 } 2450 2451 /*************************************** 2452 * Return !=0 if the type or any of its subtypes is wild. 2453 */ 2454 int hasWild() const 2455 { 2456 return mod & MODFlags.wild; 2457 } 2458 2459 /*************************************** 2460 * Return !=0 if type has pointers that need to 2461 * be scanned by the GC during a collection cycle. 2462 */ 2463 bool hasPointers() 2464 { 2465 //printf("Type::hasPointers() %s, %d\n", toChars(), ty); 2466 return false; 2467 } 2468 2469 /************************************* 2470 * Detect if type has pointer fields that are initialized to void. 2471 * Local stack variables with such void fields can remain uninitialized, 2472 * leading to pointer bugs. 2473 * Returns: 2474 * true if so 2475 */ 2476 bool hasVoidInitPointers() 2477 { 2478 return false; 2479 } 2480 2481 /************************************* 2482 * If this is a type of something, return that something. 2483 */ 2484 Type nextOf() 2485 { 2486 return null; 2487 } 2488 2489 /************************************* 2490 * If this is a type of static array, return its base element type. 2491 */ 2492 final Type baseElemOf() 2493 { 2494 Type t = toBasetype(); 2495 TypeSArray tsa; 2496 while ((tsa = t.isTypeSArray()) !is null) 2497 t = tsa.next.toBasetype(); 2498 return t; 2499 } 2500 2501 /******************************************* 2502 * Compute number of elements for a (possibly multidimensional) static array, 2503 * or 1 for other types. 2504 * Params: 2505 * loc = for error message 2506 * Returns: 2507 * number of elements, uint.max on overflow 2508 */ 2509 final uint numberOfElems(const ref Loc loc) 2510 { 2511 //printf("Type::numberOfElems()\n"); 2512 uinteger_t n = 1; 2513 Type tb = this; 2514 while ((tb = tb.toBasetype()).ty == Tsarray) 2515 { 2516 bool overflow = false; 2517 n = mulu(n, (cast(TypeSArray)tb).dim.toUInteger(), overflow); 2518 if (overflow || n >= uint.max) 2519 { 2520 error(loc, "static array `%s` size overflowed to %llu", toChars(), cast(ulong)n); 2521 return uint.max; 2522 } 2523 tb = (cast(TypeSArray)tb).next; 2524 } 2525 return cast(uint)n; 2526 } 2527 2528 /**************************************** 2529 * Return the mask that an integral type will 2530 * fit into. 2531 */ 2532 final uinteger_t sizemask() 2533 { 2534 uinteger_t m; 2535 switch (toBasetype().ty) 2536 { 2537 case Tbool: 2538 m = 1; 2539 break; 2540 case Tchar: 2541 case Tint8: 2542 case Tuns8: 2543 m = 0xFF; 2544 break; 2545 case Twchar: 2546 case Tint16: 2547 case Tuns16: 2548 m = 0xFFFFU; 2549 break; 2550 case Tdchar: 2551 case Tint32: 2552 case Tuns32: 2553 m = 0xFFFFFFFFU; 2554 break; 2555 case Tint64: 2556 case Tuns64: 2557 m = 0xFFFFFFFFFFFFFFFFUL; 2558 break; 2559 default: 2560 assert(0); 2561 } 2562 return m; 2563 } 2564 2565 /******************************** 2566 * true if when type goes out of scope, it needs a destructor applied. 2567 * Only applies to value types, not ref types. 2568 */ 2569 bool needsDestruction() 2570 { 2571 return false; 2572 } 2573 2574 /******************************** 2575 * true if when type is copied, it needs a copy constructor or postblit 2576 * applied. Only applies to value types, not ref types. 2577 */ 2578 bool needsCopyOrPostblit() 2579 { 2580 return false; 2581 } 2582 2583 /********************************* 2584 * 2585 */ 2586 bool needsNested() 2587 { 2588 return false; 2589 } 2590 2591 /************************************* 2592 * https://issues.dlang.org/show_bug.cgi?id=14488 2593 * Check if the inner most base type is complex or imaginary. 2594 * Should only give alerts when set to emit transitional messages. 2595 * Params: 2596 * loc = The source location. 2597 * sc = scope of the type 2598 */ 2599 extern (D) final bool checkComplexTransition(const ref Loc loc, Scope* sc) 2600 { 2601 if (sc.isDeprecated()) 2602 return false; 2603 2604 Type t = baseElemOf(); 2605 while (t.ty == Tpointer || t.ty == Tarray) 2606 t = t.nextOf().baseElemOf(); 2607 2608 // Basetype is an opaque enum, nothing to check. 2609 if (t.ty == Tenum && !(cast(TypeEnum)t).sym.memtype) 2610 return false; 2611 2612 if (t.isimaginary() || t.iscomplex()) 2613 { 2614 Type rt; 2615 switch (t.ty) 2616 { 2617 case Tcomplex32: 2618 case Timaginary32: 2619 rt = Type.tfloat32; 2620 break; 2621 2622 case Tcomplex64: 2623 case Timaginary64: 2624 rt = Type.tfloat64; 2625 break; 2626 2627 case Tcomplex80: 2628 case Timaginary80: 2629 rt = Type.tfloat80; 2630 break; 2631 2632 default: 2633 assert(0); 2634 } 2635 if (t.iscomplex()) 2636 { 2637 deprecation(loc, "use of complex type `%s` is deprecated, use `std.complex.Complex!(%s)` instead", 2638 toChars(), rt.toChars()); 2639 return true; 2640 } 2641 else 2642 { 2643 deprecation(loc, "use of imaginary type `%s` is deprecated, use `%s` instead", 2644 toChars(), rt.toChars()); 2645 return true; 2646 } 2647 } 2648 return false; 2649 } 2650 2651 // For eliminating dynamic_cast 2652 TypeBasic isTypeBasic() 2653 { 2654 return null; 2655 } 2656 2657 final pure inout nothrow @nogc 2658 { 2659 inout(TypeError) isTypeError() { return ty == Terror ? cast(typeof(return))this : null; } 2660 inout(TypeVector) isTypeVector() { return ty == Tvector ? cast(typeof(return))this : null; } 2661 inout(TypeSArray) isTypeSArray() { return ty == Tsarray ? cast(typeof(return))this : null; } 2662 inout(TypeDArray) isTypeDArray() { return ty == Tarray ? cast(typeof(return))this : null; } 2663 inout(TypeAArray) isTypeAArray() { return ty == Taarray ? cast(typeof(return))this : null; } 2664 inout(TypePointer) isTypePointer() { return ty == Tpointer ? cast(typeof(return))this : null; } 2665 inout(TypeReference) isTypeReference() { return ty == Treference ? cast(typeof(return))this : null; } 2666 inout(TypeFunction) isTypeFunction() { return ty == Tfunction ? cast(typeof(return))this : null; } 2667 inout(TypeDelegate) isTypeDelegate() { return ty == Tdelegate ? cast(typeof(return))this : null; } 2668 inout(TypeIdentifier) isTypeIdentifier() { return ty == Tident ? cast(typeof(return))this : null; } 2669 inout(TypeInstance) isTypeInstance() { return ty == Tinstance ? cast(typeof(return))this : null; } 2670 inout(TypeTypeof) isTypeTypeof() { return ty == Ttypeof ? cast(typeof(return))this : null; } 2671 inout(TypeReturn) isTypeReturn() { return ty == Treturn ? cast(typeof(return))this : null; } 2672 inout(TypeStruct) isTypeStruct() { return ty == Tstruct ? cast(typeof(return))this : null; } 2673 inout(TypeEnum) isTypeEnum() { return ty == Tenum ? cast(typeof(return))this : null; } 2674 inout(TypeClass) isTypeClass() { return ty == Tclass ? cast(typeof(return))this : null; } 2675 inout(TypeTuple) isTypeTuple() { return ty == Ttuple ? cast(typeof(return))this : null; } 2676 inout(TypeSlice) isTypeSlice() { return ty == Tslice ? cast(typeof(return))this : null; } 2677 inout(TypeNull) isTypeNull() { return ty == Tnull ? cast(typeof(return))this : null; } 2678 inout(TypeMixin) isTypeMixin() { return ty == Tmixin ? cast(typeof(return))this : null; } 2679 inout(TypeTraits) isTypeTraits() { return ty == Ttraits ? cast(typeof(return))this : null; } 2680 } 2681 2682 override void accept(Visitor v) 2683 { 2684 v.visit(this); 2685 } 2686 2687 final TypeFunction toTypeFunction() 2688 { 2689 if (ty != Tfunction) 2690 assert(0); 2691 return cast(TypeFunction)this; 2692 } 2693 } 2694 2695 /*********************************************************** 2696 */ 2697 extern (C++) final class TypeError : Type 2698 { 2699 extern (D) this() 2700 { 2701 super(Terror); 2702 } 2703 2704 override Type syntaxCopy() 2705 { 2706 // No semantic analysis done, no need to copy 2707 return this; 2708 } 2709 2710 override d_uns64 size(const ref Loc loc) 2711 { 2712 return SIZE_INVALID; 2713 } 2714 2715 override Expression defaultInitLiteral(const ref Loc loc) 2716 { 2717 return new ErrorExp(); 2718 } 2719 2720 override void accept(Visitor v) 2721 { 2722 v.visit(this); 2723 } 2724 } 2725 2726 /*********************************************************** 2727 */ 2728 extern (C++) abstract class TypeNext : Type 2729 { 2730 Type next; 2731 2732 final extern (D) this(TY ty, Type next) 2733 { 2734 super(ty); 2735 this.next = next; 2736 } 2737 2738 override final void checkDeprecated(const ref Loc loc, Scope* sc) 2739 { 2740 Type.checkDeprecated(loc, sc); 2741 if (next) // next can be NULL if TypeFunction and auto return type 2742 next.checkDeprecated(loc, sc); 2743 } 2744 2745 override final int hasWild() const 2746 { 2747 if (ty == Tfunction) 2748 return 0; 2749 if (ty == Tdelegate) 2750 return Type.hasWild(); 2751 return mod & MODFlags.wild || (next && next.hasWild()); 2752 } 2753 2754 /******************************* 2755 * For TypeFunction, nextOf() can return NULL if the function return 2756 * type is meant to be inferred, and semantic() hasn't yet ben run 2757 * on the function. After semantic(), it must no longer be NULL. 2758 */ 2759 override final Type nextOf() 2760 { 2761 return next; 2762 } 2763 2764 override final Type makeConst() 2765 { 2766 //printf("TypeNext::makeConst() %p, %s\n", this, toChars()); 2767 if (cto) 2768 { 2769 assert(cto.mod == MODFlags.const_); 2770 return cto; 2771 } 2772 TypeNext t = cast(TypeNext)Type.makeConst(); 2773 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable()) 2774 { 2775 if (next.isShared()) 2776 { 2777 if (next.isWild()) 2778 t.next = next.sharedWildConstOf(); 2779 else 2780 t.next = next.sharedConstOf(); 2781 } 2782 else 2783 { 2784 if (next.isWild()) 2785 t.next = next.wildConstOf(); 2786 else 2787 t.next = next.constOf(); 2788 } 2789 } 2790 //printf("TypeNext::makeConst() returns %p, %s\n", t, t.toChars()); 2791 return t; 2792 } 2793 2794 override final Type makeImmutable() 2795 { 2796 //printf("TypeNext::makeImmutable() %s\n", toChars()); 2797 if (ito) 2798 { 2799 assert(ito.isImmutable()); 2800 return ito; 2801 } 2802 TypeNext t = cast(TypeNext)Type.makeImmutable(); 2803 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable()) 2804 { 2805 t.next = next.immutableOf(); 2806 } 2807 return t; 2808 } 2809 2810 override final Type makeShared() 2811 { 2812 //printf("TypeNext::makeShared() %s\n", toChars()); 2813 if (sto) 2814 { 2815 assert(sto.mod == MODFlags.shared_); 2816 return sto; 2817 } 2818 TypeNext t = cast(TypeNext)Type.makeShared(); 2819 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable()) 2820 { 2821 if (next.isWild()) 2822 { 2823 if (next.isConst()) 2824 t.next = next.sharedWildConstOf(); 2825 else 2826 t.next = next.sharedWildOf(); 2827 } 2828 else 2829 { 2830 if (next.isConst()) 2831 t.next = next.sharedConstOf(); 2832 else 2833 t.next = next.sharedOf(); 2834 } 2835 } 2836 //printf("TypeNext::makeShared() returns %p, %s\n", t, t.toChars()); 2837 return t; 2838 } 2839 2840 override final Type makeSharedConst() 2841 { 2842 //printf("TypeNext::makeSharedConst() %s\n", toChars()); 2843 if (scto) 2844 { 2845 assert(scto.mod == (MODFlags.shared_ | MODFlags.const_)); 2846 return scto; 2847 } 2848 TypeNext t = cast(TypeNext)Type.makeSharedConst(); 2849 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable()) 2850 { 2851 if (next.isWild()) 2852 t.next = next.sharedWildConstOf(); 2853 else 2854 t.next = next.sharedConstOf(); 2855 } 2856 //printf("TypeNext::makeSharedConst() returns %p, %s\n", t, t.toChars()); 2857 return t; 2858 } 2859 2860 override final Type makeWild() 2861 { 2862 //printf("TypeNext::makeWild() %s\n", toChars()); 2863 if (wto) 2864 { 2865 assert(wto.mod == MODFlags.wild); 2866 return wto; 2867 } 2868 TypeNext t = cast(TypeNext)Type.makeWild(); 2869 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable()) 2870 { 2871 if (next.isShared()) 2872 { 2873 if (next.isConst()) 2874 t.next = next.sharedWildConstOf(); 2875 else 2876 t.next = next.sharedWildOf(); 2877 } 2878 else 2879 { 2880 if (next.isConst()) 2881 t.next = next.wildConstOf(); 2882 else 2883 t.next = next.wildOf(); 2884 } 2885 } 2886 //printf("TypeNext::makeWild() returns %p, %s\n", t, t.toChars()); 2887 return t; 2888 } 2889 2890 override final Type makeWildConst() 2891 { 2892 //printf("TypeNext::makeWildConst() %s\n", toChars()); 2893 if (wcto) 2894 { 2895 assert(wcto.mod == MODFlags.wildconst); 2896 return wcto; 2897 } 2898 TypeNext t = cast(TypeNext)Type.makeWildConst(); 2899 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable()) 2900 { 2901 if (next.isShared()) 2902 t.next = next.sharedWildConstOf(); 2903 else 2904 t.next = next.wildConstOf(); 2905 } 2906 //printf("TypeNext::makeWildConst() returns %p, %s\n", t, t.toChars()); 2907 return t; 2908 } 2909 2910 override final Type makeSharedWild() 2911 { 2912 //printf("TypeNext::makeSharedWild() %s\n", toChars()); 2913 if (swto) 2914 { 2915 assert(swto.isSharedWild()); 2916 return swto; 2917 } 2918 TypeNext t = cast(TypeNext)Type.makeSharedWild(); 2919 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable()) 2920 { 2921 if (next.isConst()) 2922 t.next = next.sharedWildConstOf(); 2923 else 2924 t.next = next.sharedWildOf(); 2925 } 2926 //printf("TypeNext::makeSharedWild() returns %p, %s\n", t, t.toChars()); 2927 return t; 2928 } 2929 2930 override final Type makeSharedWildConst() 2931 { 2932 //printf("TypeNext::makeSharedWildConst() %s\n", toChars()); 2933 if (swcto) 2934 { 2935 assert(swcto.mod == (MODFlags.shared_ | MODFlags.wildconst)); 2936 return swcto; 2937 } 2938 TypeNext t = cast(TypeNext)Type.makeSharedWildConst(); 2939 if (ty != Tfunction && next.ty != Tfunction && !next.isImmutable()) 2940 { 2941 t.next = next.sharedWildConstOf(); 2942 } 2943 //printf("TypeNext::makeSharedWildConst() returns %p, %s\n", t, t.toChars()); 2944 return t; 2945 } 2946 2947 override final Type makeMutable() 2948 { 2949 //printf("TypeNext::makeMutable() %p, %s\n", this, toChars()); 2950 TypeNext t = cast(TypeNext)Type.makeMutable(); 2951 if (ty == Tsarray) 2952 { 2953 t.next = next.mutableOf(); 2954 } 2955 //printf("TypeNext::makeMutable() returns %p, %s\n", t, t.toChars()); 2956 return t; 2957 } 2958 2959 override MATCH constConv(Type to) 2960 { 2961 //printf("TypeNext::constConv from = %s, to = %s\n", toChars(), to.toChars()); 2962 if (equals(to)) 2963 return MATCH.exact; 2964 2965 if (!(ty == to.ty && MODimplicitConv(mod, to.mod))) 2966 return MATCH.nomatch; 2967 2968 Type tn = to.nextOf(); 2969 if (!(tn && next.ty == tn.ty)) 2970 return MATCH.nomatch; 2971 2972 MATCH m; 2973 if (to.isConst()) // whole tail const conversion 2974 { 2975 // Recursive shared level check 2976 m = next.constConv(tn); 2977 if (m == MATCH.exact) 2978 m = MATCH.constant; 2979 } 2980 else 2981 { 2982 //printf("\tnext => %s, to.next => %s\n", next.toChars(), tn.toChars()); 2983 m = next.equals(tn) ? MATCH.constant : MATCH.nomatch; 2984 } 2985 return m; 2986 } 2987 2988 override final MOD deduceWild(Type t, bool isRef) 2989 { 2990 if (ty == Tfunction) 2991 return 0; 2992 2993 ubyte wm; 2994 2995 Type tn = t.nextOf(); 2996 if (!isRef && (ty == Tarray || ty == Tpointer) && tn) 2997 { 2998 wm = next.deduceWild(tn, true); 2999 if (!wm) 3000 wm = Type.deduceWild(t, true); 3001 } 3002 else 3003 { 3004 wm = Type.deduceWild(t, isRef); 3005 if (!wm && tn) 3006 wm = next.deduceWild(tn, true); 3007 } 3008 3009 return wm; 3010 } 3011 3012 final void transitive() 3013 { 3014 /* Invoke transitivity of type attributes 3015 */ 3016 next = next.addMod(mod); 3017 } 3018 3019 override void accept(Visitor v) 3020 { 3021 v.visit(this); 3022 } 3023 } 3024 3025 /*********************************************************** 3026 */ 3027 extern (C++) final class TypeBasic : Type 3028 { 3029 const(char)* dstring; 3030 uint flags; 3031 3032 extern (D) this(TY ty) 3033 { 3034 super(ty); 3035 const(char)* d; 3036 uint flags = 0; 3037 switch (ty) 3038 { 3039 case Tvoid: 3040 d = Token.toChars(TOK.void_); 3041 break; 3042 3043 case Tint8: 3044 d = Token.toChars(TOK.int8); 3045 flags |= TFlags.integral; 3046 break; 3047 3048 case Tuns8: 3049 d = Token.toChars(TOK.uns8); 3050 flags |= TFlags.integral | TFlags.unsigned; 3051 break; 3052 3053 case Tint16: 3054 d = Token.toChars(TOK.int16); 3055 flags |= TFlags.integral; 3056 break; 3057 3058 case Tuns16: 3059 d = Token.toChars(TOK.uns16); 3060 flags |= TFlags.integral | TFlags.unsigned; 3061 break; 3062 3063 case Tint32: 3064 d = Token.toChars(TOK.int32); 3065 flags |= TFlags.integral; 3066 break; 3067 3068 case Tuns32: 3069 d = Token.toChars(TOK.uns32); 3070 flags |= TFlags.integral | TFlags.unsigned; 3071 break; 3072 3073 case Tfloat32: 3074 d = Token.toChars(TOK.float32); 3075 flags |= TFlags.floating | TFlags.real_; 3076 break; 3077 3078 case Tint64: 3079 d = Token.toChars(TOK.int64); 3080 flags |= TFlags.integral; 3081 break; 3082 3083 case Tuns64: 3084 d = Token.toChars(TOK.uns64); 3085 flags |= TFlags.integral | TFlags.unsigned; 3086 break; 3087 3088 case Tint128: 3089 d = Token.toChars(TOK.int128); 3090 flags |= TFlags.integral; 3091 break; 3092 3093 case Tuns128: 3094 d = Token.toChars(TOK.uns128); 3095 flags |= TFlags.integral | TFlags.unsigned; 3096 break; 3097 3098 case Tfloat64: 3099 d = Token.toChars(TOK.float64); 3100 flags |= TFlags.floating | TFlags.real_; 3101 break; 3102 3103 case Tfloat80: 3104 d = Token.toChars(TOK.float80); 3105 flags |= TFlags.floating | TFlags.real_; 3106 break; 3107 3108 case Timaginary32: 3109 d = Token.toChars(TOK.imaginary32); 3110 flags |= TFlags.floating | TFlags.imaginary; 3111 break; 3112 3113 case Timaginary64: 3114 d = Token.toChars(TOK.imaginary64); 3115 flags |= TFlags.floating | TFlags.imaginary; 3116 break; 3117 3118 case Timaginary80: 3119 d = Token.toChars(TOK.imaginary80); 3120 flags |= TFlags.floating | TFlags.imaginary; 3121 break; 3122 3123 case Tcomplex32: 3124 d = Token.toChars(TOK.complex32); 3125 flags |= TFlags.floating | TFlags.complex; 3126 break; 3127 3128 case Tcomplex64: 3129 d = Token.toChars(TOK.complex64); 3130 flags |= TFlags.floating | TFlags.complex; 3131 break; 3132 3133 case Tcomplex80: 3134 d = Token.toChars(TOK.complex80); 3135 flags |= TFlags.floating | TFlags.complex; 3136 break; 3137 3138 case Tbool: 3139 d = "bool"; 3140 flags |= TFlags.integral | TFlags.unsigned; 3141 break; 3142 3143 case Tchar: 3144 d = Token.toChars(TOK.char_); 3145 flags |= TFlags.integral | TFlags.unsigned; 3146 break; 3147 3148 case Twchar: 3149 d = Token.toChars(TOK.wchar_); 3150 flags |= TFlags.integral | TFlags.unsigned; 3151 break; 3152 3153 case Tdchar: 3154 d = Token.toChars(TOK.dchar_); 3155 flags |= TFlags.integral | TFlags.unsigned; 3156 break; 3157 3158 default: 3159 assert(0); 3160 } 3161 this.dstring = d; 3162 this.flags = flags; 3163 merge(this); 3164 } 3165 3166 override const(char)* kind() const 3167 { 3168 return dstring; 3169 } 3170 3171 override Type syntaxCopy() 3172 { 3173 // No semantic analysis done on basic types, no need to copy 3174 return this; 3175 } 3176 3177 override d_uns64 size(const ref Loc loc) const 3178 { 3179 uint size; 3180 //printf("TypeBasic::size()\n"); 3181 switch (ty) 3182 { 3183 case Tint8: 3184 case Tuns8: 3185 size = 1; 3186 break; 3187 3188 case Tint16: 3189 case Tuns16: 3190 size = 2; 3191 break; 3192 3193 case Tint32: 3194 case Tuns32: 3195 case Tfloat32: 3196 case Timaginary32: 3197 size = 4; 3198 break; 3199 3200 case Tint64: 3201 case Tuns64: 3202 case Tfloat64: 3203 case Timaginary64: 3204 size = 8; 3205 break; 3206 3207 case Tfloat80: 3208 case Timaginary80: 3209 size = target.realsize; 3210 break; 3211 3212 case Tcomplex32: 3213 size = 8; 3214 break; 3215 3216 case Tcomplex64: 3217 case Tint128: 3218 case Tuns128: 3219 size = 16; 3220 break; 3221 3222 case Tcomplex80: 3223 size = target.realsize * 2; 3224 break; 3225 3226 case Tvoid: 3227 //size = Type::size(); // error message 3228 size = 1; 3229 break; 3230 3231 case Tbool: 3232 size = 1; 3233 break; 3234 3235 case Tchar: 3236 size = 1; 3237 break; 3238 3239 case Twchar: 3240 size = 2; 3241 break; 3242 3243 case Tdchar: 3244 size = 4; 3245 break; 3246 3247 default: 3248 assert(0); 3249 } 3250 //printf("TypeBasic::size() = %d\n", size); 3251 return size; 3252 } 3253 3254 override uint alignsize() 3255 { 3256 return target.alignsize(this); 3257 } 3258 3259 override bool isintegral() 3260 { 3261 //printf("TypeBasic::isintegral('%s') x%x\n", toChars(), flags); 3262 return (flags & TFlags.integral) != 0; 3263 } 3264 3265 override bool isfloating() const 3266 { 3267 return (flags & TFlags.floating) != 0; 3268 } 3269 3270 override bool isreal() const 3271 { 3272 return (flags & TFlags.real_) != 0; 3273 } 3274 3275 override bool isimaginary() const 3276 { 3277 return (flags & TFlags.imaginary) != 0; 3278 } 3279 3280 override bool iscomplex() const 3281 { 3282 return (flags & TFlags.complex) != 0; 3283 } 3284 3285 override bool isscalar() const 3286 { 3287 return (flags & (TFlags.integral | TFlags.floating)) != 0; 3288 } 3289 3290 override bool isunsigned() const 3291 { 3292 return (flags & TFlags.unsigned) != 0; 3293 } 3294 3295 override MATCH implicitConvTo(Type to) 3296 { 3297 //printf("TypeBasic::implicitConvTo(%s) from %s\n", to.toChars(), toChars()); 3298 if (this == to) 3299 return MATCH.exact; 3300 3301 if (ty == to.ty) 3302 { 3303 if (mod == to.mod) 3304 return MATCH.exact; 3305 else if (MODimplicitConv(mod, to.mod)) 3306 return MATCH.constant; 3307 else if (!((mod ^ to.mod) & MODFlags.shared_)) // for wild matching 3308 return MATCH.constant; 3309 else 3310 return MATCH.convert; 3311 } 3312 3313 if (ty == Tvoid || to.ty == Tvoid) 3314 return MATCH.nomatch; 3315 if (to.ty == Tbool) 3316 return MATCH.nomatch; 3317 3318 TypeBasic tob; 3319 if (to.ty == Tvector && to.deco) 3320 { 3321 TypeVector tv = cast(TypeVector)to; 3322 tob = tv.elementType(); 3323 } 3324 else if (auto te = to.isTypeEnum()) 3325 { 3326 EnumDeclaration ed = te.sym; 3327 if (ed.isSpecial()) 3328 { 3329 /* Special enums that allow implicit conversions to them 3330 * with a MATCH.convert 3331 */ 3332 tob = to.toBasetype().isTypeBasic(); 3333 } 3334 else 3335 return MATCH.nomatch; 3336 } 3337 else 3338 tob = to.isTypeBasic(); 3339 if (!tob) 3340 return MATCH.nomatch; 3341 3342 if (flags & TFlags.integral) 3343 { 3344 // Disallow implicit conversion of integers to imaginary or complex 3345 if (tob.flags & (TFlags.imaginary | TFlags.complex)) 3346 return MATCH.nomatch; 3347 3348 // If converting from integral to integral 3349 if (tob.flags & TFlags.integral) 3350 { 3351 d_uns64 sz = size(Loc.initial); 3352 d_uns64 tosz = tob.size(Loc.initial); 3353 3354 /* Can't convert to smaller size 3355 */ 3356 if (sz > tosz) 3357 return MATCH.nomatch; 3358 /* Can't change sign if same size 3359 */ 3360 //if (sz == tosz && (flags ^ tob.flags) & TFlags.unsigned) 3361 // return MATCH.nomatch; 3362 } 3363 } 3364 else if (flags & TFlags.floating) 3365 { 3366 // Disallow implicit conversion of floating point to integer 3367 if (tob.flags & TFlags.integral) 3368 return MATCH.nomatch; 3369 3370 assert(tob.flags & TFlags.floating || to.ty == Tvector); 3371 3372 // Disallow implicit conversion from complex to non-complex 3373 if (flags & TFlags.complex && !(tob.flags & TFlags.complex)) 3374 return MATCH.nomatch; 3375 3376 // Disallow implicit conversion of real or imaginary to complex 3377 if (flags & (TFlags.real_ | TFlags.imaginary) && tob.flags & TFlags.complex) 3378 return MATCH.nomatch; 3379 3380 // Disallow implicit conversion to-from real and imaginary 3381 if ((flags & (TFlags.real_ | TFlags.imaginary)) != (tob.flags & (TFlags.real_ | TFlags.imaginary))) 3382 return MATCH.nomatch; 3383 } 3384 return MATCH.convert; 3385 } 3386 3387 override bool isZeroInit(const ref Loc loc) const 3388 { 3389 switch (ty) 3390 { 3391 case Tchar: 3392 case Twchar: 3393 case Tdchar: 3394 case Timaginary32: 3395 case Timaginary64: 3396 case Timaginary80: 3397 case Tfloat32: 3398 case Tfloat64: 3399 case Tfloat80: 3400 case Tcomplex32: 3401 case Tcomplex64: 3402 case Tcomplex80: 3403 return false; // no 3404 default: 3405 return true; // yes 3406 } 3407 } 3408 3409 // For eliminating dynamic_cast 3410 override TypeBasic isTypeBasic() 3411 { 3412 return this; 3413 } 3414 3415 override void accept(Visitor v) 3416 { 3417 v.visit(this); 3418 } 3419 } 3420 3421 /*********************************************************** 3422 * The basetype must be one of: 3423 * byte[16],ubyte[16],short[8],ushort[8],int[4],uint[4],long[2],ulong[2],float[4],double[2] 3424 * For AVX: 3425 * byte[32],ubyte[32],short[16],ushort[16],int[8],uint[8],long[4],ulong[4],float[8],double[4] 3426 */ 3427 extern (C++) final class TypeVector : Type 3428 { 3429 Type basetype; 3430 3431 extern (D) this(Type basetype) 3432 { 3433 super(Tvector); 3434 this.basetype = basetype; 3435 } 3436 3437 static TypeVector create(Type basetype) 3438 { 3439 return new TypeVector(basetype); 3440 } 3441 3442 override const(char)* kind() const 3443 { 3444 return "vector"; 3445 } 3446 3447 override Type syntaxCopy() 3448 { 3449 return new TypeVector(basetype.syntaxCopy()); 3450 } 3451 3452 override d_uns64 size(const ref Loc loc) 3453 { 3454 return basetype.size(); 3455 } 3456 3457 override uint alignsize() 3458 { 3459 return cast(uint)basetype.size(); 3460 } 3461 3462 override bool isintegral() 3463 { 3464 //printf("TypeVector::isintegral('%s') x%x\n", toChars(), flags); 3465 return basetype.nextOf().isintegral(); 3466 } 3467 3468 override bool isfloating() 3469 { 3470 return basetype.nextOf().isfloating(); 3471 } 3472 3473 override bool isscalar() 3474 { 3475 return basetype.nextOf().isscalar(); 3476 } 3477 3478 override bool isunsigned() 3479 { 3480 return basetype.nextOf().isunsigned(); 3481 } 3482 3483 override bool isBoolean() const 3484 { 3485 return false; 3486 } 3487 3488 override MATCH implicitConvTo(Type to) 3489 { 3490 //printf("TypeVector::implicitConvTo(%s) from %s\n", to.toChars(), toChars()); 3491 if (this == to) 3492 return MATCH.exact; 3493 if (ty == to.ty) 3494 return MATCH.convert; 3495 return MATCH.nomatch; 3496 } 3497 3498 override Expression defaultInitLiteral(const ref Loc loc) 3499 { 3500 //printf("TypeVector::defaultInitLiteral()\n"); 3501 assert(basetype.ty == Tsarray); 3502 Expression e = basetype.defaultInitLiteral(loc); 3503 auto ve = new VectorExp(loc, e, this); 3504 ve.type = this; 3505 ve.dim = cast(int)(basetype.size(loc) / elementType().size(loc)); 3506 return ve; 3507 } 3508 3509 TypeBasic elementType() 3510 { 3511 assert(basetype.ty == Tsarray); 3512 TypeSArray t = cast(TypeSArray)basetype; 3513 TypeBasic tb = t.nextOf().isTypeBasic(); 3514 assert(tb); 3515 return tb; 3516 } 3517 3518 override bool isZeroInit(const ref Loc loc) 3519 { 3520 return basetype.isZeroInit(loc); 3521 } 3522 3523 override void accept(Visitor v) 3524 { 3525 v.visit(this); 3526 } 3527 } 3528 3529 /*********************************************************** 3530 */ 3531 extern (C++) abstract class TypeArray : TypeNext 3532 { 3533 final extern (D) this(TY ty, Type next) 3534 { 3535 super(ty, next); 3536 } 3537 3538 override void accept(Visitor v) 3539 { 3540 v.visit(this); 3541 } 3542 } 3543 3544 /*********************************************************** 3545 * Static array, one with a fixed dimension 3546 */ 3547 extern (C++) final class TypeSArray : TypeArray 3548 { 3549 Expression dim; 3550 3551 extern (D) this(Type t, Expression dim) 3552 { 3553 super(Tsarray, t); 3554 //printf("TypeSArray(%s)\n", dim.toChars()); 3555 this.dim = dim; 3556 } 3557 3558 override const(char)* kind() const 3559 { 3560 return "sarray"; 3561 } 3562 3563 override Type syntaxCopy() 3564 { 3565 Type t = next.syntaxCopy(); 3566 Expression e = dim.syntaxCopy(); 3567 t = new TypeSArray(t, e); 3568 t.mod = mod; 3569 return t; 3570 } 3571 3572 override d_uns64 size(const ref Loc loc) 3573 { 3574 //printf("TypeSArray::size()\n"); 3575 const n = numberOfElems(loc); 3576 const elemsize = baseElemOf().size(loc); 3577 bool overflow = false; 3578 const sz = mulu(n, elemsize, overflow); 3579 if (overflow || sz >= uint.max) 3580 { 3581 if (elemsize != SIZE_INVALID && n != uint.max) 3582 error(loc, "static array `%s` size overflowed to %lld", toChars(), cast(long)sz); 3583 return SIZE_INVALID; 3584 } 3585 return sz; 3586 } 3587 3588 override uint alignsize() 3589 { 3590 return next.alignsize(); 3591 } 3592 3593 override bool isString() 3594 { 3595 TY nty = next.toBasetype().ty; 3596 return nty.isSomeChar; 3597 } 3598 3599 override bool isZeroInit(const ref Loc loc) 3600 { 3601 return next.isZeroInit(loc); 3602 } 3603 3604 override structalign_t alignment() 3605 { 3606 return next.alignment(); 3607 } 3608 3609 override MATCH constConv(Type to) 3610 { 3611 if (auto tsa = to.isTypeSArray()) 3612 { 3613 if (!dim.equals(tsa.dim)) 3614 return MATCH.nomatch; 3615 } 3616 return TypeNext.constConv(to); 3617 } 3618 3619 override MATCH implicitConvTo(Type to) 3620 { 3621 //printf("TypeSArray::implicitConvTo(to = %s) this = %s\n", to.toChars(), toChars()); 3622 if (auto ta = to.isTypeDArray()) 3623 { 3624 if (!MODimplicitConv(next.mod, ta.next.mod)) 3625 return MATCH.nomatch; 3626 3627 /* Allow conversion to void[] 3628 */ 3629 if (ta.next.ty == Tvoid) 3630 { 3631 return MATCH.convert; 3632 } 3633 3634 MATCH m = next.constConv(ta.next); 3635 if (m > MATCH.nomatch) 3636 { 3637 return MATCH.convert; 3638 } 3639 return MATCH.nomatch; 3640 } 3641 if (auto tsa = to.isTypeSArray()) 3642 { 3643 if (this == to) 3644 return MATCH.exact; 3645 3646 if (dim.equals(tsa.dim)) 3647 { 3648 /* Since static arrays are value types, allow 3649 * conversions from const elements to non-const 3650 * ones, just like we allow conversion from const int 3651 * to int. 3652 */ 3653 MATCH m = next.implicitConvTo(tsa.next); 3654 if (m >= MATCH.constant) 3655 { 3656 if (mod != to.mod) 3657 m = MATCH.constant; 3658 return m; 3659 } 3660 } 3661 } 3662 return MATCH.nomatch; 3663 } 3664 3665 override Expression defaultInitLiteral(const ref Loc loc) 3666 { 3667 static if (LOGDEFAULTINIT) 3668 { 3669 printf("TypeSArray::defaultInitLiteral() '%s'\n", toChars()); 3670 } 3671 size_t d = cast(size_t)dim.toInteger(); 3672 Expression elementinit; 3673 if (next.ty == Tvoid) 3674 elementinit = tuns8.defaultInitLiteral(loc); 3675 else 3676 elementinit = next.defaultInitLiteral(loc); 3677 auto elements = new Expressions(d); 3678 foreach (ref e; *elements) 3679 e = null; 3680 auto ae = new ArrayLiteralExp(Loc.initial, this, elementinit, elements); 3681 return ae; 3682 } 3683 3684 override bool hasPointers() 3685 { 3686 /* Don't want to do this, because: 3687 * struct S { T* array[0]; } 3688 * may be a variable length struct. 3689 */ 3690 //if (dim.toInteger() == 0) 3691 // return false; 3692 3693 if (next.ty == Tvoid) 3694 { 3695 // Arrays of void contain arbitrary data, which may include pointers 3696 return true; 3697 } 3698 else 3699 return next.hasPointers(); 3700 } 3701 3702 override bool needsDestruction() 3703 { 3704 return next.needsDestruction(); 3705 } 3706 3707 override bool needsCopyOrPostblit() 3708 { 3709 return next.needsCopyOrPostblit(); 3710 } 3711 3712 /********************************* 3713 * 3714 */ 3715 override bool needsNested() 3716 { 3717 return next.needsNested(); 3718 } 3719 3720 override void accept(Visitor v) 3721 { 3722 v.visit(this); 3723 } 3724 } 3725 3726 /*********************************************************** 3727 * Dynamic array, no dimension 3728 */ 3729 extern (C++) final class TypeDArray : TypeArray 3730 { 3731 extern (D) this(Type t) 3732 { 3733 super(Tarray, t); 3734 //printf("TypeDArray(t = %p)\n", t); 3735 } 3736 3737 override const(char)* kind() const 3738 { 3739 return "darray"; 3740 } 3741 3742 override Type syntaxCopy() 3743 { 3744 Type t = next.syntaxCopy(); 3745 if (t == next) 3746 t = this; 3747 else 3748 { 3749 t = new TypeDArray(t); 3750 t.mod = mod; 3751 } 3752 return t; 3753 } 3754 3755 override d_uns64 size(const ref Loc loc) const 3756 { 3757 //printf("TypeDArray::size()\n"); 3758 return target.ptrsize * 2; 3759 } 3760 3761 override uint alignsize() const 3762 { 3763 // A DArray consists of two ptr-sized values, so align it on pointer size 3764 // boundary 3765 return target.ptrsize; 3766 } 3767 3768 override bool isString() 3769 { 3770 TY nty = next.toBasetype().ty; 3771 return nty.isSomeChar; 3772 } 3773 3774 override bool isZeroInit(const ref Loc loc) const 3775 { 3776 return true; 3777 } 3778 3779 override bool isBoolean() const 3780 { 3781 return true; 3782 } 3783 3784 override MATCH implicitConvTo(Type to) 3785 { 3786 //printf("TypeDArray::implicitConvTo(to = %s) this = %s\n", to.toChars(), toChars()); 3787 if (equals(to)) 3788 return MATCH.exact; 3789 3790 if (auto ta = to.isTypeDArray()) 3791 { 3792 if (!MODimplicitConv(next.mod, ta.next.mod)) 3793 return MATCH.nomatch; // not const-compatible 3794 3795 /* Allow conversion to void[] 3796 */ 3797 if (next.ty != Tvoid && ta.next.ty == Tvoid) 3798 { 3799 return MATCH.convert; 3800 } 3801 3802 MATCH m = next.constConv(ta.next); 3803 if (m > MATCH.nomatch) 3804 { 3805 if (m == MATCH.exact && mod != to.mod) 3806 m = MATCH.constant; 3807 return m; 3808 } 3809 } 3810 return Type.implicitConvTo(to); 3811 } 3812 3813 override bool hasPointers() const 3814 { 3815 return true; 3816 } 3817 3818 override void accept(Visitor v) 3819 { 3820 v.visit(this); 3821 } 3822 } 3823 3824 /*********************************************************** 3825 */ 3826 extern (C++) final class TypeAArray : TypeArray 3827 { 3828 Type index; // key type 3829 Loc loc; 3830 Scope* sc; 3831 3832 extern (D) this(Type t, Type index) 3833 { 3834 super(Taarray, t); 3835 this.index = index; 3836 } 3837 3838 static TypeAArray create(Type t, Type index) 3839 { 3840 return new TypeAArray(t, index); 3841 } 3842 3843 override const(char)* kind() const 3844 { 3845 return "aarray"; 3846 } 3847 3848 override Type syntaxCopy() 3849 { 3850 Type t = next.syntaxCopy(); 3851 Type ti = index.syntaxCopy(); 3852 if (t == next && ti == index) 3853 t = this; 3854 else 3855 { 3856 t = new TypeAArray(t, ti); 3857 t.mod = mod; 3858 } 3859 return t; 3860 } 3861 3862 override d_uns64 size(const ref Loc loc) const 3863 { 3864 return target.ptrsize; 3865 } 3866 3867 override bool isZeroInit(const ref Loc loc) const 3868 { 3869 return true; 3870 } 3871 3872 override bool isBoolean() const 3873 { 3874 return true; 3875 } 3876 3877 override bool hasPointers() const 3878 { 3879 return true; 3880 } 3881 3882 override MATCH implicitConvTo(Type to) 3883 { 3884 //printf("TypeAArray::implicitConvTo(to = %s) this = %s\n", to.toChars(), toChars()); 3885 if (equals(to)) 3886 return MATCH.exact; 3887 3888 if (auto ta = to.isTypeAArray()) 3889 { 3890 if (!MODimplicitConv(next.mod, ta.next.mod)) 3891 return MATCH.nomatch; // not const-compatible 3892 3893 if (!MODimplicitConv(index.mod, ta.index.mod)) 3894 return MATCH.nomatch; // not const-compatible 3895 3896 MATCH m = next.constConv(ta.next); 3897 MATCH mi = index.constConv(ta.index); 3898 if (m > MATCH.nomatch && mi > MATCH.nomatch) 3899 { 3900 return MODimplicitConv(mod, to.mod) ? MATCH.constant : MATCH.nomatch; 3901 } 3902 } 3903 return Type.implicitConvTo(to); 3904 } 3905 3906 override MATCH constConv(Type to) 3907 { 3908 if (auto taa = to.isTypeAArray()) 3909 { 3910 MATCH mindex = index.constConv(taa.index); 3911 MATCH mkey = next.constConv(taa.next); 3912 // Pick the worst match 3913 return mkey < mindex ? mkey : mindex; 3914 } 3915 return Type.constConv(to); 3916 } 3917 3918 override void accept(Visitor v) 3919 { 3920 v.visit(this); 3921 } 3922 } 3923 3924 /*********************************************************** 3925 */ 3926 extern (C++) final class TypePointer : TypeNext 3927 { 3928 extern (D) this(Type t) 3929 { 3930 super(Tpointer, t); 3931 } 3932 3933 static TypePointer create(Type t) 3934 { 3935 return new TypePointer(t); 3936 } 3937 3938 override const(char)* kind() const 3939 { 3940 return "pointer"; 3941 } 3942 3943 override Type syntaxCopy() 3944 { 3945 Type t = next.syntaxCopy(); 3946 if (t == next) 3947 t = this; 3948 else 3949 { 3950 t = new TypePointer(t); 3951 t.mod = mod; 3952 } 3953 return t; 3954 } 3955 3956 override d_uns64 size(const ref Loc loc) const 3957 { 3958 return target.ptrsize; 3959 } 3960 3961 override MATCH implicitConvTo(Type to) 3962 { 3963 //printf("TypePointer::implicitConvTo(to = %s) %s\n", to.toChars(), toChars()); 3964 if (equals(to)) 3965 return MATCH.exact; 3966 3967 if (next.ty == Tfunction) 3968 { 3969 if (auto tp = to.isTypePointer()) 3970 { 3971 if (tp.next.ty == Tfunction) 3972 { 3973 if (next.equals(tp.next)) 3974 return MATCH.constant; 3975 3976 if (next.covariant(tp.next) == 1) 3977 { 3978 Type tret = this.next.nextOf(); 3979 Type toret = tp.next.nextOf(); 3980 if (tret.ty == Tclass && toret.ty == Tclass) 3981 { 3982 /* https://issues.dlang.org/show_bug.cgi?id=10219 3983 * Check covariant interface return with offset tweaking. 3984 * interface I {} 3985 * class C : Object, I {} 3986 * I function() dg = function C() {} // should be error 3987 */ 3988 int offset = 0; 3989 if (toret.isBaseOf(tret, &offset) && offset != 0) 3990 return MATCH.nomatch; 3991 } 3992 return MATCH.convert; 3993 } 3994 } 3995 else if (tp.next.ty == Tvoid) 3996 { 3997 // Allow conversions to void* 3998 return MATCH.convert; 3999 } 4000 } 4001 return MATCH.nomatch; 4002 } 4003 else if (auto tp = to.isTypePointer()) 4004 { 4005 assert(tp.next); 4006 4007 if (!MODimplicitConv(next.mod, tp.next.mod)) 4008 return MATCH.nomatch; // not const-compatible 4009 4010 /* Alloc conversion to void* 4011 */ 4012 if (next.ty != Tvoid && tp.next.ty == Tvoid) 4013 { 4014 return MATCH.convert; 4015 } 4016 4017 MATCH m = next.constConv(tp.next); 4018 if (m > MATCH.nomatch) 4019 { 4020 if (m == MATCH.exact && mod != to.mod) 4021 m = MATCH.constant; 4022 return m; 4023 } 4024 } 4025 return MATCH.nomatch; 4026 } 4027 4028 override MATCH constConv(Type to) 4029 { 4030 if (next.ty == Tfunction) 4031 { 4032 if (to.nextOf() && next.equals((cast(TypeNext)to).next)) 4033 return Type.constConv(to); 4034 else 4035 return MATCH.nomatch; 4036 } 4037 return TypeNext.constConv(to); 4038 } 4039 4040 override bool isscalar() const 4041 { 4042 return true; 4043 } 4044 4045 override bool isZeroInit(const ref Loc loc) const 4046 { 4047 return true; 4048 } 4049 4050 override bool hasPointers() const 4051 { 4052 return true; 4053 } 4054 4055 override void accept(Visitor v) 4056 { 4057 v.visit(this); 4058 } 4059 } 4060 4061 /*********************************************************** 4062 */ 4063 extern (C++) final class TypeReference : TypeNext 4064 { 4065 extern (D) this(Type t) 4066 { 4067 super(Treference, t); 4068 // BUG: what about references to static arrays? 4069 } 4070 4071 override const(char)* kind() const 4072 { 4073 return "reference"; 4074 } 4075 4076 override Type syntaxCopy() 4077 { 4078 Type t = next.syntaxCopy(); 4079 if (t == next) 4080 t = this; 4081 else 4082 { 4083 t = new TypeReference(t); 4084 t.mod = mod; 4085 } 4086 return t; 4087 } 4088 4089 override d_uns64 size(const ref Loc loc) const 4090 { 4091 return target.ptrsize; 4092 } 4093 4094 override bool isZeroInit(const ref Loc loc) const 4095 { 4096 return true; 4097 } 4098 4099 override void accept(Visitor v) 4100 { 4101 v.visit(this); 4102 } 4103 } 4104 4105 enum RET : int 4106 { 4107 regs = 1, // returned in registers 4108 stack = 2, // returned on stack 4109 } 4110 4111 enum TRUST : int 4112 { 4113 default_ = 0, 4114 system = 1, // @system (same as TRUST.default) 4115 trusted = 2, // @trusted 4116 safe = 3, // @safe 4117 } 4118 4119 enum TRUSTformat : int 4120 { 4121 TRUSTformatDefault, // do not emit @system when trust == TRUST.default_ 4122 TRUSTformatSystem, // emit @system when trust == TRUST.default_ 4123 } 4124 4125 alias TRUSTformatDefault = TRUSTformat.TRUSTformatDefault; 4126 alias TRUSTformatSystem = TRUSTformat.TRUSTformatSystem; 4127 4128 enum PURE : int 4129 { 4130 impure = 0, // not pure at all 4131 fwdref = 1, // it's pure, but not known which level yet 4132 weak = 2, // no mutable globals are read or written 4133 const_ = 3, // parameters are values or const 4134 strong = 4, // parameters are values or immutable 4135 } 4136 4137 /*********************************************************** 4138 */ 4139 extern (C++) final class TypeFunction : TypeNext 4140 { 4141 // .next is the return type 4142 4143 ParameterList parameterList; // function parameters 4144 4145 bool isnothrow; // true: nothrow 4146 bool isnogc; // true: is @nogc 4147 bool isproperty; // can be called without parentheses 4148 bool isref; // true: returns a reference 4149 bool isreturn; // true: 'this' is returned by ref 4150 bool isscope; // true: 'this' is scope 4151 bool isreturninferred; // true: 'this' is return from inference 4152 bool isscopeinferred; // true: 'this' is scope from inference 4153 bool islive; // is @live 4154 LINK linkage; // calling convention 4155 TRUST trust; // level of trust 4156 PURE purity = PURE.impure; 4157 ubyte iswild; // bit0: inout on params, bit1: inout on qualifier 4158 Expressions* fargs; // function arguments 4159 int inuse; 4160 bool incomplete; // return type or default arguments removed 4161 4162 extern (D) this(ParameterList pl, Type treturn, LINK linkage, StorageClass stc = 0) 4163 { 4164 super(Tfunction, treturn); 4165 //if (!treturn) *(char*)0=0; 4166 // assert(treturn); 4167 assert(VarArg.none <= pl.varargs && pl.varargs <= VarArg.typesafe); 4168 this.parameterList = pl; 4169 this.linkage = linkage; 4170 4171 if (stc & STC.pure_) 4172 this.purity = PURE.fwdref; 4173 if (stc & STC.nothrow_) 4174 this.isnothrow = true; 4175 if (stc & STC.nogc) 4176 this.isnogc = true; 4177 if (stc & STC.property) 4178 this.isproperty = true; 4179 if (stc & STC.live) 4180 this.islive = true; 4181 4182 if (stc & STC.ref_) 4183 this.isref = true; 4184 if (stc & STC.return_) 4185 this.isreturn = true; 4186 if (stc & STC.returninferred) 4187 this.isreturninferred = true; 4188 if (stc & STC.scope_) 4189 this.isscope = true; 4190 if (stc & STC.scopeinferred) 4191 this.isscopeinferred = true; 4192 4193 this.trust = TRUST.default_; 4194 if (stc & STC.safe) 4195 this.trust = TRUST.safe; 4196 if (stc & STC.system) 4197 this.trust = TRUST.system; 4198 if (stc & STC.trusted) 4199 this.trust = TRUST.trusted; 4200 } 4201 4202 static TypeFunction create(Parameters* parameters, Type treturn, VarArg varargs, LINK linkage, StorageClass stc = 0) 4203 { 4204 return new TypeFunction(ParameterList(parameters, varargs), treturn, linkage, stc); 4205 } 4206 4207 override const(char)* kind() const 4208 { 4209 return "function"; 4210 } 4211 4212 override Type syntaxCopy() 4213 { 4214 Type treturn = next ? next.syntaxCopy() : null; 4215 Parameters* params = Parameter.arraySyntaxCopy(parameterList.parameters); 4216 auto t = new TypeFunction(ParameterList(params, parameterList.varargs), treturn, linkage); 4217 t.mod = mod; 4218 t.isnothrow = isnothrow; 4219 t.isnogc = isnogc; 4220 t.purity = purity; 4221 t.isproperty = isproperty; 4222 t.isref = isref; 4223 t.isreturn = isreturn; 4224 t.isscope = isscope; 4225 t.isreturninferred = isreturninferred; 4226 t.isscopeinferred = isscopeinferred; 4227 t.iswild = iswild; 4228 t.trust = trust; 4229 t.fargs = fargs; 4230 return t; 4231 } 4232 4233 /******************************************** 4234 * Set 'purity' field of 'this'. 4235 * Do this lazily, as the parameter types might be forward referenced. 4236 */ 4237 void purityLevel() 4238 { 4239 TypeFunction tf = this; 4240 if (tf.purity != PURE.fwdref) 4241 return; 4242 4243 /* Determine purity level based on mutability of t 4244 * and whether it is a 'ref' type or not. 4245 */ 4246 static PURE purityOfType(bool isref, Type t) 4247 { 4248 if (isref) 4249 { 4250 if (t.mod & MODFlags.immutable_) 4251 return PURE.strong; 4252 if (t.mod & (MODFlags.const_ | MODFlags.wild)) 4253 return PURE.const_; 4254 return PURE.weak; 4255 } 4256 4257 t = t.baseElemOf(); 4258 4259 if (!t.hasPointers() || t.mod & MODFlags.immutable_) 4260 return PURE.strong; 4261 4262 /* Accept immutable(T)[] and immutable(T)* as being strongly pure 4263 */ 4264 if (t.ty == Tarray || t.ty == Tpointer) 4265 { 4266 Type tn = t.nextOf().toBasetype(); 4267 if (tn.mod & MODFlags.immutable_) 4268 return PURE.strong; 4269 if (tn.mod & (MODFlags.const_ | MODFlags.wild)) 4270 return PURE.const_; 4271 } 4272 4273 /* The rest of this is too strict; fix later. 4274 * For example, the only pointer members of a struct may be immutable, 4275 * which would maintain strong purity. 4276 * (Just like for dynamic arrays and pointers above.) 4277 */ 4278 if (t.mod & (MODFlags.const_ | MODFlags.wild)) 4279 return PURE.const_; 4280 4281 /* Should catch delegates and function pointers, and fold in their purity 4282 */ 4283 return PURE.weak; 4284 } 4285 4286 purity = PURE.strong; // assume strong until something weakens it 4287 4288 /* Evaluate what kind of purity based on the modifiers for the parameters 4289 */ 4290 const dim = tf.parameterList.length; 4291 Lloop: foreach (i; 0 .. dim) 4292 { 4293 Parameter fparam = tf.parameterList[i]; 4294 Type t = fparam.type; 4295 if (!t) 4296 continue; 4297 4298 if (fparam.storageClass & (STC.lazy_ | STC.out_)) 4299 { 4300 purity = PURE.weak; 4301 break; 4302 } 4303 switch (purityOfType((fparam.storageClass & STC.ref_) != 0, t)) 4304 { 4305 case PURE.weak: 4306 purity = PURE.weak; 4307 break Lloop; // since PURE.weak, no need to check further 4308 4309 case PURE.const_: 4310 purity = PURE.const_; 4311 continue; 4312 4313 case PURE.strong: 4314 continue; 4315 4316 default: 4317 assert(0); 4318 } 4319 } 4320 4321 if (purity > PURE.weak && tf.nextOf()) 4322 { 4323 /* Adjust purity based on mutability of return type. 4324 * https://issues.dlang.org/show_bug.cgi?id=15862 4325 */ 4326 const purity2 = purityOfType(tf.isref, tf.nextOf()); 4327 if (purity2 < purity) 4328 purity = purity2; 4329 } 4330 tf.purity = purity; 4331 } 4332 4333 /******************************************** 4334 * Return true if there are lazy parameters. 4335 */ 4336 bool hasLazyParameters() 4337 { 4338 size_t dim = parameterList.length; 4339 for (size_t i = 0; i < dim; i++) 4340 { 4341 Parameter fparam = parameterList[i]; 4342 if (fparam.storageClass & STC.lazy_) 4343 return true; 4344 } 4345 return false; 4346 } 4347 4348 /******************************* 4349 * Check for `extern (D) U func(T t, ...)` variadic function type, 4350 * which has `_arguments[]` added as the first argument. 4351 * Returns: 4352 * true if D-style variadic 4353 */ 4354 bool isDstyleVariadic() const pure nothrow 4355 { 4356 return linkage == LINK.d && parameterList.varargs == VarArg.variadic; 4357 } 4358 4359 /*************************** 4360 * Examine function signature for parameter p and see if 4361 * the value of p can 'escape' the scope of the function. 4362 * This is useful to minimize the needed annotations for the parameters. 4363 * Params: 4364 * tthis = type of `this` parameter, null if none 4365 * p = parameter to this function 4366 * Returns: 4367 * true if escapes via assignment to global or through a parameter 4368 */ 4369 bool parameterEscapes(Type tthis, Parameter p) 4370 { 4371 /* Scope parameters do not escape. 4372 * Allow 'lazy' to imply 'scope' - 4373 * lazy parameters can be passed along 4374 * as lazy parameters to the next function, but that isn't 4375 * escaping. 4376 */ 4377 if (parameterStorageClass(tthis, p) & (STC.scope_ | STC.lazy_)) 4378 return false; 4379 return true; 4380 } 4381 4382 /************************************ 4383 * Take the specified storage class for p, 4384 * and use the function signature to infer whether 4385 * STC.scope_ and STC.return_ should be OR'd in. 4386 * (This will not affect the name mangling.) 4387 * Params: 4388 * tthis = type of `this` parameter, null if none 4389 * p = parameter to this function 4390 * Returns: 4391 * storage class with STC.scope_ or STC.return_ OR'd in 4392 */ 4393 StorageClass parameterStorageClass(Type tthis, Parameter p) 4394 { 4395 //printf("parameterStorageClass(p: %s)\n", p.toChars()); 4396 auto stc = p.storageClass; 4397 if (!global.params.vsafe) 4398 return stc; 4399 4400 if (stc & (STC.scope_ | STC.return_ | STC.lazy_) || purity == PURE.impure) 4401 return stc; 4402 4403 /* If haven't inferred the return type yet, can't infer storage classes 4404 */ 4405 if (!nextOf()) 4406 return stc; 4407 4408 purityLevel(); 4409 4410 // See if p can escape via any of the other parameters 4411 if (purity == PURE.weak) 4412 { 4413 // Check escaping through parameters 4414 const dim = parameterList.length; 4415 foreach (const i; 0 .. dim) 4416 { 4417 Parameter fparam = parameterList[i]; 4418 if (fparam == p) 4419 continue; 4420 Type t = fparam.type; 4421 if (!t) 4422 continue; 4423 t = t.baseElemOf(); 4424 if (t.isMutable() && t.hasPointers()) 4425 { 4426 if (fparam.storageClass & (STC.ref_ | STC.out_)) 4427 { 4428 } 4429 else if (t.ty == Tarray || t.ty == Tpointer) 4430 { 4431 Type tn = t.nextOf().toBasetype(); 4432 if (!(tn.isMutable() && tn.hasPointers())) 4433 continue; 4434 } 4435 return stc; 4436 } 4437 } 4438 4439 // Check escaping through `this` 4440 if (tthis && tthis.isMutable()) 4441 { 4442 auto tb = tthis.toBasetype(); 4443 AggregateDeclaration ad; 4444 if (auto tc = tb.isTypeClass()) 4445 ad = tc.sym; 4446 else if (auto ts = tb.isTypeStruct()) 4447 ad = ts.sym; 4448 else 4449 assert(0); 4450 foreach (VarDeclaration v; ad.fields) 4451 { 4452 if (v.hasPointers()) 4453 return stc; 4454 } 4455 } 4456 } 4457 4458 stc |= STC.scope_; 4459 4460 /* Inferring STC.return_ here has false positives 4461 * for pure functions, producing spurious error messages 4462 * about escaping references. 4463 * Give up on it for now. 4464 */ 4465 version (none) 4466 { 4467 Type tret = nextOf().toBasetype(); 4468 if (isref || tret.hasPointers()) 4469 { 4470 /* The result has references, so p could be escaping 4471 * that way. 4472 */ 4473 stc |= STC.return_; 4474 } 4475 } 4476 4477 return stc; 4478 } 4479 4480 override Type addStorageClass(StorageClass stc) 4481 { 4482 //printf("addStorageClass(%llx) %d\n", stc, (stc & STC.scope_) != 0); 4483 TypeFunction t = Type.addStorageClass(stc).toTypeFunction(); 4484 if ((stc & STC.pure_ && !t.purity) || 4485 (stc & STC.nothrow_ && !t.isnothrow) || 4486 (stc & STC.nogc && !t.isnogc) || 4487 (stc & STC.scope_ && !t.isscope) || 4488 (stc & STC.safe && t.trust < TRUST.trusted)) 4489 { 4490 // Klunky to change these 4491 auto tf = new TypeFunction(t.parameterList, t.next, t.linkage, 0); 4492 tf.mod = t.mod; 4493 tf.fargs = fargs; 4494 tf.purity = t.purity; 4495 tf.isnothrow = t.isnothrow; 4496 tf.isnogc = t.isnogc; 4497 tf.isproperty = t.isproperty; 4498 tf.isref = t.isref; 4499 tf.isreturn = t.isreturn; 4500 tf.isscope = t.isscope; 4501 tf.isreturninferred = t.isreturninferred; 4502 tf.isscopeinferred = t.isscopeinferred; 4503 tf.trust = t.trust; 4504 tf.iswild = t.iswild; 4505 4506 if (stc & STC.pure_) 4507 tf.purity = PURE.fwdref; 4508 if (stc & STC.nothrow_) 4509 tf.isnothrow = true; 4510 if (stc & STC.nogc) 4511 tf.isnogc = true; 4512 if (stc & STC.safe) 4513 tf.trust = TRUST.safe; 4514 if (stc & STC.scope_) 4515 { 4516 tf.isscope = true; 4517 if (stc & STC.scopeinferred) 4518 tf.isscopeinferred = true; 4519 } 4520 4521 tf.deco = tf.merge().deco; 4522 t = tf; 4523 } 4524 return t; 4525 } 4526 4527 override Type substWildTo(uint) 4528 { 4529 if (!iswild && !(mod & MODFlags.wild)) 4530 return this; 4531 4532 // Substitude inout qualifier of function type to mutable or immutable 4533 // would break type system. Instead substitude inout to the most weak 4534 // qualifer - const. 4535 uint m = MODFlags.const_; 4536 4537 assert(next); 4538 Type tret = next.substWildTo(m); 4539 Parameters* params = parameterList.parameters; 4540 if (mod & MODFlags.wild) 4541 params = parameterList.parameters.copy(); 4542 for (size_t i = 0; i < params.dim; i++) 4543 { 4544 Parameter p = (*params)[i]; 4545 Type t = p.type.substWildTo(m); 4546 if (t == p.type) 4547 continue; 4548 if (params == parameterList.parameters) 4549 params = parameterList.parameters.copy(); 4550 (*params)[i] = new Parameter(p.storageClass, t, null, null, null); 4551 } 4552 if (next == tret && params == parameterList.parameters) 4553 return this; 4554 4555 // Similar to TypeFunction::syntaxCopy; 4556 auto t = new TypeFunction(ParameterList(params, parameterList.varargs), tret, linkage); 4557 t.mod = ((mod & MODFlags.wild) ? (mod & ~MODFlags.wild) | MODFlags.const_ : mod); 4558 t.isnothrow = isnothrow; 4559 t.isnogc = isnogc; 4560 t.purity = purity; 4561 t.isproperty = isproperty; 4562 t.isref = isref; 4563 t.isreturn = isreturn; 4564 t.isscope = isscope; 4565 t.isreturninferred = isreturninferred; 4566 t.isscopeinferred = isscopeinferred; 4567 t.iswild = 0; 4568 t.trust = trust; 4569 t.fargs = fargs; 4570 return t.merge(); 4571 } 4572 4573 // arguments get specially formatted 4574 private const(char)* getParamError(Expression arg, Parameter par) 4575 { 4576 if (global.gag && !global.params.showGaggedErrors) 4577 return null; 4578 // show qualification when toChars() is the same but types are different 4579 auto at = arg.type.toChars(); 4580 bool qual = !arg.type.equals(par.type) && strcmp(at, par.type.toChars()) == 0; 4581 if (qual) 4582 at = arg.type.toPrettyChars(true); 4583 OutBuffer buf; 4584 // only mention rvalue if it's relevant 4585 const rv = !arg.isLvalue() && par.storageClass & (STC.ref_ | STC.out_); 4586 buf.printf("cannot pass %sargument `%s` of type `%s` to parameter `%s`", 4587 rv ? "rvalue ".ptr : "".ptr, arg.toChars(), at, 4588 parameterToChars(par, this, qual)); 4589 return buf.extractChars(); 4590 } 4591 4592 private extern(D) const(char)* getMatchError(A...)(const(char)* format, A args) 4593 { 4594 if (global.gag && !global.params.showGaggedErrors) 4595 return null; 4596 OutBuffer buf; 4597 buf.printf(format, args); 4598 return buf.extractChars(); 4599 } 4600 4601 /******************************** 4602 * 'args' are being matched to function 'this' 4603 * Determine match level. 4604 * Params: 4605 * tthis = type of `this` pointer, null if not member function 4606 * args = array of function arguments 4607 * flag = 1: performing a partial ordering match 4608 * pMessage = address to store error message, or null 4609 * sc = context 4610 * Returns: 4611 * MATCHxxxx 4612 */ 4613 extern (D) MATCH callMatch(Type tthis, Expression[] args, int flag = 0, const(char)** pMessage = null, Scope* sc = null) 4614 { 4615 //printf("TypeFunction::callMatch() %s\n", toChars()); 4616 MATCH match = MATCH.exact; // assume exact match 4617 ubyte wildmatch = 0; 4618 4619 if (tthis) 4620 { 4621 Type t = tthis; 4622 if (t.toBasetype().ty == Tpointer) 4623 t = t.toBasetype().nextOf(); // change struct* to struct 4624 if (t.mod != mod) 4625 { 4626 if (MODimplicitConv(t.mod, mod)) 4627 match = MATCH.constant; 4628 else if ((mod & MODFlags.wild) && MODimplicitConv(t.mod, (mod & ~MODFlags.wild) | MODFlags.const_)) 4629 { 4630 match = MATCH.constant; 4631 } 4632 else 4633 return MATCH.nomatch; 4634 } 4635 if (isWild()) 4636 { 4637 if (t.isWild()) 4638 wildmatch |= MODFlags.wild; 4639 else if (t.isConst()) 4640 wildmatch |= MODFlags.const_; 4641 else if (t.isImmutable()) 4642 wildmatch |= MODFlags.immutable_; 4643 else 4644 wildmatch |= MODFlags.mutable; 4645 } 4646 } 4647 4648 size_t nparams = parameterList.length; 4649 size_t nargs = args.length; 4650 if (nargs > nparams) 4651 { 4652 if (parameterList.varargs == VarArg.none) 4653 { 4654 // suppress early exit if an error message is wanted, 4655 // so we can check any matching args are valid 4656 if (!pMessage) 4657 goto Nomatch; 4658 } 4659 // too many args; no match 4660 match = MATCH.convert; // match ... with a "conversion" match level 4661 } 4662 4663 for (size_t u = 0; u < nargs; u++) 4664 { 4665 if (u >= nparams) 4666 break; 4667 Parameter p = parameterList[u]; 4668 Expression arg = args[u]; 4669 assert(arg); 4670 Type tprm = p.type; 4671 Type targ = arg.type; 4672 4673 if (!(p.storageClass & STC.lazy_ && tprm.ty == Tvoid && targ.ty != Tvoid)) 4674 { 4675 bool isRef = (p.storageClass & (STC.ref_ | STC.out_)) != 0; 4676 wildmatch |= targ.deduceWild(tprm, isRef); 4677 } 4678 } 4679 if (wildmatch) 4680 { 4681 /* Calculate wild matching modifier 4682 */ 4683 if (wildmatch & MODFlags.const_ || wildmatch & (wildmatch - 1)) 4684 wildmatch = MODFlags.const_; 4685 else if (wildmatch & MODFlags.immutable_) 4686 wildmatch = MODFlags.immutable_; 4687 else if (wildmatch & MODFlags.wild) 4688 wildmatch = MODFlags.wild; 4689 else 4690 { 4691 assert(wildmatch & MODFlags.mutable); 4692 wildmatch = MODFlags.mutable; 4693 } 4694 } 4695 4696 for (size_t u = 0; u < nparams; u++) 4697 { 4698 MATCH m; 4699 4700 Parameter p = parameterList[u]; 4701 assert(p); 4702 if (u >= nargs) 4703 { 4704 if (p.defaultArg) 4705 continue; 4706 // try typesafe variadics 4707 goto L1; 4708 } 4709 { 4710 Expression arg = args[u]; 4711 assert(arg); 4712 //printf("arg: %s, type: %s\n", arg.toChars(), arg.type.toChars()); 4713 4714 Type targ = arg.type; 4715 Type tprm = wildmatch ? p.type.substWildTo(wildmatch) : p.type; 4716 4717 if (p.storageClass & STC.lazy_ && tprm.ty == Tvoid && targ.ty != Tvoid) 4718 m = MATCH.convert; 4719 else 4720 { 4721 //printf("%s of type %s implicitConvTo %s\n", arg.toChars(), targ.toChars(), tprm.toChars()); 4722 if (flag) 4723 { 4724 // for partial ordering, value is an irrelevant mockup, just look at the type 4725 m = targ.implicitConvTo(tprm); 4726 } 4727 else 4728 { 4729 const isRef = (p.storageClass & (STC.ref_ | STC.out_)) != 0; 4730 4731 StructDeclaration argStruct, prmStruct; 4732 4733 // first look for a copy constructor 4734 if (arg.isLvalue() && !isRef && targ.ty == Tstruct && tprm.ty == Tstruct) 4735 { 4736 // if the argument and the parameter are of the same unqualified struct type 4737 argStruct = (cast(TypeStruct)targ).sym; 4738 prmStruct = (cast(TypeStruct)tprm).sym; 4739 } 4740 4741 // check if the copy constructor may be called to copy the argument 4742 if (argStruct && argStruct == prmStruct && argStruct.hasCopyCtor) 4743 { 4744 /* this is done by seeing if a call to the copy constructor can be made: 4745 * 4746 * typeof(tprm) __copytmp; 4747 * copytmp.__copyCtor(arg); 4748 */ 4749 auto tmp = new VarDeclaration(arg.loc, tprm, Identifier.generateId("__copytmp"), null); 4750 tmp.storage_class = STC.rvalue | STC.temp | STC.ctfe; 4751 tmp.dsymbolSemantic(sc); 4752 Expression ve = new VarExp(arg.loc, tmp); 4753 Expression e = new DotIdExp(arg.loc, ve, Id.ctor); 4754 e = new CallExp(arg.loc, e, arg); 4755 //printf("e = %s\n", e.toChars()); 4756 if(.trySemantic(e, sc)) 4757 m = MATCH.exact; 4758 else 4759 { 4760 m = MATCH.nomatch; 4761 if (pMessage) 4762 { 4763 OutBuffer buf; 4764 buf.printf("`struct %s` does not define a copy constructor for `%s` to `%s` copies", 4765 argStruct.toChars(), targ.toChars(), tprm.toChars()); 4766 *pMessage = buf.extractChars(); 4767 } 4768 goto Nomatch; 4769 } 4770 } 4771 else 4772 m = arg.implicitConvTo(tprm); 4773 } 4774 //printf("match %d\n", m); 4775 } 4776 4777 // Non-lvalues do not match ref or out parameters 4778 if (p.storageClass & (STC.ref_ | STC.out_)) 4779 { 4780 // https://issues.dlang.org/show_bug.cgi?id=13783 4781 // Don't use toBasetype() to handle enum types. 4782 Type ta = targ; 4783 Type tp = tprm; 4784 //printf("fparam[%d] ta = %s, tp = %s\n", u, ta.toChars(), tp.toChars()); 4785 4786 if (m && !arg.isLvalue()) 4787 { 4788 if (p.storageClass & STC.out_) 4789 { 4790 if (pMessage) *pMessage = getParamError(arg, p); 4791 goto Nomatch; 4792 } 4793 4794 if (arg.op == TOK.string_ && tp.ty == Tsarray) 4795 { 4796 if (ta.ty != Tsarray) 4797 { 4798 Type tn = tp.nextOf().castMod(ta.nextOf().mod); 4799 dinteger_t dim = (cast(StringExp)arg).len; 4800 ta = tn.sarrayOf(dim); 4801 } 4802 } 4803 else if (arg.op == TOK.slice && tp.ty == Tsarray) 4804 { 4805 // Allow conversion from T[lwr .. upr] to ref T[upr-lwr] 4806 if (ta.ty != Tsarray) 4807 { 4808 Type tn = ta.nextOf(); 4809 dinteger_t dim = (cast(TypeSArray)tp).dim.toUInteger(); 4810 ta = tn.sarrayOf(dim); 4811 } 4812 } 4813 else if (!global.params.rvalueRefParam || 4814 p.storageClass & STC.out_ || 4815 !arg.type.isCopyable()) // can't copy to temp for ref parameter 4816 { 4817 if (pMessage) *pMessage = getParamError(arg, p); 4818 goto Nomatch; 4819 } 4820 else 4821 { 4822 /* in functionParameters() we'll convert this 4823 * rvalue into a temporary 4824 */ 4825 m = MATCH.convert; 4826 } 4827 } 4828 4829 /* Find most derived alias this type being matched. 4830 * https://issues.dlang.org/show_bug.cgi?id=15674 4831 * Allow on both ref and out parameters. 4832 */ 4833 while (1) 4834 { 4835 Type tab = ta.toBasetype(); 4836 Type tat = tab.aliasthisOf(); 4837 if (!tat || !tat.implicitConvTo(tprm)) 4838 break; 4839 if (tat == tab) 4840 break; 4841 ta = tat; 4842 } 4843 4844 /* A ref variable should work like a head-const reference. 4845 * e.g. disallows: 4846 * ref T <- an lvalue of const(T) argument 4847 * ref T[dim] <- an lvalue of const(T[dim]) argument 4848 */ 4849 if (!ta.constConv(tp)) 4850 { 4851 if (pMessage) *pMessage = getParamError(arg, p); 4852 goto Nomatch; 4853 } 4854 } 4855 } 4856 4857 /* prefer matching the element type rather than the array 4858 * type when more arguments are present with T[]... 4859 */ 4860 if (parameterList.varargs == VarArg.typesafe && u + 1 == nparams && nargs > nparams) 4861 goto L1; 4862 4863 //printf("\tm = %d\n", m); 4864 if (m == MATCH.nomatch) // if no match 4865 { 4866 L1: 4867 if (parameterList.varargs == VarArg.typesafe && u + 1 == nparams) // if last varargs param 4868 { 4869 Type tb = p.type.toBasetype(); 4870 TypeSArray tsa; 4871 dinteger_t sz; 4872 4873 switch (tb.ty) 4874 { 4875 case Tsarray: 4876 tsa = cast(TypeSArray)tb; 4877 sz = tsa.dim.toInteger(); 4878 if (sz != nargs - u) 4879 { 4880 if (pMessage) 4881 // Windows (Vista) OutBuffer.vprintf issue? 2nd argument always zero 4882 //*pMessage = getMatchError("expected %d variadic argument(s), not %d", sz, nargs - u); 4883 if (!global.gag || global.params.showGaggedErrors) 4884 { 4885 OutBuffer buf; 4886 buf.printf("expected %d variadic argument(s)", sz); 4887 buf.printf(", not %d", nargs - u); 4888 *pMessage = buf.extractChars(); 4889 } 4890 goto Nomatch; 4891 } 4892 goto case Tarray; 4893 case Tarray: 4894 { 4895 TypeArray ta = cast(TypeArray)tb; 4896 foreach (arg; args[u .. nargs]) 4897 { 4898 assert(arg); 4899 4900 /* If lazy array of delegates, 4901 * convert arg(s) to delegate(s) 4902 */ 4903 Type tret = p.isLazyArray(); 4904 if (tret) 4905 { 4906 if (ta.next.equals(arg.type)) 4907 m = MATCH.exact; 4908 else if (tret.toBasetype().ty == Tvoid) 4909 m = MATCH.convert; 4910 else 4911 { 4912 m = arg.implicitConvTo(tret); 4913 if (m == MATCH.nomatch) 4914 m = arg.implicitConvTo(ta.next); 4915 } 4916 } 4917 else 4918 m = arg.implicitConvTo(ta.next); 4919 4920 if (m == MATCH.nomatch) 4921 { 4922 if (pMessage) *pMessage = getParamError(arg, p); 4923 goto Nomatch; 4924 } 4925 if (m < match) 4926 match = m; 4927 } 4928 goto Ldone; 4929 } 4930 case Tclass: 4931 // Should see if there's a constructor match? 4932 // Or just leave it ambiguous? 4933 goto Ldone; 4934 4935 default: 4936 break; 4937 } 4938 } 4939 if (pMessage && u < nargs) 4940 *pMessage = getParamError(args[u], p); 4941 else if (pMessage) 4942 *pMessage = getMatchError("missing argument for parameter #%d: `%s`", 4943 u + 1, parameterToChars(p, this, false)); 4944 goto Nomatch; 4945 } 4946 if (m < match) 4947 match = m; // pick worst match 4948 } 4949 4950 Ldone: 4951 if (pMessage && !parameterList.varargs && nargs > nparams) 4952 { 4953 // all parameters had a match, but there are surplus args 4954 *pMessage = getMatchError("expected %d argument(s), not %d", nparams, nargs); 4955 goto Nomatch; 4956 } 4957 //printf("match = %d\n", match); 4958 return match; 4959 4960 Nomatch: 4961 //printf("no match\n"); 4962 return MATCH.nomatch; 4963 } 4964 4965 extern (D) bool checkRetType(const ref Loc loc) 4966 { 4967 Type tb = next.toBasetype(); 4968 if (tb.ty == Tfunction) 4969 { 4970 error(loc, "functions cannot return a function"); 4971 next = Type.terror; 4972 } 4973 if (tb.ty == Ttuple) 4974 { 4975 error(loc, "functions cannot return a tuple"); 4976 next = Type.terror; 4977 } 4978 if (!isref && (tb.ty == Tstruct || tb.ty == Tsarray)) 4979 { 4980 if (auto ts = tb.baseElemOf().isTypeStruct()) 4981 { 4982 if (!ts.sym.members) 4983 { 4984 error(loc, "functions cannot return opaque type `%s` by value", tb.toChars()); 4985 next = Type.terror; 4986 } 4987 } 4988 } 4989 if (tb.ty == Terror) 4990 return true; 4991 return false; 4992 } 4993 4994 override void accept(Visitor v) 4995 { 4996 v.visit(this); 4997 } 4998 } 4999 5000 /*********************************************************** 5001 */ 5002 extern (C++) final class TypeDelegate : TypeNext 5003 { 5004 // .next is a TypeFunction 5005 5006 extern (D) this(Type t) 5007 { 5008 super(Tfunction, t); 5009 ty = Tdelegate; 5010 } 5011 5012 static TypeDelegate create(Type t) 5013 { 5014 return new TypeDelegate(t); 5015 } 5016 5017 override const(char)* kind() const 5018 { 5019 return "delegate"; 5020 } 5021 5022 override Type syntaxCopy() 5023 { 5024 Type t = next.syntaxCopy(); 5025 if (t == next) 5026 t = this; 5027 else 5028 { 5029 t = new TypeDelegate(t); 5030 t.mod = mod; 5031 } 5032 return t; 5033 } 5034 5035 override Type addStorageClass(StorageClass stc) 5036 { 5037 TypeDelegate t = cast(TypeDelegate)Type.addStorageClass(stc); 5038 if (!global.params.vsafe) 5039 return t; 5040 5041 /* The rest is meant to add 'scope' to a delegate declaration if it is of the form: 5042 * alias dg_t = void* delegate(); 5043 * scope dg_t dg = ...; 5044 */ 5045 if(stc & STC.scope_) 5046 { 5047 auto n = t.next.addStorageClass(STC.scope_ | STC.scopeinferred); 5048 if (n != t.next) 5049 { 5050 t.next = n; 5051 t.deco = t.merge().deco; // mangling supposed to not be changed due to STC.scope_inferrred 5052 } 5053 } 5054 return t; 5055 } 5056 5057 override d_uns64 size(const ref Loc loc) const 5058 { 5059 return target.ptrsize * 2; 5060 } 5061 5062 override uint alignsize() const 5063 { 5064 return target.ptrsize; 5065 } 5066 5067 override MATCH implicitConvTo(Type to) 5068 { 5069 //printf("TypeDelegate.implicitConvTo(this=%p, to=%p)\n", this, to); 5070 //printf("from: %s\n", toChars()); 5071 //printf("to : %s\n", to.toChars()); 5072 if (this == to) 5073 return MATCH.exact; 5074 5075 version (all) 5076 { 5077 // not allowing covariant conversions because it interferes with overriding 5078 if (to.ty == Tdelegate && this.nextOf().covariant(to.nextOf()) == 1) 5079 { 5080 Type tret = this.next.nextOf(); 5081 Type toret = (cast(TypeDelegate)to).next.nextOf(); 5082 if (tret.ty == Tclass && toret.ty == Tclass) 5083 { 5084 /* https://issues.dlang.org/show_bug.cgi?id=10219 5085 * Check covariant interface return with offset tweaking. 5086 * interface I {} 5087 * class C : Object, I {} 5088 * I delegate() dg = delegate C() {} // should be error 5089 */ 5090 int offset = 0; 5091 if (toret.isBaseOf(tret, &offset) && offset != 0) 5092 return MATCH.nomatch; 5093 } 5094 return MATCH.convert; 5095 } 5096 } 5097 5098 return MATCH.nomatch; 5099 } 5100 5101 override bool isZeroInit(const ref Loc loc) const 5102 { 5103 return true; 5104 } 5105 5106 override bool isBoolean() const 5107 { 5108 return true; 5109 } 5110 5111 override bool hasPointers() const 5112 { 5113 return true; 5114 } 5115 5116 override void accept(Visitor v) 5117 { 5118 v.visit(this); 5119 } 5120 } 5121 5122 /** 5123 * This is a shell containing a TraitsExp that can be 5124 * either resolved to a type or to a symbol. 5125 * 5126 * The point is to allow AliasDeclarationY to use `__traits()`, see issue 7804. 5127 */ 5128 extern (C++) final class TypeTraits : Type 5129 { 5130 Loc loc; 5131 /// The expression to resolve as type or symbol. 5132 TraitsExp exp; 5133 /// After `typeSemantic` the symbol when `exp` doesn't represent a type. 5134 Dsymbol sym; 5135 5136 final extern (D) this(const ref Loc loc, TraitsExp exp) 5137 { 5138 super(Ttraits); 5139 this.loc = loc; 5140 this.exp = exp; 5141 } 5142 5143 override Type syntaxCopy() 5144 { 5145 TraitsExp te = cast(TraitsExp) exp.syntaxCopy(); 5146 TypeTraits tt = new TypeTraits(loc, te); 5147 tt.mod = mod; 5148 return tt; 5149 } 5150 5151 override Dsymbol toDsymbol(Scope* sc) 5152 { 5153 Type t; 5154 Expression e; 5155 Dsymbol s; 5156 resolve(this, loc, sc, &e, &t, &s); 5157 if (t && t.ty != Terror) 5158 s = t.toDsymbol(sc); 5159 else if (e) 5160 s = getDsymbol(e); 5161 5162 return s; 5163 } 5164 5165 override void accept(Visitor v) 5166 { 5167 v.visit(this); 5168 } 5169 5170 override d_uns64 size(const ref Loc loc) 5171 { 5172 return SIZE_INVALID; 5173 } 5174 } 5175 5176 /****** 5177 * Implements mixin types. 5178 * 5179 * Semantic analysis will convert it to a real type. 5180 */ 5181 extern (C++) final class TypeMixin : Type 5182 { 5183 Loc loc; 5184 Expressions* exps; 5185 5186 extern (D) this(const ref Loc loc, Expressions* exps) 5187 { 5188 super(Tmixin); 5189 this.loc = loc; 5190 this.exps = exps; 5191 } 5192 5193 override const(char)* kind() const 5194 { 5195 return "mixin"; 5196 } 5197 5198 override Type syntaxCopy() 5199 { 5200 return new TypeMixin(loc, Expression.arraySyntaxCopy(exps)); 5201 } 5202 5203 override Dsymbol toDsymbol(Scope* sc) 5204 { 5205 Type t; 5206 Expression e; 5207 Dsymbol s; 5208 resolve(this, loc, sc, &e, &t, &s); 5209 if (t) 5210 s = t.toDsymbol(sc); 5211 else if (e) 5212 s = getDsymbol(e); 5213 5214 return s; 5215 } 5216 5217 override void accept(Visitor v) 5218 { 5219 v.visit(this); 5220 } 5221 } 5222 5223 /*********************************************************** 5224 */ 5225 extern (C++) abstract class TypeQualified : Type 5226 { 5227 Loc loc; 5228 5229 // array of Identifier and TypeInstance, 5230 // representing ident.ident!tiargs.ident. ... etc. 5231 Objects idents; 5232 5233 final extern (D) this(TY ty, Loc loc) 5234 { 5235 super(ty); 5236 this.loc = loc; 5237 } 5238 5239 final void syntaxCopyHelper(TypeQualified t) 5240 { 5241 //printf("TypeQualified::syntaxCopyHelper(%s) %s\n", t.toChars(), toChars()); 5242 idents.setDim(t.idents.dim); 5243 for (size_t i = 0; i < idents.dim; i++) 5244 { 5245 RootObject id = t.idents[i]; 5246 if (id.dyncast() == DYNCAST.dsymbol) 5247 { 5248 TemplateInstance ti = cast(TemplateInstance)id; 5249 ti = cast(TemplateInstance)ti.syntaxCopy(null); 5250 id = ti; 5251 } 5252 else if (id.dyncast() == DYNCAST.expression) 5253 { 5254 Expression e = cast(Expression)id; 5255 e = e.syntaxCopy(); 5256 id = e; 5257 } 5258 else if (id.dyncast() == DYNCAST.type) 5259 { 5260 Type tx = cast(Type)id; 5261 tx = tx.syntaxCopy(); 5262 id = tx; 5263 } 5264 idents[i] = id; 5265 } 5266 } 5267 5268 final void addIdent(Identifier ident) 5269 { 5270 idents.push(ident); 5271 } 5272 5273 final void addInst(TemplateInstance inst) 5274 { 5275 idents.push(inst); 5276 } 5277 5278 final void addIndex(RootObject e) 5279 { 5280 idents.push(e); 5281 } 5282 5283 override d_uns64 size(const ref Loc loc) 5284 { 5285 error(this.loc, "size of type `%s` is not known", toChars()); 5286 return SIZE_INVALID; 5287 } 5288 5289 override void accept(Visitor v) 5290 { 5291 v.visit(this); 5292 } 5293 } 5294 5295 /*********************************************************** 5296 */ 5297 extern (C++) final class TypeIdentifier : TypeQualified 5298 { 5299 Identifier ident; 5300 5301 // The symbol representing this identifier, before alias resolution 5302 Dsymbol originalSymbol; 5303 5304 extern (D) this(const ref Loc loc, Identifier ident) 5305 { 5306 super(Tident, loc); 5307 this.ident = ident; 5308 } 5309 5310 override const(char)* kind() const 5311 { 5312 return "identifier"; 5313 } 5314 5315 override Type syntaxCopy() 5316 { 5317 auto t = new TypeIdentifier(loc, ident); 5318 t.syntaxCopyHelper(this); 5319 t.mod = mod; 5320 return t; 5321 } 5322 5323 /***************************************** 5324 * See if type resolves to a symbol, if so, 5325 * return that symbol. 5326 */ 5327 override Dsymbol toDsymbol(Scope* sc) 5328 { 5329 //printf("TypeIdentifier::toDsymbol('%s')\n", toChars()); 5330 if (!sc) 5331 return null; 5332 5333 Type t; 5334 Expression e; 5335 Dsymbol s; 5336 resolve(this, loc, sc, &e, &t, &s); 5337 if (t && t.ty != Tident) 5338 s = t.toDsymbol(sc); 5339 if (e) 5340 s = getDsymbol(e); 5341 5342 return s; 5343 } 5344 5345 override void accept(Visitor v) 5346 { 5347 v.visit(this); 5348 } 5349 } 5350 5351 /*********************************************************** 5352 * Similar to TypeIdentifier, but with a TemplateInstance as the root 5353 */ 5354 extern (C++) final class TypeInstance : TypeQualified 5355 { 5356 TemplateInstance tempinst; 5357 5358 extern (D) this(const ref Loc loc, TemplateInstance tempinst) 5359 { 5360 super(Tinstance, loc); 5361 this.tempinst = tempinst; 5362 } 5363 5364 override const(char)* kind() const 5365 { 5366 return "instance"; 5367 } 5368 5369 override Type syntaxCopy() 5370 { 5371 //printf("TypeInstance::syntaxCopy() %s, %d\n", toChars(), idents.dim); 5372 auto t = new TypeInstance(loc, cast(TemplateInstance)tempinst.syntaxCopy(null)); 5373 t.syntaxCopyHelper(this); 5374 t.mod = mod; 5375 return t; 5376 } 5377 5378 override Dsymbol toDsymbol(Scope* sc) 5379 { 5380 Type t; 5381 Expression e; 5382 Dsymbol s; 5383 //printf("TypeInstance::semantic(%s)\n", toChars()); 5384 resolve(this, loc, sc, &e, &t, &s); 5385 if (t && t.ty != Tinstance) 5386 s = t.toDsymbol(sc); 5387 return s; 5388 } 5389 5390 override void accept(Visitor v) 5391 { 5392 v.visit(this); 5393 } 5394 } 5395 5396 /*********************************************************** 5397 */ 5398 extern (C++) final class TypeTypeof : TypeQualified 5399 { 5400 Expression exp; 5401 int inuse; 5402 5403 extern (D) this(const ref Loc loc, Expression exp) 5404 { 5405 super(Ttypeof, loc); 5406 this.exp = exp; 5407 } 5408 5409 override const(char)* kind() const 5410 { 5411 return "typeof"; 5412 } 5413 5414 override Type syntaxCopy() 5415 { 5416 //printf("TypeTypeof::syntaxCopy() %s\n", toChars()); 5417 auto t = new TypeTypeof(loc, exp.syntaxCopy()); 5418 t.syntaxCopyHelper(this); 5419 t.mod = mod; 5420 return t; 5421 } 5422 5423 override Dsymbol toDsymbol(Scope* sc) 5424 { 5425 //printf("TypeTypeof::toDsymbol('%s')\n", toChars()); 5426 Expression e; 5427 Type t; 5428 Dsymbol s; 5429 resolve(this, loc, sc, &e, &t, &s); 5430 return s; 5431 } 5432 5433 override d_uns64 size(const ref Loc loc) 5434 { 5435 if (exp.type) 5436 return exp.type.size(loc); 5437 else 5438 return TypeQualified.size(loc); 5439 } 5440 5441 override void accept(Visitor v) 5442 { 5443 v.visit(this); 5444 } 5445 } 5446 5447 /*********************************************************** 5448 */ 5449 extern (C++) final class TypeReturn : TypeQualified 5450 { 5451 extern (D) this(const ref Loc loc) 5452 { 5453 super(Treturn, loc); 5454 } 5455 5456 override const(char)* kind() const 5457 { 5458 return "return"; 5459 } 5460 5461 override Type syntaxCopy() 5462 { 5463 auto t = new TypeReturn(loc); 5464 t.syntaxCopyHelper(this); 5465 t.mod = mod; 5466 return t; 5467 } 5468 5469 override Dsymbol toDsymbol(Scope* sc) 5470 { 5471 Expression e; 5472 Type t; 5473 Dsymbol s; 5474 resolve(this, loc, sc, &e, &t, &s); 5475 return s; 5476 } 5477 5478 override void accept(Visitor v) 5479 { 5480 v.visit(this); 5481 } 5482 } 5483 5484 // Whether alias this dependency is recursive or not. 5485 enum AliasThisRec : int 5486 { 5487 no = 0, // no alias this recursion 5488 yes = 1, // alias this has recursive dependency 5489 fwdref = 2, // not yet known 5490 typeMask = 3, // mask to read no/yes/fwdref 5491 tracing = 0x4, // mark in progress of implicitConvTo/deduceWild 5492 tracingDT = 0x8, // mark in progress of deduceType 5493 } 5494 5495 /*********************************************************** 5496 */ 5497 extern (C++) final class TypeStruct : Type 5498 { 5499 StructDeclaration sym; 5500 AliasThisRec att = AliasThisRec.fwdref; 5501 5502 extern (D) this(StructDeclaration sym) 5503 { 5504 super(Tstruct); 5505 this.sym = sym; 5506 } 5507 5508 static TypeStruct create(StructDeclaration sym) 5509 { 5510 return new TypeStruct(sym); 5511 } 5512 5513 override const(char)* kind() const 5514 { 5515 return "struct"; 5516 } 5517 5518 override d_uns64 size(const ref Loc loc) 5519 { 5520 return sym.size(loc); 5521 } 5522 5523 override uint alignsize() 5524 { 5525 sym.size(Loc.initial); // give error for forward references 5526 return sym.alignsize; 5527 } 5528 5529 override Type syntaxCopy() 5530 { 5531 return this; 5532 } 5533 5534 override Dsymbol toDsymbol(Scope* sc) 5535 { 5536 return sym; 5537 } 5538 5539 override structalign_t alignment() 5540 { 5541 if (sym.alignment == 0) 5542 sym.size(sym.loc); 5543 return sym.alignment; 5544 } 5545 5546 /*************************************** 5547 * Use when we prefer the default initializer to be a literal, 5548 * rather than a global immutable variable. 5549 */ 5550 override Expression defaultInitLiteral(const ref Loc loc) 5551 { 5552 static if (LOGDEFAULTINIT) 5553 { 5554 printf("TypeStruct::defaultInitLiteral() '%s'\n", toChars()); 5555 } 5556 sym.size(loc); 5557 if (sym.sizeok != Sizeok.done) 5558 return new ErrorExp(); 5559 5560 auto structelems = new Expressions(sym.nonHiddenFields()); 5561 uint offset = 0; 5562 foreach (j; 0 .. structelems.dim) 5563 { 5564 VarDeclaration vd = sym.fields[j]; 5565 Expression e; 5566 if (vd.inuse) 5567 { 5568 error(loc, "circular reference to `%s`", vd.toPrettyChars()); 5569 return new ErrorExp(); 5570 } 5571 if (vd.offset < offset || vd.type.size() == 0) 5572 e = null; 5573 else if (vd._init) 5574 { 5575 if (vd._init.isVoidInitializer()) 5576 e = null; 5577 else 5578 e = vd.getConstInitializer(false); 5579 } 5580 else 5581 e = vd.type.defaultInitLiteral(loc); 5582 if (e && e.op == TOK.error) 5583 return e; 5584 if (e) 5585 offset = vd.offset + cast(uint)vd.type.size(); 5586 (*structelems)[j] = e; 5587 } 5588 auto structinit = new StructLiteralExp(loc, sym, structelems); 5589 5590 /* Copy from the initializer symbol for larger symbols, 5591 * otherwise the literals expressed as code get excessively large. 5592 */ 5593 if (size(loc) > target.ptrsize * 4 && !needsNested()) 5594 structinit.useStaticInit = true; 5595 5596 structinit.type = this; 5597 return structinit; 5598 } 5599 5600 override bool isZeroInit(const ref Loc loc) 5601 { 5602 // Determine zeroInit here, as this can be called before semantic2 5603 sym.determineSize(sym.loc); 5604 return sym.zeroInit; 5605 } 5606 5607 override bool isAssignable() 5608 { 5609 bool assignable = true; 5610 uint offset = ~0; // dead-store initialize to prevent spurious warning 5611 5612 sym.determineSize(sym.loc); 5613 5614 /* If any of the fields are const or immutable, 5615 * then one cannot assign this struct. 5616 */ 5617 for (size_t i = 0; i < sym.fields.dim; i++) 5618 { 5619 VarDeclaration v = sym.fields[i]; 5620 //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()); 5621 if (i == 0) 5622 { 5623 } 5624 else if (v.offset == offset) 5625 { 5626 /* If any fields of anonymous union are assignable, 5627 * then regard union as assignable. 5628 * This is to support unsafe things like Rebindable templates. 5629 */ 5630 if (assignable) 5631 continue; 5632 } 5633 else 5634 { 5635 if (!assignable) 5636 return false; 5637 } 5638 assignable = v.type.isMutable() && v.type.isAssignable(); 5639 offset = v.offset; 5640 //printf(" -> assignable = %d\n", assignable); 5641 } 5642 5643 return assignable; 5644 } 5645 5646 override bool isBoolean() const 5647 { 5648 return false; 5649 } 5650 5651 override bool needsDestruction() const 5652 { 5653 return sym.dtor !is null; 5654 } 5655 5656 override bool needsCopyOrPostblit() 5657 { 5658 return sym.hasCopyCtor || sym.postblit; 5659 } 5660 5661 override bool needsNested() 5662 { 5663 if (sym.isNested()) 5664 return true; 5665 5666 for (size_t i = 0; i < sym.fields.dim; i++) 5667 { 5668 VarDeclaration v = sym.fields[i]; 5669 if (!v.isDataseg() && v.type.needsNested()) 5670 return true; 5671 } 5672 return false; 5673 } 5674 5675 override bool hasPointers() 5676 { 5677 // Probably should cache this information in sym rather than recompute 5678 StructDeclaration s = sym; 5679 5680 if (sym.members && !sym.determineFields() && sym.type != Type.terror) 5681 error(sym.loc, "no size because of forward references"); 5682 5683 foreach (VarDeclaration v; s.fields) 5684 { 5685 if (v.storage_class & STC.ref_ || v.hasPointers()) 5686 return true; 5687 } 5688 return false; 5689 } 5690 5691 override bool hasVoidInitPointers() 5692 { 5693 // Probably should cache this information in sym rather than recompute 5694 StructDeclaration s = sym; 5695 5696 sym.size(Loc.initial); // give error for forward references 5697 foreach (VarDeclaration v; s.fields) 5698 { 5699 if (v._init && v._init.isVoidInitializer() && v.type.hasPointers()) 5700 return true; 5701 if (!v._init && v.type.hasVoidInitPointers()) 5702 return true; 5703 } 5704 return false; 5705 } 5706 5707 extern (D) MATCH implicitConvToWithoutAliasThis(Type to) 5708 { 5709 MATCH m; 5710 5711 if (ty == to.ty && sym == (cast(TypeStruct)to).sym) 5712 { 5713 m = MATCH.exact; // exact match 5714 if (mod != to.mod) 5715 { 5716 m = MATCH.constant; 5717 if (MODimplicitConv(mod, to.mod)) 5718 { 5719 } 5720 else 5721 { 5722 /* Check all the fields. If they can all be converted, 5723 * allow the conversion. 5724 */ 5725 uint offset = ~0; // dead-store to prevent spurious warning 5726 for (size_t i = 0; i < sym.fields.dim; i++) 5727 { 5728 VarDeclaration v = sym.fields[i]; 5729 if (i == 0) 5730 { 5731 } 5732 else if (v.offset == offset) 5733 { 5734 if (m > MATCH.nomatch) 5735 continue; 5736 } 5737 else 5738 { 5739 if (m <= MATCH.nomatch) 5740 return m; 5741 } 5742 5743 // 'from' type 5744 Type tvf = v.type.addMod(mod); 5745 5746 // 'to' type 5747 Type tv = v.type.addMod(to.mod); 5748 5749 // field match 5750 MATCH mf = tvf.implicitConvTo(tv); 5751 //printf("\t%s => %s, match = %d\n", v.type.toChars(), tv.toChars(), mf); 5752 5753 if (mf <= MATCH.nomatch) 5754 return mf; 5755 if (mf < m) // if field match is worse 5756 m = mf; 5757 offset = v.offset; 5758 } 5759 } 5760 } 5761 } 5762 return m; 5763 } 5764 5765 extern (D) MATCH implicitConvToThroughAliasThis(Type to) 5766 { 5767 MATCH m; 5768 if (!(ty == to.ty && sym == (cast(TypeStruct)to).sym) && sym.aliasthis && !(att & AliasThisRec.tracing)) 5769 { 5770 if (auto ato = aliasthisOf()) 5771 { 5772 att = cast(AliasThisRec)(att | AliasThisRec.tracing); 5773 m = ato.implicitConvTo(to); 5774 att = cast(AliasThisRec)(att & ~AliasThisRec.tracing); 5775 } 5776 else 5777 m = MATCH.nomatch; // no match 5778 } 5779 return m; 5780 } 5781 5782 override MATCH implicitConvTo(Type to) 5783 { 5784 //printf("TypeStruct::implicitConvTo(%s => %s)\n", toChars(), to.toChars()); 5785 MATCH m = implicitConvToWithoutAliasThis(to); 5786 return m ? m : implicitConvToThroughAliasThis(to); 5787 } 5788 5789 override MATCH constConv(Type to) 5790 { 5791 if (equals(to)) 5792 return MATCH.exact; 5793 if (ty == to.ty && sym == (cast(TypeStruct)to).sym && MODimplicitConv(mod, to.mod)) 5794 return MATCH.constant; 5795 return MATCH.nomatch; 5796 } 5797 5798 override MOD deduceWild(Type t, bool isRef) 5799 { 5800 if (ty == t.ty && sym == (cast(TypeStruct)t).sym) 5801 return Type.deduceWild(t, isRef); 5802 5803 ubyte wm = 0; 5804 5805 if (t.hasWild() && sym.aliasthis && !(att & AliasThisRec.tracing)) 5806 { 5807 if (auto ato = aliasthisOf()) 5808 { 5809 att = cast(AliasThisRec)(att | AliasThisRec.tracing); 5810 wm = ato.deduceWild(t, isRef); 5811 att = cast(AliasThisRec)(att & ~AliasThisRec.tracing); 5812 } 5813 } 5814 5815 return wm; 5816 } 5817 5818 override inout(Type) toHeadMutable() inout 5819 { 5820 return this; 5821 } 5822 5823 override void accept(Visitor v) 5824 { 5825 v.visit(this); 5826 } 5827 } 5828 5829 /*********************************************************** 5830 */ 5831 extern (C++) final class TypeEnum : Type 5832 { 5833 EnumDeclaration sym; 5834 5835 extern (D) this(EnumDeclaration sym) 5836 { 5837 super(Tenum); 5838 this.sym = sym; 5839 } 5840 5841 override const(char)* kind() const 5842 { 5843 return "enum"; 5844 } 5845 5846 override Type syntaxCopy() 5847 { 5848 return this; 5849 } 5850 5851 override d_uns64 size(const ref Loc loc) 5852 { 5853 return sym.getMemtype(loc).size(loc); 5854 } 5855 5856 Type memType(const ref Loc loc = Loc.initial) 5857 { 5858 return sym.getMemtype(loc); 5859 } 5860 override uint alignsize() 5861 { 5862 Type t = memType(); 5863 if (t.ty == Terror) 5864 return 4; 5865 return t.alignsize(); 5866 } 5867 5868 override Dsymbol toDsymbol(Scope* sc) 5869 { 5870 return sym; 5871 } 5872 5873 override bool isintegral() 5874 { 5875 return memType().isintegral(); 5876 } 5877 5878 override bool isfloating() 5879 { 5880 return memType().isfloating(); 5881 } 5882 5883 override bool isreal() 5884 { 5885 return memType().isreal(); 5886 } 5887 5888 override bool isimaginary() 5889 { 5890 return memType().isimaginary(); 5891 } 5892 5893 override bool iscomplex() 5894 { 5895 return memType().iscomplex(); 5896 } 5897 5898 override bool isscalar() 5899 { 5900 return memType().isscalar(); 5901 } 5902 5903 override bool isunsigned() 5904 { 5905 return memType().isunsigned(); 5906 } 5907 5908 override bool isBoolean() 5909 { 5910 return memType().isBoolean(); 5911 } 5912 5913 override bool isString() 5914 { 5915 return memType().isString(); 5916 } 5917 5918 override bool isAssignable() 5919 { 5920 return memType().isAssignable(); 5921 } 5922 5923 override bool needsDestruction() 5924 { 5925 return memType().needsDestruction(); 5926 } 5927 5928 override bool needsCopyOrPostblit() 5929 { 5930 return memType().needsCopyOrPostblit(); 5931 } 5932 5933 override bool needsNested() 5934 { 5935 return memType().needsNested(); 5936 } 5937 5938 override MATCH implicitConvTo(Type to) 5939 { 5940 MATCH m; 5941 //printf("TypeEnum::implicitConvTo() %s to %s\n", toChars(), to.toChars()); 5942 if (ty == to.ty && sym == (cast(TypeEnum)to).sym) 5943 m = (mod == to.mod) ? MATCH.exact : MATCH.constant; 5944 else if (sym.getMemtype(Loc.initial).implicitConvTo(to)) 5945 m = MATCH.convert; // match with conversions 5946 else 5947 m = MATCH.nomatch; // no match 5948 return m; 5949 } 5950 5951 override MATCH constConv(Type to) 5952 { 5953 if (equals(to)) 5954 return MATCH.exact; 5955 if (ty == to.ty && sym == (cast(TypeEnum)to).sym && MODimplicitConv(mod, to.mod)) 5956 return MATCH.constant; 5957 return MATCH.nomatch; 5958 } 5959 5960 override Type toBasetype() 5961 { 5962 if (!sym.members && !sym.memtype) 5963 return this; 5964 auto tb = sym.getMemtype(Loc.initial).toBasetype(); 5965 return tb.castMod(mod); // retain modifier bits from 'this' 5966 } 5967 5968 override bool isZeroInit(const ref Loc loc) 5969 { 5970 return sym.getDefaultValue(loc).isBool(false); 5971 } 5972 5973 override bool hasPointers() 5974 { 5975 return memType().hasPointers(); 5976 } 5977 5978 override bool hasVoidInitPointers() 5979 { 5980 return memType().hasVoidInitPointers(); 5981 } 5982 5983 override Type nextOf() 5984 { 5985 return memType().nextOf(); 5986 } 5987 5988 override void accept(Visitor v) 5989 { 5990 v.visit(this); 5991 } 5992 } 5993 5994 /*********************************************************** 5995 */ 5996 extern (C++) final class TypeClass : Type 5997 { 5998 ClassDeclaration sym; 5999 AliasThisRec att = AliasThisRec.fwdref; 6000 CPPMANGLE cppmangle = CPPMANGLE.def; 6001 6002 extern (D) this(ClassDeclaration sym) 6003 { 6004 super(Tclass); 6005 this.sym = sym; 6006 } 6007 6008 override const(char)* kind() const 6009 { 6010 return "class"; 6011 } 6012 6013 override d_uns64 size(const ref Loc loc) const 6014 { 6015 return target.ptrsize; 6016 } 6017 6018 override Type syntaxCopy() 6019 { 6020 return this; 6021 } 6022 6023 override Dsymbol toDsymbol(Scope* sc) 6024 { 6025 return sym; 6026 } 6027 6028 override inout(ClassDeclaration) isClassHandle() inout 6029 { 6030 return sym; 6031 } 6032 6033 override bool isBaseOf(Type t, int* poffset) 6034 { 6035 if (t && t.ty == Tclass) 6036 { 6037 ClassDeclaration cd = (cast(TypeClass)t).sym; 6038 if (sym.isBaseOf(cd, poffset)) 6039 return true; 6040 } 6041 return false; 6042 } 6043 6044 extern (D) MATCH implicitConvToWithoutAliasThis(Type to) 6045 { 6046 MATCH m = constConv(to); 6047 if (m > MATCH.nomatch) 6048 return m; 6049 6050 ClassDeclaration cdto = to.isClassHandle(); 6051 if (cdto) 6052 { 6053 //printf("TypeClass::implicitConvTo(to = '%s') %s, isbase = %d %d\n", to.toChars(), toChars(), cdto.isBaseInfoComplete(), sym.isBaseInfoComplete()); 6054 if (cdto.semanticRun < PASS.semanticdone && !cdto.isBaseInfoComplete()) 6055 cdto.dsymbolSemantic(null); 6056 if (sym.semanticRun < PASS.semanticdone && !sym.isBaseInfoComplete()) 6057 sym.dsymbolSemantic(null); 6058 if (cdto.isBaseOf(sym, null) && MODimplicitConv(mod, to.mod)) 6059 { 6060 //printf("'to' is base\n"); 6061 return MATCH.convert; 6062 } 6063 } 6064 return MATCH.nomatch; 6065 } 6066 6067 extern (D) MATCH implicitConvToThroughAliasThis(Type to) 6068 { 6069 MATCH m; 6070 if (sym.aliasthis && !(att & AliasThisRec.tracing)) 6071 { 6072 if (auto ato = aliasthisOf()) 6073 { 6074 att = cast(AliasThisRec)(att | AliasThisRec.tracing); 6075 m = ato.implicitConvTo(to); 6076 att = cast(AliasThisRec)(att & ~AliasThisRec.tracing); 6077 } 6078 } 6079 return m; 6080 } 6081 6082 override MATCH implicitConvTo(Type to) 6083 { 6084 //printf("TypeClass::implicitConvTo(to = '%s') %s\n", to.toChars(), toChars()); 6085 MATCH m = implicitConvToWithoutAliasThis(to); 6086 return m ? m : implicitConvToThroughAliasThis(to); 6087 } 6088 6089 override MATCH constConv(Type to) 6090 { 6091 if (equals(to)) 6092 return MATCH.exact; 6093 if (ty == to.ty && sym == (cast(TypeClass)to).sym && MODimplicitConv(mod, to.mod)) 6094 return MATCH.constant; 6095 6096 /* Conversion derived to const(base) 6097 */ 6098 int offset = 0; 6099 if (to.isBaseOf(this, &offset) && offset == 0 && MODimplicitConv(mod, to.mod)) 6100 { 6101 // Disallow: 6102 // derived to base 6103 // inout(derived) to inout(base) 6104 if (!to.isMutable() && !to.isWild()) 6105 return MATCH.convert; 6106 } 6107 6108 return MATCH.nomatch; 6109 } 6110 6111 override MOD deduceWild(Type t, bool isRef) 6112 { 6113 ClassDeclaration cd = t.isClassHandle(); 6114 if (cd && (sym == cd || cd.isBaseOf(sym, null))) 6115 return Type.deduceWild(t, isRef); 6116 6117 ubyte wm = 0; 6118 6119 if (t.hasWild() && sym.aliasthis && !(att & AliasThisRec.tracing)) 6120 { 6121 if (auto ato = aliasthisOf()) 6122 { 6123 att = cast(AliasThisRec)(att | AliasThisRec.tracing); 6124 wm = ato.deduceWild(t, isRef); 6125 att = cast(AliasThisRec)(att & ~AliasThisRec.tracing); 6126 } 6127 } 6128 6129 return wm; 6130 } 6131 6132 override inout(Type) toHeadMutable() inout 6133 { 6134 return this; 6135 } 6136 6137 override bool isZeroInit(const ref Loc loc) const 6138 { 6139 return true; 6140 } 6141 6142 override bool isscope() const 6143 { 6144 return sym.stack; 6145 } 6146 6147 override bool isBoolean() const 6148 { 6149 return true; 6150 } 6151 6152 override bool hasPointers() const 6153 { 6154 return true; 6155 } 6156 6157 override void accept(Visitor v) 6158 { 6159 v.visit(this); 6160 } 6161 } 6162 6163 /*********************************************************** 6164 */ 6165 extern (C++) final class TypeTuple : Type 6166 { 6167 Parameters* arguments; // types making up the tuple 6168 6169 extern (D) this(Parameters* arguments) 6170 { 6171 super(Ttuple); 6172 //printf("TypeTuple(this = %p)\n", this); 6173 this.arguments = arguments; 6174 //printf("TypeTuple() %p, %s\n", this, toChars()); 6175 debug 6176 { 6177 if (arguments) 6178 { 6179 for (size_t i = 0; i < arguments.dim; i++) 6180 { 6181 Parameter arg = (*arguments)[i]; 6182 assert(arg && arg.type); 6183 } 6184 } 6185 } 6186 } 6187 6188 /**************** 6189 * Form TypeTuple from the types of the expressions. 6190 * Assume exps[] is already tuple expanded. 6191 */ 6192 extern (D) this(Expressions* exps) 6193 { 6194 super(Ttuple); 6195 auto arguments = new Parameters(); 6196 if (exps) 6197 { 6198 arguments.setDim(exps.dim); 6199 for (size_t i = 0; i < exps.dim; i++) 6200 { 6201 Expression e = (*exps)[i]; 6202 if (e.type.ty == Ttuple) 6203 e.error("cannot form tuple of tuples"); 6204 auto arg = new Parameter(STC.undefined_, e.type, null, null, null); 6205 (*arguments)[i] = arg; 6206 } 6207 } 6208 this.arguments = arguments; 6209 //printf("TypeTuple() %p, %s\n", this, toChars()); 6210 } 6211 6212 static TypeTuple create(Parameters* arguments) 6213 { 6214 return new TypeTuple(arguments); 6215 } 6216 6217 /******************************************* 6218 * Type tuple with 0, 1 or 2 types in it. 6219 */ 6220 extern (D) this() 6221 { 6222 super(Ttuple); 6223 arguments = new Parameters(); 6224 } 6225 6226 extern (D) this(Type t1) 6227 { 6228 super(Ttuple); 6229 arguments = new Parameters(); 6230 arguments.push(new Parameter(0, t1, null, null, null)); 6231 } 6232 6233 extern (D) this(Type t1, Type t2) 6234 { 6235 super(Ttuple); 6236 arguments = new Parameters(); 6237 arguments.push(new Parameter(0, t1, null, null, null)); 6238 arguments.push(new Parameter(0, t2, null, null, null)); 6239 } 6240 6241 static TypeTuple create() 6242 { 6243 return new TypeTuple(); 6244 } 6245 6246 static TypeTuple create(Type t1) 6247 { 6248 return new TypeTuple(t1); 6249 } 6250 6251 static TypeTuple create(Type t1, Type t2) 6252 { 6253 return new TypeTuple(t1, t2); 6254 } 6255 6256 override const(char)* kind() const 6257 { 6258 return "tuple"; 6259 } 6260 6261 override Type syntaxCopy() 6262 { 6263 Parameters* args = Parameter.arraySyntaxCopy(arguments); 6264 Type t = new TypeTuple(args); 6265 t.mod = mod; 6266 return t; 6267 } 6268 6269 override bool equals(const RootObject o) const 6270 { 6271 Type t = cast(Type)o; 6272 //printf("TypeTuple::equals(%s, %s)\n", toChars(), t.toChars()); 6273 if (this == t) 6274 return true; 6275 if (auto tt = t.isTypeTuple()) 6276 { 6277 if (arguments.dim == tt.arguments.dim) 6278 { 6279 for (size_t i = 0; i < tt.arguments.dim; i++) 6280 { 6281 const Parameter arg1 = (*arguments)[i]; 6282 Parameter arg2 = (*tt.arguments)[i]; 6283 if (!arg1.type.equals(arg2.type)) 6284 return false; 6285 } 6286 return true; 6287 } 6288 } 6289 return false; 6290 } 6291 6292 override void accept(Visitor v) 6293 { 6294 v.visit(this); 6295 } 6296 } 6297 6298 /*********************************************************** 6299 * This is so we can slice a TypeTuple 6300 */ 6301 extern (C++) final class TypeSlice : TypeNext 6302 { 6303 Expression lwr; 6304 Expression upr; 6305 6306 extern (D) this(Type next, Expression lwr, Expression upr) 6307 { 6308 super(Tslice, next); 6309 //printf("TypeSlice[%s .. %s]\n", lwr.toChars(), upr.toChars()); 6310 this.lwr = lwr; 6311 this.upr = upr; 6312 } 6313 6314 override const(char)* kind() const 6315 { 6316 return "slice"; 6317 } 6318 6319 override Type syntaxCopy() 6320 { 6321 Type t = new TypeSlice(next.syntaxCopy(), lwr.syntaxCopy(), upr.syntaxCopy()); 6322 t.mod = mod; 6323 return t; 6324 } 6325 6326 override void accept(Visitor v) 6327 { 6328 v.visit(this); 6329 } 6330 } 6331 6332 /*********************************************************** 6333 */ 6334 extern (C++) final class TypeNull : Type 6335 { 6336 extern (D) this() 6337 { 6338 //printf("TypeNull %p\n", this); 6339 super(Tnull); 6340 } 6341 6342 override const(char)* kind() const 6343 { 6344 return "null"; 6345 } 6346 6347 override Type syntaxCopy() 6348 { 6349 // No semantic analysis done, no need to copy 6350 return this; 6351 } 6352 6353 override MATCH implicitConvTo(Type to) 6354 { 6355 //printf("TypeNull::implicitConvTo(this=%p, to=%p)\n", this, to); 6356 //printf("from: %s\n", toChars()); 6357 //printf("to : %s\n", to.toChars()); 6358 MATCH m = Type.implicitConvTo(to); 6359 if (m != MATCH.nomatch) 6360 return m; 6361 6362 // NULL implicitly converts to any pointer type or dynamic array 6363 //if (type.ty == Tpointer && type.nextOf().ty == Tvoid) 6364 { 6365 Type tb = to.toBasetype(); 6366 if (tb.ty == Tnull || tb.ty == Tpointer || tb.ty == Tarray || tb.ty == Taarray || tb.ty == Tclass || tb.ty == Tdelegate) 6367 return MATCH.constant; 6368 } 6369 6370 return MATCH.nomatch; 6371 } 6372 6373 override bool hasPointers() 6374 { 6375 /* Although null isn't dereferencable, treat it as a pointer type for 6376 * attribute inference, generic code, etc. 6377 */ 6378 return true; 6379 } 6380 6381 override bool isBoolean() const 6382 { 6383 return true; 6384 } 6385 6386 override d_uns64 size(const ref Loc loc) const 6387 { 6388 return tvoidptr.size(loc); 6389 } 6390 6391 override void accept(Visitor v) 6392 { 6393 v.visit(this); 6394 } 6395 } 6396 6397 /*********************************************************** 6398 * Encapsulate Parameters* so .length and [i] can be used on it. 6399 * https://dlang.org/spec/function.html#ParameterList 6400 */ 6401 extern (C++) struct ParameterList 6402 { 6403 Parameters* parameters; 6404 VarArg varargs = VarArg.none; 6405 6406 size_t length() 6407 { 6408 return Parameter.dim(parameters); 6409 } 6410 6411 Parameter opIndex(size_t i) 6412 { 6413 return Parameter.getNth(parameters, i); 6414 } 6415 6416 alias parameters this; 6417 } 6418 6419 6420 /*********************************************************** 6421 */ 6422 extern (C++) final class Parameter : ASTNode 6423 { 6424 import dmd.attrib : UserAttributeDeclaration; 6425 6426 StorageClass storageClass; 6427 Type type; 6428 Identifier ident; 6429 Expression defaultArg; 6430 UserAttributeDeclaration userAttribDecl; // user defined attributes 6431 6432 extern (D) this(StorageClass storageClass, Type type, Identifier ident, Expression defaultArg, UserAttributeDeclaration userAttribDecl) 6433 { 6434 this.type = type; 6435 this.ident = ident; 6436 this.storageClass = storageClass; 6437 this.defaultArg = defaultArg; 6438 this.userAttribDecl = userAttribDecl; 6439 } 6440 6441 static Parameter create(StorageClass storageClass, Type type, Identifier ident, Expression defaultArg, UserAttributeDeclaration userAttribDecl) 6442 { 6443 return new Parameter(storageClass, type, ident, defaultArg, userAttribDecl); 6444 } 6445 6446 Parameter syntaxCopy() 6447 { 6448 return new Parameter(storageClass, type ? type.syntaxCopy() : null, ident, defaultArg ? defaultArg.syntaxCopy() : null, userAttribDecl ? cast(UserAttributeDeclaration) userAttribDecl.syntaxCopy(null) : null); 6449 } 6450 6451 /**************************************************** 6452 * Determine if parameter is a lazy array of delegates. 6453 * If so, return the return type of those delegates. 6454 * If not, return NULL. 6455 * 6456 * Returns T if the type is one of the following forms: 6457 * T delegate()[] 6458 * T delegate()[dim] 6459 */ 6460 Type isLazyArray() 6461 { 6462 Type tb = type.toBasetype(); 6463 if (tb.ty == Tsarray || tb.ty == Tarray) 6464 { 6465 Type tel = (cast(TypeArray)tb).next.toBasetype(); 6466 if (auto td = tel.isTypeDelegate()) 6467 { 6468 TypeFunction tf = td.next.toTypeFunction(); 6469 if (tf.parameterList.varargs == VarArg.none && tf.parameterList.length == 0) 6470 { 6471 return tf.next; // return type of delegate 6472 } 6473 } 6474 } 6475 return null; 6476 } 6477 6478 // kludge for template.isType() 6479 override DYNCAST dyncast() const 6480 { 6481 return DYNCAST.parameter; 6482 } 6483 6484 override void accept(Visitor v) 6485 { 6486 v.visit(this); 6487 } 6488 6489 extern (D) static Parameters* arraySyntaxCopy(Parameters* parameters) 6490 { 6491 Parameters* params = null; 6492 if (parameters) 6493 { 6494 params = new Parameters(parameters.dim); 6495 for (size_t i = 0; i < params.dim; i++) 6496 (*params)[i] = (*parameters)[i].syntaxCopy(); 6497 } 6498 return params; 6499 } 6500 6501 /*************************************** 6502 * Determine number of arguments, folding in tuples. 6503 */ 6504 static size_t dim(Parameters* parameters) 6505 { 6506 size_t nargs = 0; 6507 6508 int dimDg(size_t n, Parameter p) 6509 { 6510 ++nargs; 6511 return 0; 6512 } 6513 6514 _foreach(parameters, &dimDg); 6515 return nargs; 6516 } 6517 6518 /*************************************** 6519 * Get nth Parameter, folding in tuples. 6520 * Returns: 6521 * Parameter* nth Parameter 6522 * NULL not found, *pn gets incremented by the number 6523 * of Parameters 6524 */ 6525 static Parameter getNth(Parameters* parameters, size_t nth, size_t* pn = null) 6526 { 6527 Parameter param; 6528 6529 int getNthParamDg(size_t n, Parameter p) 6530 { 6531 if (n == nth) 6532 { 6533 param = p; 6534 return 1; 6535 } 6536 return 0; 6537 } 6538 6539 int res = _foreach(parameters, &getNthParamDg); 6540 return res ? param : null; 6541 } 6542 6543 alias ForeachDg = extern (D) int delegate(size_t paramidx, Parameter param); 6544 6545 /*************************************** 6546 * Expands tuples in args in depth first order. Calls 6547 * dg(void *ctx, size_t argidx, Parameter *arg) for each Parameter. 6548 * If dg returns !=0, stops and returns that value else returns 0. 6549 * Use this function to avoid the O(N + N^2/2) complexity of 6550 * calculating dim and calling N times getNth. 6551 */ 6552 extern (D) static int _foreach(Parameters* parameters, scope ForeachDg dg, size_t* pn = null) 6553 { 6554 assert(dg); 6555 if (!parameters) 6556 return 0; 6557 6558 size_t n = pn ? *pn : 0; // take over index 6559 int result = 0; 6560 foreach (i; 0 .. parameters.dim) 6561 { 6562 Parameter p = (*parameters)[i]; 6563 Type t = p.type.toBasetype(); 6564 6565 if (auto tu = t.isTypeTuple()) 6566 { 6567 result = _foreach(tu.arguments, dg, &n); 6568 } 6569 else 6570 result = dg(n++, p); 6571 6572 if (result) 6573 break; 6574 } 6575 6576 if (pn) 6577 *pn = n; // update index 6578 return result; 6579 } 6580 6581 override const(char)* toChars() const 6582 { 6583 return ident ? ident.toChars() : "__anonymous_param"; 6584 } 6585 6586 /********************************* 6587 * Compute covariance of parameters `this` and `p` 6588 * as determined by the storage classes of both. 6589 * Params: 6590 * returnByRef = true if the function returns by ref 6591 * p = Parameter to compare with 6592 * Returns: 6593 * true = `this` can be used in place of `p` 6594 * false = nope 6595 */ 6596 bool isCovariant(bool returnByRef, const Parameter p) const pure nothrow @nogc @safe 6597 { 6598 enum stc = STC.ref_ | STC.in_ | STC.out_ | STC.lazy_; 6599 if ((this.storageClass & stc) != (p.storageClass & stc)) 6600 return false; 6601 return isCovariantScope(returnByRef, this.storageClass, p.storageClass); 6602 } 6603 6604 extern (D) private static bool isCovariantScope(bool returnByRef, StorageClass from, StorageClass to) pure nothrow @nogc @safe 6605 { 6606 if (from == to) 6607 return true; 6608 6609 /* Shrinking the representation is necessary because StorageClass is so wide 6610 * Params: 6611 * returnByRef = true if the function returns by ref 6612 * stc = storage class of parameter 6613 */ 6614 static uint buildSR(bool returnByRef, StorageClass stc) pure nothrow @nogc @safe 6615 { 6616 uint result; 6617 final switch (stc & (STC.ref_ | STC.scope_ | STC.return_)) 6618 { 6619 case 0: result = SR.None; break; 6620 case STC.ref_: result = SR.Ref; break; 6621 case STC.scope_: result = SR.Scope; break; 6622 case STC.return_ | STC.ref_: result = SR.ReturnRef; break; 6623 case STC.return_ | STC.scope_: result = SR.ReturnScope; break; 6624 case STC.ref_ | STC.scope_: result = SR.RefScope; break; 6625 case STC.return_ | STC.ref_ | STC.scope_: 6626 result = returnByRef ? SR.ReturnRef_Scope : SR.Ref_ReturnScope; 6627 break; 6628 } 6629 return result; 6630 } 6631 6632 /* result is true if the 'from' can be used as a 'to' 6633 */ 6634 6635 if ((from ^ to) & STC.ref_) // differing in 'ref' means no covariance 6636 return false; 6637 6638 return covariant[buildSR(returnByRef, from)][buildSR(returnByRef, to)]; 6639 } 6640 6641 /* Classification of 'scope-return-ref' possibilities 6642 */ 6643 private enum SR 6644 { 6645 None, 6646 Scope, 6647 ReturnScope, 6648 Ref, 6649 ReturnRef, 6650 RefScope, 6651 ReturnRef_Scope, 6652 Ref_ReturnScope, 6653 } 6654 6655 extern (D) private static bool[SR.max + 1][SR.max + 1] covariantInit() pure nothrow @nogc @safe 6656 { 6657 /* Initialize covariant[][] with this: 6658 6659 From\To n rs s 6660 None X 6661 ReturnScope X X 6662 Scope X X X 6663 6664 From\To r rr rs rr-s r-rs 6665 Ref X X 6666 ReturnRef X 6667 RefScope X X X X X 6668 ReturnRef-Scope X X 6669 Ref-ReturnScope X X X 6670 */ 6671 bool[SR.max + 1][SR.max + 1] covariant; 6672 6673 foreach (i; 0 .. SR.max + 1) 6674 { 6675 covariant[i][i] = true; 6676 covariant[SR.RefScope][i] = true; 6677 } 6678 covariant[SR.ReturnScope][SR.None] = true; 6679 covariant[SR.Scope ][SR.None] = true; 6680 covariant[SR.Scope ][SR.ReturnScope] = true; 6681 6682 covariant[SR.Ref ][SR.ReturnRef] = true; 6683 covariant[SR.ReturnRef_Scope][SR.ReturnRef] = true; 6684 covariant[SR.Ref_ReturnScope][SR.Ref ] = true; 6685 covariant[SR.Ref_ReturnScope][SR.ReturnRef] = true; 6686 6687 return covariant; 6688 } 6689 6690 extern (D) private static immutable bool[SR.max + 1][SR.max + 1] covariant = covariantInit(); 6691 } 6692 6693 /************************************************************* 6694 * For printing two types with qualification when necessary. 6695 * Params: 6696 * t1 = The first type to receive the type name for 6697 * t2 = The second type to receive the type name for 6698 * Returns: 6699 * The fully-qualified names of both types if the two type names are not the same, 6700 * or the unqualified names of both types if the two type names are the same. 6701 */ 6702 const(char*)[2] toAutoQualChars(Type t1, Type t2) 6703 { 6704 auto s1 = t1.toChars(); 6705 auto s2 = t2.toChars(); 6706 // show qualification only if it's different 6707 if (!t1.equals(t2) && strcmp(s1, s2) == 0) 6708 { 6709 s1 = t1.toPrettyChars(true); 6710 s2 = t2.toPrettyChars(true); 6711 } 6712 return [s1, s2]; 6713 } 6714 6715 6716 /** 6717 * For each active modifier (MODFlags.const_, MODFlags.immutable_, etc) call `fp` with a 6718 * void* for the work param and a string representation of the attribute. 6719 */ 6720 void modifiersApply(const TypeFunction tf, void delegate(string) dg) 6721 { 6722 immutable ubyte[4] modsArr = [MODFlags.const_, MODFlags.immutable_, MODFlags.wild, MODFlags.shared_]; 6723 6724 foreach (modsarr; modsArr) 6725 { 6726 if (tf.mod & modsarr) 6727 { 6728 dg(MODtoString(modsarr)); 6729 } 6730 } 6731 } 6732 6733 /** 6734 * For each active attribute (ref/const/nogc/etc) call `fp` with a void* for the 6735 * work param and a string representation of the attribute. 6736 */ 6737 void attributesApply(const TypeFunction tf, void delegate(string) dg, TRUSTformat trustFormat = TRUSTformatDefault) 6738 { 6739 if (tf.purity) 6740 dg("pure"); 6741 if (tf.isnothrow) 6742 dg("nothrow"); 6743 if (tf.isnogc) 6744 dg("@nogc"); 6745 if (tf.isproperty) 6746 dg("@property"); 6747 if (tf.isref) 6748 dg("ref"); 6749 if (tf.isreturn && !tf.isreturninferred) 6750 dg("return"); 6751 if (tf.isscope && !tf.isscopeinferred) 6752 dg("scope"); 6753 if (tf.islive) 6754 dg("@live"); 6755 6756 TRUST trustAttrib = tf.trust; 6757 6758 if (trustAttrib == TRUST.default_) 6759 { 6760 if (trustFormat == TRUSTformatSystem) 6761 trustAttrib = TRUST.system; 6762 else 6763 return; // avoid calling with an empty string 6764 } 6765 6766 dg(trustToString(trustAttrib)); 6767 } 6768 6769 /** 6770 * If the type is a class or struct, returns the symbol for it, 6771 * else null. 6772 */ 6773 extern (C++) AggregateDeclaration isAggregate(Type t) 6774 { 6775 t = t.toBasetype(); 6776 if (t.ty == Tclass) 6777 return (cast(TypeClass)t).sym; 6778 if (t.ty == Tstruct) 6779 return (cast(TypeStruct)t).sym; 6780 return null; 6781 } 6782 6783 /*************************************************** 6784 * Determine if type t can be indexed or sliced given that it is not an 6785 * aggregate with operator overloads. 6786 * Params: 6787 * t = type to check 6788 * Returns: 6789 * true if an expression of type t can be e1 in an array expression 6790 */ 6791 bool isIndexableNonAggregate(Type t) 6792 { 6793 t = t.toBasetype(); 6794 return (t.ty == Tpointer || t.ty == Tsarray || t.ty == Tarray || t.ty == Taarray || 6795 t.ty == Ttuple || t.ty == Tvector); 6796 } 6797 6798 /*************************************************** 6799 * Determine if type t is copyable. 6800 * Params: 6801 * t = type to check 6802 * Returns: 6803 * true if we can copy it 6804 */ 6805 bool isCopyable(const Type t) pure nothrow @nogc 6806 { 6807 //printf("isCopyable() %s\n", t.toChars()); 6808 if (auto ts = t.isTypeStruct()) 6809 { 6810 if (ts.sym.postblit && 6811 ts.sym.postblit.storage_class & STC.disable) 6812 return false; 6813 } 6814 return true; 6815 }