1 2/* Compiler implementation of the D programming language 3 * Copyright (C) 1999-2019 by The D Language Foundation, All Rights Reserved 4 * written by Walter Bright 5 * http://www.digitalmars.com 6 * Distributed under the Boost Software License, Version 1.0. 7 * http://www.boost.org/LICENSE_1_0.txt 8 * https://github.com/D-Programming-Language/dmd/blob/master/src/cast.c 9 */ 10 11#include "root/dsystem.h" // mem{set|cpy}() 12#include "root/rmem.h" 13 14#include "mars.h" 15#include "expression.h" 16#include "mtype.h" 17#include "utf.h" 18#include "declaration.h" 19#include "aggregate.h" 20#include "template.h" 21#include "scope.h" 22#include "id.h" 23#include "init.h" 24#include "tokens.h" 25 26FuncDeclaration *isFuncAddress(Expression *e, bool *hasOverloads = NULL); 27bool isCommutative(TOK op); 28MOD MODmerge(MOD mod1, MOD mod2); 29Expression *semantic(Expression *e, Scope *sc); 30 31/* ==================== implicitCast ====================== */ 32 33/************************************** 34 * Do an implicit cast. 35 * Issue error if it can't be done. 36 */ 37 38 39Expression *implicitCastTo(Expression *e, Scope *sc, Type *t) 40{ 41 class ImplicitCastTo : public Visitor 42 { 43 public: 44 Type *t; 45 Scope *sc; 46 Expression *result; 47 48 ImplicitCastTo(Scope *sc, Type *t) 49 : t(t), sc(sc) 50 { 51 result = NULL; 52 } 53 54 void visit(Expression *e) 55 { 56 //printf("Expression::implicitCastTo(%s of type %s) => %s\n", e->toChars(), e->type->toChars(), t->toChars()); 57 58 MATCH match = e->implicitConvTo(t); 59 if (match) 60 { 61 if (match == MATCHconst && 62 (e->type->constConv(t) || 63 (!e->isLvalue() && e->type->equivalent(t)))) 64 { 65 /* Do not emit CastExp for const conversions and 66 * unique conversions on rvalue. 67 */ 68 result = e->copy(); 69 result->type = t; 70 return; 71 } 72 result = e->castTo(sc, t); 73 return; 74 } 75 76 result = e->optimize(WANTvalue); 77 if (result != e) 78 { 79 result->accept(this); 80 return; 81 } 82 83 if (t->ty != Terror && e->type->ty != Terror) 84 { 85 if (!t->deco) 86 { 87 e->error("forward reference to type %s", t->toChars()); 88 } 89 else 90 { 91 //printf("type %p ty %d deco %p\n", type, type->ty, type->deco); 92 //type = type->semantic(loc, sc); 93 //printf("type %s t %s\n", type->deco, t->deco); 94 e->error("cannot implicitly convert expression (%s) of type %s to %s", 95 e->toChars(), e->type->toChars(), t->toChars()); 96 } 97 } 98 result = new ErrorExp(); 99 } 100 101 void visit(StringExp *e) 102 { 103 //printf("StringExp::implicitCastTo(%s of type %s) => %s\n", e->toChars(), e->type->toChars(), t->toChars()); 104 visit((Expression *)e); 105 if (result->op == TOKstring) 106 { 107 // Retain polysemous nature if it started out that way 108 ((StringExp *)result)->committed = e->committed; 109 } 110 } 111 112 void visit(ErrorExp *e) 113 { 114 result = e; 115 } 116 117 void visit(FuncExp *e) 118 { 119 //printf("FuncExp::implicitCastTo type = %p %s, t = %s\n", e->type, e->type ? e->type->toChars() : NULL, t->toChars()); 120 FuncExp *fe; 121 if (e->matchType(t, sc, &fe) > MATCHnomatch) 122 { 123 result = fe; 124 return; 125 } 126 visit((Expression *)e); 127 } 128 129 void visit(ArrayLiteralExp *e) 130 { 131 visit((Expression *)e); 132 133 Type *tb = result->type->toBasetype(); 134 if (tb->ty == Tarray && global.params.useTypeInfo && Type::dtypeinfo) 135 semanticTypeInfo(sc, ((TypeDArray *)tb)->next); 136 } 137 138 void visit(SliceExp *e) 139 { 140 visit((Expression *)e); 141 if (result->op != TOKslice) 142 return; 143 144 e = (SliceExp *)result; 145 if (e->e1->op == TOKarrayliteral) 146 { 147 ArrayLiteralExp *ale = (ArrayLiteralExp *)e->e1; 148 Type *tb = t->toBasetype(); 149 Type *tx; 150 if (tb->ty == Tsarray) 151 tx = tb->nextOf()->sarrayOf(ale->elements ? ale->elements->dim : 0); 152 else 153 tx = tb->nextOf()->arrayOf(); 154 e->e1 = ale->implicitCastTo(sc, tx); 155 } 156 } 157 }; 158 159 ImplicitCastTo v(sc, t); 160 e->accept(&v); 161 return v.result; 162} 163 164/******************************************* 165 * Return MATCH level of implicitly converting e to type t. 166 * Don't do the actual cast; don't change e. 167 */ 168 169MATCH implicitConvTo(Expression *e, Type *t) 170{ 171 class ImplicitConvTo : public Visitor 172 { 173 public: 174 Type *t; 175 MATCH result; 176 177 ImplicitConvTo(Type *t) 178 : t(t) 179 { 180 result = MATCHnomatch; 181 } 182 183 void visit(Expression *e) 184 { 185 //static int nest; if (++nest == 10) halt(); 186 if (t == Type::terror) 187 return; 188 if (!e->type) 189 { 190 e->error("%s is not an expression", e->toChars()); 191 e->type = Type::terror; 192 } 193 Expression *ex = e->optimize(WANTvalue); 194 if (ex->type->equals(t)) 195 { 196 result = MATCHexact; 197 return; 198 } 199 if (ex != e) 200 { 201 //printf("\toptimized to %s of type %s\n", e->toChars(), e->type->toChars()); 202 result = ex->implicitConvTo(t); 203 return; 204 } 205 MATCH match = e->type->implicitConvTo(t); 206 if (match != MATCHnomatch) 207 { 208 result = match; 209 return; 210 } 211 212 /* See if we can do integral narrowing conversions 213 */ 214 if (e->type->isintegral() && t->isintegral() && 215 e->type->isTypeBasic() && t->isTypeBasic()) 216 { 217 IntRange src = getIntRange(e); 218 IntRange target = IntRange::fromType(t); 219 if (target.contains(src)) 220 { 221 result = MATCHconvert; 222 return; 223 } 224 } 225 } 226 227 /****** 228 * Given expression e of type t, see if we can implicitly convert e 229 * to type tprime, where tprime is type t with mod bits added. 230 * Returns: 231 * match level 232 */ 233 static MATCH implicitMod(Expression *e, Type *t, MOD mod) 234 { 235 Type *tprime; 236 if (t->ty == Tpointer) 237 tprime = t->nextOf()->castMod(mod)->pointerTo(); 238 else if (t->ty == Tarray) 239 tprime = t->nextOf()->castMod(mod)->arrayOf(); 240 else if (t->ty == Tsarray) 241 tprime = t->nextOf()->castMod(mod)->sarrayOf(t->size() / t->nextOf()->size()); 242 else 243 tprime = t->castMod(mod); 244 245 return e->implicitConvTo(tprime); 246 } 247 248 static MATCH implicitConvToAddMin(BinExp *e, Type *t) 249 { 250 /* Is this (ptr +- offset)? If so, then ask ptr 251 * if the conversion can be done. 252 * This is to support doing things like implicitly converting a mutable unique 253 * pointer to an immutable pointer. 254 */ 255 256 Type *typeb = e->type->toBasetype(); 257 Type *tb = t->toBasetype(); 258 if (typeb->ty != Tpointer || tb->ty != Tpointer) 259 return MATCHnomatch; 260 261 Type *t1b = e->e1->type->toBasetype(); 262 Type *t2b = e->e2->type->toBasetype(); 263 if (t1b->ty == Tpointer && t2b->isintegral() && 264 t1b->equivalent(tb)) 265 { 266 // ptr + offset 267 // ptr - offset 268 MATCH m = e->e1->implicitConvTo(t); 269 return (m > MATCHconst) ? MATCHconst : m; 270 } 271 if (t2b->ty == Tpointer && t1b->isintegral() && 272 t2b->equivalent(tb)) 273 { 274 // offset + ptr 275 MATCH m = e->e2->implicitConvTo(t); 276 return (m > MATCHconst) ? MATCHconst : m; 277 } 278 279 return MATCHnomatch; 280 } 281 282 void visit(AddExp *e) 283 { 284 visit((Expression *)e); 285 if (result == MATCHnomatch) 286 result = implicitConvToAddMin(e, t); 287 } 288 289 void visit(MinExp *e) 290 { 291 visit((Expression *)e); 292 if (result == MATCHnomatch) 293 result = implicitConvToAddMin(e, t); 294 } 295 296 void visit(IntegerExp *e) 297 { 298 MATCH m = e->type->implicitConvTo(t); 299 if (m >= MATCHconst) 300 { 301 result = m; 302 return; 303 } 304 305 TY ty = e->type->toBasetype()->ty; 306 TY toty = t->toBasetype()->ty; 307 TY oldty = ty; 308 309 if (m == MATCHnomatch && t->ty == Tenum) 310 return; 311 312 if (t->ty == Tvector) 313 { 314 TypeVector *tv = (TypeVector *)t; 315 TypeBasic *tb = tv->elementType(); 316 if (tb->ty == Tvoid) 317 return; 318 toty = tb->ty; 319 } 320 321 switch (ty) 322 { 323 case Tbool: 324 case Tint8: 325 case Tchar: 326 case Tuns8: 327 case Tint16: 328 case Tuns16: 329 case Twchar: 330 ty = Tint32; 331 break; 332 333 case Tdchar: 334 ty = Tuns32; 335 break; 336 337 default: 338 break; 339 } 340 341 // Only allow conversion if no change in value 342 dinteger_t value = e->toInteger(); 343 switch (toty) 344 { 345 case Tbool: 346 if ((value & 1) != value) 347 return; 348 break; 349 350 case Tint8: 351 if (ty == Tuns64 && value & ~0x7FUL) 352 return; 353 else if ((signed char)value != (sinteger_t)value) 354 return; 355 break; 356 357 case Tchar: 358 if ((oldty == Twchar || oldty == Tdchar) && value > 0x7F) 359 return; 360 /* fall through */ 361 case Tuns8: 362 //printf("value = %llu %llu\n", (dinteger_t)(unsigned char)value, value); 363 if ((unsigned char)value != value) 364 return; 365 break; 366 367 case Tint16: 368 if (ty == Tuns64 && value & ~0x7FFFUL) 369 return; 370 else if ((short)value != (sinteger_t)value) 371 return; 372 break; 373 374 case Twchar: 375 if (oldty == Tdchar && value > 0xD7FF && value < 0xE000) 376 return; 377 /* fall through */ 378 case Tuns16: 379 if ((unsigned short)value != value) 380 return; 381 break; 382 383 case Tint32: 384 if (ty == Tuns32) 385 { 386 } 387 else if (ty == Tuns64 && value & ~0x7FFFFFFFUL) 388 return; 389 else if ((int)value != (sinteger_t)value) 390 return; 391 break; 392 393 case Tuns32: 394 if (ty == Tint32) 395 { 396 } 397 else if ((unsigned)value != value) 398 return; 399 break; 400 401 case Tdchar: 402 if (value > 0x10FFFFUL) 403 return; 404 break; 405 406 case Tfloat32: 407 { 408 volatile float f; 409 if (e->type->isunsigned()) 410 { 411 f = (float)value; 412 if (f != value) 413 return; 414 } 415 else 416 { 417 f = (float)(sinteger_t)value; 418 if (f != (sinteger_t)value) 419 return; 420 } 421 break; 422 } 423 424 case Tfloat64: 425 { 426 volatile double f; 427 if (e->type->isunsigned()) 428 { 429 f = (double)value; 430 if (f != value) 431 return; 432 } 433 else 434 { 435 f = (double)(sinteger_t)value; 436 if (f != (sinteger_t)value) 437 return; 438 } 439 break; 440 } 441 442 case Tfloat80: 443 { 444 volatile_longdouble f; 445 if (e->type->isunsigned()) 446 { 447 f = ldouble(value); 448 if ((dinteger_t)f != value) // isn't this a noop, because the compiler prefers ld 449 return; 450 } 451 else 452 { 453 f = ldouble((sinteger_t)value); 454 if ((sinteger_t)f != (sinteger_t)value) 455 return; 456 } 457 break; 458 } 459 460 case Tpointer: 461 //printf("type = %s\n", type->toBasetype()->toChars()); 462 //printf("t = %s\n", t->toBasetype()->toChars()); 463 if (ty == Tpointer && 464 e->type->toBasetype()->nextOf()->ty == t->toBasetype()->nextOf()->ty) 465 { 466 /* Allow things like: 467 * const char* P = cast(char *)3; 468 * char* q = P; 469 */ 470 break; 471 } 472 /* fall through */ 473 474 default: 475 visit((Expression *)e); 476 return; 477 } 478 479 //printf("MATCHconvert\n"); 480 result = MATCHconvert; 481 } 482 483 void visit(ErrorExp *) 484 { 485 // no match 486 } 487 488 void visit(NullExp *e) 489 { 490 if (e->type->equals(t)) 491 { 492 result = MATCHexact; 493 return; 494 } 495 496 /* Allow implicit conversions from immutable to mutable|const, 497 * and mutable to immutable. It works because, after all, a null 498 * doesn't actually point to anything. 499 */ 500 if (t->equivalent(e->type)) 501 { 502 result = MATCHconst; 503 return; 504 } 505 506 visit((Expression *)e); 507 } 508 509 void visit(StructLiteralExp *e) 510 { 511 visit((Expression *)e); 512 if (result != MATCHnomatch) 513 return; 514 if (e->type->ty == t->ty && e->type->ty == Tstruct && 515 ((TypeStruct *)e->type)->sym == ((TypeStruct *)t)->sym) 516 { 517 result = MATCHconst; 518 for (size_t i = 0; i < e->elements->dim; i++) 519 { 520 Expression *el = (*e->elements)[i]; 521 if (!el) 522 continue; 523 Type *te = el->type; 524 te = e->sd->fields[i]->type->addMod(t->mod); 525 MATCH m2 = el->implicitConvTo(te); 526 //printf("\t%s => %s, match = %d\n", el->toChars(), te->toChars(), m2); 527 if (m2 < result) 528 result = m2; 529 } 530 } 531 } 532 533 void visit(StringExp *e) 534 { 535 if (!e->committed && t->ty == Tpointer && t->nextOf()->ty == Tvoid) 536 return; 537 538 if (e->type->ty == Tsarray || e->type->ty == Tarray || e->type->ty == Tpointer) 539 { 540 TY tyn = e->type->nextOf()->ty; 541 if (tyn == Tchar || tyn == Twchar || tyn == Tdchar) 542 { 543 switch (t->ty) 544 { 545 case Tsarray: 546 if (e->type->ty == Tsarray) 547 { 548 TY tynto = t->nextOf()->ty; 549 if (tynto == tyn) 550 { 551 if (((TypeSArray *)e->type)->dim->toInteger() == 552 ((TypeSArray *)t)->dim->toInteger()) 553 { 554 result = MATCHexact; 555 } 556 return; 557 } 558 if (tynto == Tchar || tynto == Twchar || tynto == Tdchar) 559 { 560 if (e->committed && tynto != tyn) 561 return; 562 size_t fromlen = e->numberOfCodeUnits(tynto); 563 size_t tolen = (size_t)((TypeSArray *)t)->dim->toInteger(); 564 if (tolen < fromlen) 565 return; 566 if (tolen != fromlen) 567 { 568 // implicit length extending 569 result = MATCHconvert; 570 return; 571 } 572 } 573 if (!e->committed && (tynto == Tchar || tynto == Twchar || tynto == Tdchar)) 574 { 575 result = MATCHexact; 576 return; 577 } 578 } 579 else if (e->type->ty == Tarray) 580 { 581 TY tynto = t->nextOf()->ty; 582 if (tynto == Tchar || tynto == Twchar || tynto == Tdchar) 583 { 584 if (e->committed && tynto != tyn) 585 return; 586 size_t fromlen = e->numberOfCodeUnits(tynto); 587 size_t tolen = (size_t)((TypeSArray *)t)->dim->toInteger(); 588 if (tolen < fromlen) 589 return; 590 if (tolen != fromlen) 591 { 592 // implicit length extending 593 result = MATCHconvert; 594 return; 595 } 596 } 597 if (tynto == tyn) 598 { 599 result = MATCHexact; 600 return; 601 } 602 if (!e->committed && (tynto == Tchar || tynto == Twchar || tynto == Tdchar)) 603 { 604 result = MATCHexact; 605 return; 606 } 607 } 608 /* fall through */ 609 case Tarray: 610 case Tpointer: 611 Type *tn = t->nextOf(); 612 MATCH m = MATCHexact; 613 if (e->type->nextOf()->mod != tn->mod) 614 { 615 if (!tn->isConst()) 616 return; 617 m = MATCHconst; 618 } 619 if (!e->committed) 620 { 621 switch (tn->ty) 622 { 623 case Tchar: 624 if (e->postfix == 'w' || e->postfix == 'd') 625 m = MATCHconvert; 626 result = m; 627 return; 628 case Twchar: 629 if (e->postfix != 'w') 630 m = MATCHconvert; 631 result = m; 632 return; 633 case Tdchar: 634 if (e->postfix != 'd') 635 m = MATCHconvert; 636 result = m; 637 return; 638 } 639 } 640 break; 641 } 642 } 643 } 644 645 visit((Expression *)e); 646 } 647 648 void visit(ArrayLiteralExp *e) 649 { 650 Type *typeb = e->type->toBasetype(); 651 Type *tb = t->toBasetype(); 652 if ((tb->ty == Tarray || tb->ty == Tsarray) && 653 (typeb->ty == Tarray || typeb->ty == Tsarray)) 654 { 655 result = MATCHexact; 656 Type *typen = typeb->nextOf()->toBasetype(); 657 658 if (tb->ty == Tsarray) 659 { 660 TypeSArray *tsa = (TypeSArray *)tb; 661 if (e->elements->dim != tsa->dim->toInteger()) 662 result = MATCHnomatch; 663 } 664 665 Type *telement = tb->nextOf(); 666 if (!e->elements->dim) 667 { 668 if (typen->ty != Tvoid) 669 result = typen->implicitConvTo(telement); 670 } 671 else 672 { 673 if (e->basis) 674 { 675 MATCH m = e->basis->implicitConvTo(telement); 676 if (m < result) 677 result = m; 678 } 679 for (size_t i = 0; i < e->elements->dim; i++) 680 { 681 Expression *el = (*e->elements)[i]; 682 if (result == MATCHnomatch) 683 break; 684 if (!el) 685 continue; 686 MATCH m = el->implicitConvTo(telement); 687 if (m < result) 688 result = m; // remember worst match 689 } 690 } 691 692 if (!result) 693 result = e->type->implicitConvTo(t); 694 695 return; 696 } 697 else if (tb->ty == Tvector && 698 (typeb->ty == Tarray || typeb->ty == Tsarray)) 699 { 700 result = MATCHexact; 701 // Convert array literal to vector type 702 TypeVector *tv = (TypeVector *)tb; 703 TypeSArray *tbase = (TypeSArray *)tv->basetype; 704 assert(tbase->ty == Tsarray); 705 const size_t edim = e->elements->dim; 706 const size_t tbasedim = tbase->dim->toInteger(); 707 if (edim > tbasedim) 708 { 709 result = MATCHnomatch; 710 return; 711 } 712 713 Type *telement = tv->elementType(); 714 if (edim < tbasedim) 715 { 716 Expression *el = typeb->nextOf()->defaultInitLiteral(e->loc); 717 MATCH m = el->implicitConvTo(telement); 718 if (m < result) 719 result = m; // remember worst match 720 } 721 for (size_t i = 0; i < edim; i++) 722 { 723 Expression *el = (*e->elements)[i]; 724 MATCH m = el->implicitConvTo(telement); 725 if (m < result) 726 result = m; // remember worst match 727 if (result == MATCHnomatch) 728 break; // no need to check for worse 729 } 730 return; 731 } 732 733 visit((Expression *)e); 734 } 735 736 void visit(AssocArrayLiteralExp *e) 737 { 738 Type *typeb = e->type->toBasetype(); 739 Type *tb = t->toBasetype(); 740 if (tb->ty == Taarray && typeb->ty == Taarray) 741 { 742 result = MATCHexact; 743 for (size_t i = 0; i < e->keys->dim; i++) 744 { 745 Expression *el = (*e->keys)[i]; 746 MATCH m = el->implicitConvTo(((TypeAArray *)tb)->index); 747 if (m < result) 748 result = m; // remember worst match 749 if (result == MATCHnomatch) 750 break; // no need to check for worse 751 el = (*e->values)[i]; 752 m = el->implicitConvTo(tb->nextOf()); 753 if (m < result) 754 result = m; // remember worst match 755 if (result == MATCHnomatch) 756 break; // no need to check for worse 757 } 758 return; 759 } 760 else 761 visit((Expression *)e); 762 } 763 764 void visit(CallExp *e) 765 { 766 visit((Expression *)e); 767 if (result != MATCHnomatch) 768 return; 769 770 /* Allow the result of strongly pure functions to 771 * convert to immutable 772 */ 773 if (e->f && e->f->isolateReturn()) 774 { 775 result = e->type->immutableOf()->implicitConvTo(t); 776 if (result > MATCHconst) // Match level is MATCHconst at best. 777 result = MATCHconst; 778 return; 779 } 780 781 /* Conversion is 'const' conversion if: 782 * 1. function is pure (weakly pure is ok) 783 * 2. implicit conversion only fails because of mod bits 784 * 3. each function parameter can be implicitly converted to the mod bits 785 */ 786 Type *tx = e->f ? e->f->type : e->e1->type; 787 tx = tx->toBasetype(); 788 if (tx->ty != Tfunction) 789 return; 790 TypeFunction *tf = (TypeFunction *)tx; 791 792 if (tf->purity == PUREimpure) 793 return; 794 if (e->f && e->f->isNested()) 795 return; 796 797 /* See if fail only because of mod bits. 798 * 799 * Bugzilla 14155: All pure functions can access global immutable data. 800 * So the returned pointer may refer an immutable global data, 801 * and then the returned pointer that points non-mutable object 802 * cannot be unique pointer. 803 * 804 * Example: 805 * immutable g; 806 * static this() { g = 1; } 807 * const(int*) foo() pure { return &g; } 808 * void test() { 809 * immutable(int*) ip = foo(); // OK 810 * int* mp = foo(); // should be disallowed 811 * } 812 */ 813 if (e->type->immutableOf()->implicitConvTo(t) < MATCHconst && 814 e->type->addMod(MODshared)->implicitConvTo(t) < MATCHconst && 815 e->type->implicitConvTo(t->addMod(MODshared)) < MATCHconst) 816 { 817 return; 818 } 819 // Allow a conversion to immutable type, or 820 // conversions of mutable types between thread-local and shared. 821 822 /* Get mod bits of what we're converting to 823 */ 824 Type *tb = t->toBasetype(); 825 MOD mod = tb->mod; 826 if (tf->isref) 827 ; 828 else 829 { 830 Type *ti = getIndirection(t); 831 if (ti) 832 mod = ti->mod; 833 } 834 if (mod & MODwild) 835 return; // not sure what to do with this 836 837 /* Apply mod bits to each function parameter, 838 * and see if we can convert the function argument to the modded type 839 */ 840 841 size_t nparams = Parameter::dim(tf->parameters); 842 size_t j = (tf->linkage == LINKd && tf->varargs == 1); // if TypeInfoArray was prepended 843 if (e->e1->op == TOKdotvar) 844 { 845 /* Treat 'this' as just another function argument 846 */ 847 DotVarExp *dve = (DotVarExp *)e->e1; 848 Type *targ = dve->e1->type; 849 if (targ->constConv(targ->castMod(mod)) == MATCHnomatch) 850 return; 851 } 852 for (size_t i = j; i < e->arguments->dim; ++i) 853 { 854 Expression *earg = (*e->arguments)[i]; 855 Type *targ = earg->type->toBasetype(); 856 if (i - j < nparams) 857 { 858 Parameter *fparam = Parameter::getNth(tf->parameters, i - j); 859 if (fparam->storageClass & STClazy) 860 return; // not sure what to do with this 861 Type *tparam = fparam->type; 862 if (!tparam) 863 continue; 864 if (fparam->storageClass & (STCout | STCref)) 865 { 866 if (targ->constConv(tparam->castMod(mod)) == MATCHnomatch) 867 return; 868 continue; 869 } 870 } 871 872 if (implicitMod(earg, targ, mod) == MATCHnomatch) 873 return; 874 } 875 876 /* Success 877 */ 878 result = MATCHconst; 879 } 880 881 void visit(AddrExp *e) 882 { 883 result = e->type->implicitConvTo(t); 884 //printf("\tresult = %d\n", result); 885 886 if (result != MATCHnomatch) 887 return; 888 889 // Look for pointers to functions where the functions are overloaded. 890 891 t = t->toBasetype(); 892 893 if (e->e1->op == TOKoverloadset && 894 (t->ty == Tpointer || t->ty == Tdelegate) && t->nextOf()->ty == Tfunction) 895 { 896 OverExp *eo = (OverExp *)e->e1; 897 FuncDeclaration *f = NULL; 898 for (size_t i = 0; i < eo->vars->a.dim; i++) 899 { 900 Dsymbol *s = eo->vars->a[i]; 901 FuncDeclaration *f2 = s->isFuncDeclaration(); 902 assert(f2); 903 if (f2->overloadExactMatch(t->nextOf())) 904 { 905 if (f) 906 { 907 /* Error if match in more than one overload set, 908 * even if one is a 'better' match than the other. 909 */ 910 ScopeDsymbol::multiplyDefined(e->loc, f, f2); 911 } 912 else 913 f = f2; 914 result = MATCHexact; 915 } 916 } 917 } 918 919 if (e->type->ty == Tpointer && e->type->nextOf()->ty == Tfunction && 920 t->ty == Tpointer && t->nextOf()->ty == Tfunction && 921 e->e1->op == TOKvar) 922 { 923 /* I don't think this can ever happen - 924 * it should have been 925 * converted to a SymOffExp. 926 */ 927 assert(0); 928 } 929 930 //printf("\tresult = %d\n", result); 931 } 932 933 void visit(SymOffExp *e) 934 { 935 result = e->type->implicitConvTo(t); 936 //printf("\tresult = %d\n", result); 937 if (result != MATCHnomatch) 938 return; 939 940 // Look for pointers to functions where the functions are overloaded. 941 t = t->toBasetype(); 942 if (e->type->ty == Tpointer && e->type->nextOf()->ty == Tfunction && 943 (t->ty == Tpointer || t->ty == Tdelegate) && t->nextOf()->ty == Tfunction) 944 { 945 if (FuncDeclaration *f = e->var->isFuncDeclaration()) 946 { 947 f = f->overloadExactMatch(t->nextOf()); 948 if (f) 949 { 950 if ((t->ty == Tdelegate && (f->needThis() || f->isNested())) || 951 (t->ty == Tpointer && !(f->needThis() || f->isNested()))) 952 { 953 result = MATCHexact; 954 } 955 } 956 } 957 } 958 //printf("\tresult = %d\n", result); 959 } 960 961 void visit(DelegateExp *e) 962 { 963 result = e->type->implicitConvTo(t); 964 if (result != MATCHnomatch) 965 return; 966 967 // Look for pointers to functions where the functions are overloaded. 968 t = t->toBasetype(); 969 if (e->type->ty == Tdelegate && 970 t->ty == Tdelegate) 971 { 972 if (e->func && e->func->overloadExactMatch(t->nextOf())) 973 result = MATCHexact; 974 } 975 } 976 977 void visit(FuncExp *e) 978 { 979 //printf("FuncExp::implicitConvTo type = %p %s, t = %s\n", e->type, e->type ? e->type->toChars() : NULL, t->toChars()); 980 MATCH m = e->matchType(t, NULL, NULL, 1); 981 if (m > MATCHnomatch) 982 { 983 result = m; 984 return; 985 } 986 visit((Expression *)e); 987 } 988 989 void visit(AndExp *e) 990 { 991 visit((Expression *)e); 992 if (result != MATCHnomatch) 993 return; 994 995 MATCH m1 = e->e1->implicitConvTo(t); 996 MATCH m2 = e->e2->implicitConvTo(t); 997 998 // Pick the worst match 999 result = (m1 < m2) ? m1 : m2; 1000 } 1001 1002 void visit(OrExp *e) 1003 { 1004 visit((Expression *)e); 1005 if (result != MATCHnomatch) 1006 return; 1007 1008 MATCH m1 = e->e1->implicitConvTo(t); 1009 MATCH m2 = e->e2->implicitConvTo(t); 1010 1011 // Pick the worst match 1012 result = (m1 < m2) ? m1 : m2; 1013 } 1014 1015 void visit(XorExp *e) 1016 { 1017 visit((Expression *)e); 1018 if (result != MATCHnomatch) 1019 return; 1020 1021 MATCH m1 = e->e1->implicitConvTo(t); 1022 MATCH m2 = e->e2->implicitConvTo(t); 1023 1024 // Pick the worst match 1025 result = (m1 < m2) ? m1 : m2; 1026 } 1027 1028 void visit(CondExp *e) 1029 { 1030 MATCH m1 = e->e1->implicitConvTo(t); 1031 MATCH m2 = e->e2->implicitConvTo(t); 1032 //printf("CondExp: m1 %d m2 %d\n", m1, m2); 1033 1034 // Pick the worst match 1035 result = (m1 < m2) ? m1 : m2; 1036 } 1037 1038 void visit(CommaExp *e) 1039 { 1040 e->e2->accept(this); 1041 } 1042 1043 void visit(CastExp *e) 1044 { 1045 result = e->type->implicitConvTo(t); 1046 if (result != MATCHnomatch) 1047 return; 1048 1049 if (t->isintegral() && 1050 e->e1->type->isintegral() && 1051 e->e1->implicitConvTo(t) != MATCHnomatch) 1052 result = MATCHconvert; 1053 else 1054 visit((Expression *)e); 1055 } 1056 1057 void visit(NewExp *e) 1058 { 1059 visit((Expression *)e); 1060 if (result != MATCHnomatch) 1061 return; 1062 1063 /* Calling new() is like calling a pure function. We can implicitly convert the 1064 * return from new() to t using the same algorithm as in CallExp, with the function 1065 * 'arguments' being: 1066 * thisexp 1067 * newargs 1068 * arguments 1069 * .init 1070 * 'member' and 'allocator' need to be pure. 1071 */ 1072 1073 /* See if fail only because of mod bits 1074 */ 1075 if (e->type->immutableOf()->implicitConvTo(t->immutableOf()) == MATCHnomatch) 1076 return; 1077 1078 /* Get mod bits of what we're converting to 1079 */ 1080 Type *tb = t->toBasetype(); 1081 MOD mod = tb->mod; 1082 if (Type *ti = getIndirection(t)) 1083 mod = ti->mod; 1084 if (mod & MODwild) 1085 return; // not sure what to do with this 1086 1087 /* Apply mod bits to each argument, 1088 * and see if we can convert the argument to the modded type 1089 */ 1090 1091 if (e->thisexp) 1092 { 1093 /* Treat 'this' as just another function argument 1094 */ 1095 Type *targ = e->thisexp->type; 1096 if (targ->constConv(targ->castMod(mod)) == MATCHnomatch) 1097 return; 1098 } 1099 1100 /* Check call to 'allocator', then 'member' 1101 */ 1102 FuncDeclaration *fd = e->allocator; 1103 for (int count = 0; count < 2; ++count, (fd = e->member)) 1104 { 1105 if (!fd) 1106 continue; 1107 if (fd->errors || fd->type->ty != Tfunction) 1108 return; // error 1109 TypeFunction *tf = (TypeFunction *)fd->type; 1110 if (tf->purity == PUREimpure) 1111 return; // impure 1112 1113 if (fd == e->member) 1114 { 1115 if (e->type->immutableOf()->implicitConvTo(t) < MATCHconst && 1116 e->type->addMod(MODshared)->implicitConvTo(t) < MATCHconst && 1117 e->type->implicitConvTo(t->addMod(MODshared)) < MATCHconst) 1118 { 1119 return; 1120 } 1121 // Allow a conversion to immutable type, or 1122 // conversions of mutable types between thread-local and shared. 1123 } 1124 1125 Expressions *args = (fd == e->allocator) ? e->newargs : e->arguments; 1126 1127 size_t nparams = Parameter::dim(tf->parameters); 1128 size_t j = (tf->linkage == LINKd && tf->varargs == 1); // if TypeInfoArray was prepended 1129 for (size_t i = j; i < e->arguments->dim; ++i) 1130 { 1131 Expression *earg = (*args)[i]; 1132 Type *targ = earg->type->toBasetype(); 1133 if (i - j < nparams) 1134 { 1135 Parameter *fparam = Parameter::getNth(tf->parameters, i - j); 1136 if (fparam->storageClass & STClazy) 1137 return; // not sure what to do with this 1138 Type *tparam = fparam->type; 1139 if (!tparam) 1140 continue; 1141 if (fparam->storageClass & (STCout | STCref)) 1142 { 1143 if (targ->constConv(tparam->castMod(mod)) == MATCHnomatch) 1144 return; 1145 continue; 1146 } 1147 } 1148 1149 if (implicitMod(earg, targ, mod) == MATCHnomatch) 1150 return; 1151 } 1152 } 1153 1154 /* If no 'member', then construction is by simple assignment, 1155 * and just straight check 'arguments' 1156 */ 1157 if (!e->member && e->arguments) 1158 { 1159 for (size_t i = 0; i < e->arguments->dim; ++i) 1160 { 1161 Expression *earg = (*e->arguments)[i]; 1162 if (!earg) // Bugzilla 14853: if it's on overlapped field 1163 continue; 1164 Type *targ = earg->type->toBasetype(); 1165 if (implicitMod(earg, targ, mod) == MATCHnomatch) 1166 return; 1167 } 1168 } 1169 1170 /* Consider the .init expression as an argument 1171 */ 1172 Type *ntb = e->newtype->toBasetype(); 1173 if (ntb->ty == Tarray) 1174 ntb = ntb->nextOf()->toBasetype(); 1175 if (ntb->ty == Tstruct) 1176 { 1177 // Don't allow nested structs - uplevel reference may not be convertible 1178 StructDeclaration *sd = ((TypeStruct *)ntb)->sym; 1179 sd->size(e->loc); // resolve any forward references 1180 if (sd->isNested()) 1181 return; 1182 } 1183 if (ntb->isZeroInit(e->loc)) 1184 { 1185 /* Zeros are implicitly convertible, except for special cases. 1186 */ 1187 if (ntb->ty == Tclass) 1188 { 1189 /* With new() must look at the class instance initializer. 1190 */ 1191 ClassDeclaration *cd = ((TypeClass *)ntb)->sym; 1192 1193 cd->size(e->loc); // resolve any forward references 1194 1195 if (cd->isNested()) 1196 return; // uplevel reference may not be convertible 1197 1198 assert(!cd->isInterfaceDeclaration()); 1199 1200 struct ClassCheck 1201 { 1202 static bool convertible(Loc loc, ClassDeclaration *cd, MOD mod) 1203 { 1204 for (size_t i = 0; i < cd->fields.dim; i++) 1205 { 1206 VarDeclaration *v = cd->fields[i]; 1207 Initializer *init = v->_init; 1208 if (init) 1209 { 1210 if (init->isVoidInitializer()) 1211 ; 1212 else if (ExpInitializer *ei = init->isExpInitializer()) 1213 { 1214 Type *tb = v->type->toBasetype(); 1215 if (implicitMod(ei->exp, tb, mod) == MATCHnomatch) 1216 return false; 1217 } 1218 else 1219 { 1220 /* Enhancement: handle StructInitializer and ArrayInitializer 1221 */ 1222 return false; 1223 } 1224 } 1225 else if (!v->type->isZeroInit(loc)) 1226 return false; 1227 } 1228 return cd->baseClass ? convertible(loc, cd->baseClass, mod) : true; 1229 } 1230 }; 1231 1232 if (!ClassCheck::convertible(e->loc, cd, mod)) 1233 return; 1234 } 1235 } 1236 else 1237 { 1238 Expression *earg = e->newtype->defaultInitLiteral(e->loc); 1239 Type *targ = e->newtype->toBasetype(); 1240 1241 if (implicitMod(earg, targ, mod) == MATCHnomatch) 1242 return; 1243 } 1244 1245 /* Success 1246 */ 1247 result = MATCHconst; 1248 } 1249 1250 void visit(SliceExp *e) 1251 { 1252 //printf("SliceExp::implicitConvTo e = %s, type = %s\n", e->toChars(), e->type->toChars()); 1253 visit((Expression *)e); 1254 if (result != MATCHnomatch) 1255 return; 1256 1257 Type *tb = t->toBasetype(); 1258 Type *typeb = e->type->toBasetype(); 1259 if (tb->ty == Tsarray && typeb->ty == Tarray) 1260 { 1261 typeb = toStaticArrayType(e); 1262 if (typeb) 1263 result = typeb->implicitConvTo(t); 1264 return; 1265 } 1266 1267 /* If the only reason it won't convert is because of the mod bits, 1268 * then test for conversion by seeing if e1 can be converted with those 1269 * same mod bits. 1270 */ 1271 Type *t1b = e->e1->type->toBasetype(); 1272 if (tb->ty == Tarray && typeb->equivalent(tb)) 1273 { 1274 Type *tbn = tb->nextOf(); 1275 Type *tx = NULL; 1276 1277 /* If e->e1 is dynamic array or pointer, the uniqueness of e->e1 1278 * is equivalent with the uniqueness of the referred data. And in here 1279 * we can have arbitrary typed reference for that. 1280 */ 1281 if (t1b->ty == Tarray) 1282 tx = tbn->arrayOf(); 1283 if (t1b->ty == Tpointer) 1284 tx = tbn->pointerTo(); 1285 1286 /* If e->e1 is static array, at least it should be an rvalue. 1287 * If not, e->e1 is a reference, and its uniqueness does not link 1288 * to the uniqueness of the referred data. 1289 */ 1290 if (t1b->ty == Tsarray && !e->e1->isLvalue()) 1291 tx = tbn->sarrayOf(t1b->size() / tbn->size()); 1292 1293 if (tx) 1294 { 1295 result = e->e1->implicitConvTo(tx); 1296 if (result > MATCHconst) // Match level is MATCHconst at best. 1297 result = MATCHconst; 1298 } 1299 } 1300 1301 // Enhancement 10724 1302 if (tb->ty == Tpointer && e->e1->op == TOKstring) 1303 e->e1->accept(this); 1304 } 1305 }; 1306 1307 ImplicitConvTo v(t); 1308 e->accept(&v); 1309 return v.result; 1310} 1311 1312Type *toStaticArrayType(SliceExp *e) 1313{ 1314 if (e->lwr && e->upr) 1315 { 1316 // For the following code to work, e should be optimized beforehand. 1317 // (eg. $ in lwr and upr should be already resolved, if possible) 1318 Expression *lwr = e->lwr->optimize(WANTvalue); 1319 Expression *upr = e->upr->optimize(WANTvalue); 1320 if (lwr->isConst() && upr->isConst()) 1321 { 1322 size_t len = (size_t)(upr->toUInteger() - lwr->toUInteger()); 1323 return e->type->toBasetype()->nextOf()->sarrayOf(len); 1324 } 1325 } 1326 else 1327 { 1328 Type *t1b = e->e1->type->toBasetype(); 1329 if (t1b->ty == Tsarray) 1330 return t1b; 1331 } 1332 return NULL; 1333} 1334 1335/* ==================== castTo ====================== */ 1336 1337/************************************** 1338 * Do an explicit cast. 1339 * Assume that the 'this' expression does not have any indirections. 1340 */ 1341 1342Expression *castTo(Expression *e, Scope *sc, Type *t) 1343{ 1344 class CastTo : public Visitor 1345 { 1346 public: 1347 Type *t; 1348 Scope *sc; 1349 Expression *result; 1350 1351 CastTo(Scope *sc, Type *t) 1352 : t(t), sc(sc) 1353 { 1354 result = NULL; 1355 } 1356 1357 void visit(Expression *e) 1358 { 1359 //printf("Expression::castTo(this=%s, t=%s)\n", e->toChars(), t->toChars()); 1360 if (e->type->equals(t)) 1361 { 1362 result = e; 1363 return; 1364 } 1365 if (e->op == TOKvar) 1366 { 1367 VarDeclaration *v = ((VarExp *)e)->var->isVarDeclaration(); 1368 if (v && v->storage_class & STCmanifest) 1369 { 1370 result = e->ctfeInterpret(); 1371 result = result->castTo(sc, t); 1372 return; 1373 } 1374 } 1375 1376 Type *tob = t->toBasetype(); 1377 Type *t1b = e->type->toBasetype(); 1378 if (tob->equals(t1b)) 1379 { 1380 result = e->copy(); // because of COW for assignment to e->type 1381 result->type = t; 1382 return; 1383 } 1384 1385 /* Make semantic error against invalid cast between concrete types. 1386 * Assume that 'e' is never be any placeholder expressions. 1387 * The result of these checks should be consistent with CastExp::toElem(). 1388 */ 1389 1390 // Fat Value types 1391 const bool tob_isFV = (tob->ty == Tstruct || tob->ty == Tsarray || tob->ty == Tvector); 1392 const bool t1b_isFV = (t1b->ty == Tstruct || t1b->ty == Tsarray || t1b->ty == Tvector); 1393 1394 // Fat Reference types 1395 const bool tob_isFR = (tob->ty == Tarray || tob->ty == Tdelegate); 1396 const bool t1b_isFR = (t1b->ty == Tarray || t1b->ty == Tdelegate); 1397 1398 // Reference types 1399 const bool tob_isR = (tob_isFR || tob->ty == Tpointer || tob->ty == Taarray || tob->ty == Tclass); 1400 const bool t1b_isR = (t1b_isFR || t1b->ty == Tpointer || t1b->ty == Taarray || t1b->ty == Tclass); 1401 1402 // Arithmetic types (== valueable basic types) 1403 const bool tob_isA = ((tob->isintegral() || tob->isfloating()) && tob->ty != Tvector); 1404 const bool t1b_isA = ((t1b->isintegral() || t1b->isfloating()) && t1b->ty != Tvector); 1405 1406 if (AggregateDeclaration *t1ad = isAggregate(t1b)) 1407 { 1408 AggregateDeclaration *toad = isAggregate(tob); 1409 if (t1ad != toad && t1ad->aliasthis) 1410 { 1411 if (t1b->ty == Tclass && tob->ty == Tclass) 1412 { 1413 ClassDeclaration *t1cd = t1b->isClassHandle(); 1414 ClassDeclaration *tocd = tob->isClassHandle(); 1415 int offset; 1416 if (tocd->isBaseOf(t1cd, &offset)) 1417 goto Lok; 1418 } 1419 1420 /* Forward the cast to our alias this member, rewrite to: 1421 * cast(to)e1.aliasthis 1422 */ 1423 result = resolveAliasThis(sc, e); 1424 result = result->castTo(sc, t); 1425 return; 1426 } 1427 } 1428 else if (tob->ty == Tvector && t1b->ty != Tvector) 1429 { 1430 //printf("test1 e = %s, e->type = %s, tob = %s\n", e->toChars(), e->type->toChars(), tob->toChars()); 1431 TypeVector *tv = (TypeVector *)tob; 1432 result = new CastExp(e->loc, e, tv->elementType()); 1433 result = new VectorExp(e->loc, result, tob); 1434 result = ::semantic(result, sc); 1435 return; 1436 } 1437 else if (tob->ty != Tvector && t1b->ty == Tvector) 1438 { 1439 // T[n] <-- __vector(U[m]) 1440 if (tob->ty == Tsarray) 1441 { 1442 if (t1b->size(e->loc) == tob->size(e->loc)) 1443 goto Lok; 1444 } 1445 goto Lfail; 1446 } 1447 else if (t1b->implicitConvTo(tob) == MATCHconst && t->equals(e->type->constOf())) 1448 { 1449 result = e->copy(); 1450 result->type = t; 1451 return; 1452 } 1453 1454 // arithmetic values vs. other arithmetic values 1455 // arithmetic values vs. T* 1456 if ((tob_isA && (t1b_isA || t1b->ty == Tpointer)) || 1457 (t1b_isA && (tob_isA || tob->ty == Tpointer))) 1458 { 1459 goto Lok; 1460 } 1461 1462 // arithmetic values vs. references or fat values 1463 if ((tob_isA && (t1b_isR || t1b_isFV)) || 1464 (t1b_isA && (tob_isR || tob_isFV))) 1465 { 1466 goto Lfail; 1467 } 1468 1469 // Bugzlla 3133: A cast between fat values is possible only when the sizes match. 1470 if (tob_isFV && t1b_isFV) 1471 { 1472 if (t1b->size(e->loc) == tob->size(e->loc)) 1473 goto Lok; 1474 e->error("cannot cast expression %s of type %s to %s because of different sizes", 1475 e->toChars(), e->type->toChars(), t->toChars()); 1476 result = new ErrorExp(); 1477 return; 1478 } 1479 1480 // Fat values vs. null or references 1481 if ((tob_isFV && (t1b->ty == Tnull || t1b_isR)) || 1482 (t1b_isFV && (tob->ty == Tnull || tob_isR))) 1483 { 1484 if (tob->ty == Tpointer && t1b->ty == Tsarray) 1485 { 1486 // T[n] sa; 1487 // cast(U*)sa; // ==> cast(U*)sa.ptr; 1488 result = new AddrExp(e->loc, e, t); 1489 return; 1490 } 1491 if (tob->ty == Tarray && t1b->ty == Tsarray) 1492 { 1493 // T[n] sa; 1494 // cast(U[])sa; // ==> cast(U[])sa[]; 1495 d_uns64 fsize = t1b->nextOf()->size(); 1496 d_uns64 tsize = tob->nextOf()->size(); 1497 if (fsize != tsize) 1498 { 1499 dinteger_t dim = ((TypeSArray *)t1b)->dim->toInteger(); 1500 if (tsize == 0 || (dim * fsize) % tsize != 0) 1501 { 1502 e->error("cannot cast expression `%s` of type `%s` to `%s` since sizes don't line up", 1503 e->toChars(), e->type->toChars(), t->toChars()); 1504 result = new ErrorExp(); 1505 return; 1506 } 1507 } 1508 goto Lok; 1509 } 1510 goto Lfail; 1511 } 1512 1513 /* For references, any reinterpret casts are allowed to same 'ty' type. 1514 * T* to U* 1515 * R1 function(P1) to R2 function(P2) 1516 * R1 delegate(P1) to R2 delegate(P2) 1517 * T[] to U[] 1518 * V1[K1] to V2[K2] 1519 * class/interface A to B (will be a dynamic cast if possible) 1520 */ 1521 if (tob->ty == t1b->ty && tob_isR && t1b_isR) 1522 goto Lok; 1523 1524 // typeof(null) <-- non-null references or values 1525 if (tob->ty == Tnull && t1b->ty != Tnull) 1526 goto Lfail; // Bugzilla 14629 1527 // typeof(null) --> non-null references or arithmetic values 1528 if (t1b->ty == Tnull && tob->ty != Tnull) 1529 goto Lok; 1530 1531 // Check size mismatch of references. 1532 // Tarray and Tdelegate are (void*).sizeof*2, but others have (void*).sizeof. 1533 if ((tob_isFR && t1b_isR) || (t1b_isFR && tob_isR)) 1534 { 1535 if (tob->ty == Tpointer && t1b->ty == Tarray) 1536 { 1537 // T[] da; 1538 // cast(U*)da; // ==> cast(U*)da.ptr; 1539 goto Lok; 1540 } 1541 if (tob->ty == Tpointer && t1b->ty == Tdelegate) 1542 { 1543 // void delegate() dg; 1544 // cast(U*)dg; // ==> cast(U*)dg.ptr; 1545 // Note that it happens even when U is a Tfunction! 1546 e->deprecation("casting from %s to %s is deprecated", e->type->toChars(), t->toChars()); 1547 goto Lok; 1548 } 1549 goto Lfail; 1550 } 1551 1552 if (t1b->ty == Tvoid && tob->ty != Tvoid) 1553 { 1554 Lfail: 1555 e->error("cannot cast expression %s of type %s to %s", 1556 e->toChars(), e->type->toChars(), t->toChars()); 1557 result = new ErrorExp(); 1558 return; 1559 } 1560 1561 Lok: 1562 result = new CastExp(e->loc, e, t); 1563 result->type = t; // Don't call semantic() 1564 //printf("Returning: %s\n", result->toChars()); 1565 } 1566 1567 void visit(ErrorExp *e) 1568 { 1569 result = e; 1570 } 1571 1572 void visit(RealExp *e) 1573 { 1574 if (!e->type->equals(t)) 1575 { 1576 if ((e->type->isreal() && t->isreal()) || 1577 (e->type->isimaginary() && t->isimaginary()) 1578 ) 1579 { 1580 result = e->copy(); 1581 result->type = t; 1582 } 1583 else 1584 visit((Expression *)e); 1585 return; 1586 } 1587 result = e; 1588 } 1589 1590 void visit(ComplexExp *e) 1591 { 1592 if (!e->type->equals(t)) 1593 { 1594 if (e->type->iscomplex() && t->iscomplex()) 1595 { 1596 result = e->copy(); 1597 result->type = t; 1598 } 1599 else 1600 visit((Expression *)e); 1601 return; 1602 } 1603 result = e; 1604 } 1605 1606 void visit(NullExp *e) 1607 { 1608 //printf("NullExp::castTo(t = %s) %s\n", t->toChars(), toChars()); 1609 visit((Expression *)e); 1610 if (result->op == TOKnull) 1611 { 1612 NullExp *ex = (NullExp *)result; 1613 ex->committed = 1; 1614 return; 1615 } 1616 } 1617 1618 void visit(StructLiteralExp *e) 1619 { 1620 visit((Expression *)e); 1621 if (result->op == TOKstructliteral) 1622 ((StructLiteralExp *)result)->stype = t; // commit type 1623 } 1624 1625 void visit(StringExp *e) 1626 { 1627 /* This follows copy-on-write; any changes to 'this' 1628 * will result in a copy. 1629 * The this->string member is considered immutable. 1630 */ 1631 int copied = 0; 1632 1633 //printf("StringExp::castTo(t = %s), '%s' committed = %d\n", t->toChars(), e->toChars(), e->committed); 1634 1635 if (!e->committed && t->ty == Tpointer && t->nextOf()->ty == Tvoid) 1636 { 1637 e->error("cannot convert string literal to void*"); 1638 result = new ErrorExp(); 1639 return; 1640 } 1641 1642 StringExp *se = e; 1643 if (!e->committed) 1644 { 1645 se = (StringExp *)e->copy(); 1646 se->committed = 1; 1647 copied = 1; 1648 } 1649 1650 if (e->type->equals(t)) 1651 { 1652 result = se; 1653 return; 1654 } 1655 1656 Type *tb = t->toBasetype(); 1657 //printf("\ttype = %s\n", e->type->toChars()); 1658 if (tb->ty == Tdelegate && e->type->toBasetype()->ty != Tdelegate) 1659 { 1660 visit((Expression *)e); 1661 return; 1662 } 1663 1664 Type *typeb = e->type->toBasetype(); 1665 if (typeb->equals(tb)) 1666 { 1667 if (!copied) 1668 { 1669 se = (StringExp *)e->copy(); 1670 copied = 1; 1671 } 1672 se->type = t; 1673 result = se; 1674 return; 1675 } 1676 1677 /* Handle reinterpret casts: 1678 * cast(wchar[3])"abcd"c --> [\u6261, \u6463, \u0000] 1679 * cast(wchar[2])"abcd"c --> [\u6261, \u6463] 1680 * cast(wchar[1])"abcd"c --> [\u6261] 1681 */ 1682 if (e->committed && tb->ty == Tsarray && typeb->ty == Tarray) 1683 { 1684 se = (StringExp *)e->copy(); 1685 d_uns64 szx = tb->nextOf()->size(); 1686 assert(szx <= 255); 1687 se->sz = (unsigned char)szx; 1688 se->len = (size_t)((TypeSArray *)tb)->dim->toInteger(); 1689 se->committed = 1; 1690 se->type = t; 1691 1692 /* Assure space for terminating 0 1693 */ 1694 if ((se->len + 1) * se->sz > (e->len + 1) * e->sz) 1695 { 1696 void *s = (void *)mem.xmalloc((se->len + 1) * se->sz); 1697 memcpy(s, se->string, se->len * se->sz); 1698 memset((char *)s + se->len * se->sz, 0, se->sz); 1699 se->string = s; 1700 } 1701 result = se; 1702 return; 1703 } 1704 1705 if (tb->ty != Tsarray && tb->ty != Tarray && tb->ty != Tpointer) 1706 { 1707 if (!copied) 1708 { 1709 se = (StringExp *)e->copy(); 1710 copied = 1; 1711 } 1712 goto Lcast; 1713 } 1714 if (typeb->ty != Tsarray && typeb->ty != Tarray && typeb->ty != Tpointer) 1715 { 1716 if (!copied) 1717 { 1718 se = (StringExp *)e->copy(); 1719 copied = 1; 1720 } 1721 goto Lcast; 1722 } 1723 1724 if (typeb->nextOf()->size() == tb->nextOf()->size()) 1725 { 1726 if (!copied) 1727 { 1728 se = (StringExp *)e->copy(); 1729 copied = 1; 1730 } 1731 if (tb->ty == Tsarray) 1732 goto L2; // handle possible change in static array dimension 1733 se->type = t; 1734 result = se; 1735 return; 1736 } 1737 1738 if (e->committed) 1739 goto Lcast; 1740 1741 #define X(tf,tt) ((int)(tf) * 256 + (int)(tt)) 1742 { 1743 OutBuffer buffer; 1744 size_t newlen = 0; 1745 int tfty = typeb->nextOf()->toBasetype()->ty; 1746 int ttty = tb->nextOf()->toBasetype()->ty; 1747 switch (X(tfty, ttty)) 1748 { 1749 case X(Tchar, Tchar): 1750 case X(Twchar,Twchar): 1751 case X(Tdchar,Tdchar): 1752 break; 1753 1754 case X(Tchar, Twchar): 1755 for (size_t u = 0; u < e->len;) 1756 { 1757 unsigned c; 1758 const char *p = utf_decodeChar((utf8_t *)se->string, e->len, &u, &c); 1759 if (p) 1760 e->error("%s", p); 1761 else 1762 buffer.writeUTF16(c); 1763 } 1764 newlen = buffer.offset / 2; 1765 buffer.writeUTF16(0); 1766 goto L1; 1767 1768 case X(Tchar, Tdchar): 1769 for (size_t u = 0; u < e->len;) 1770 { 1771 unsigned c; 1772 const char *p = utf_decodeChar((utf8_t *)se->string, e->len, &u, &c); 1773 if (p) 1774 e->error("%s", p); 1775 buffer.write4(c); 1776 newlen++; 1777 } 1778 buffer.write4(0); 1779 goto L1; 1780 1781 case X(Twchar,Tchar): 1782 for (size_t u = 0; u < e->len;) 1783 { 1784 unsigned c; 1785 const char *p = utf_decodeWchar((unsigned short *)se->string, e->len, &u, &c); 1786 if (p) 1787 e->error("%s", p); 1788 else 1789 buffer.writeUTF8(c); 1790 } 1791 newlen = buffer.offset; 1792 buffer.writeUTF8(0); 1793 goto L1; 1794 1795 case X(Twchar,Tdchar): 1796 for (size_t u = 0; u < e->len;) 1797 { 1798 unsigned c; 1799 const char *p = utf_decodeWchar((unsigned short *)se->string, e->len, &u, &c); 1800 if (p) 1801 e->error("%s", p); 1802 buffer.write4(c); 1803 newlen++; 1804 } 1805 buffer.write4(0); 1806 goto L1; 1807 1808 case X(Tdchar,Tchar): 1809 for (size_t u = 0; u < e->len; u++) 1810 { 1811 unsigned c = ((unsigned *)se->string)[u]; 1812 if (!utf_isValidDchar(c)) 1813 e->error("invalid UCS-32 char \\U%08x", c); 1814 else 1815 buffer.writeUTF8(c); 1816 newlen++; 1817 } 1818 newlen = buffer.offset; 1819 buffer.writeUTF8(0); 1820 goto L1; 1821 1822 case X(Tdchar,Twchar): 1823 for (size_t u = 0; u < e->len; u++) 1824 { 1825 unsigned c = ((unsigned *)se->string)[u]; 1826 if (!utf_isValidDchar(c)) 1827 e->error("invalid UCS-32 char \\U%08x", c); 1828 else 1829 buffer.writeUTF16(c); 1830 newlen++; 1831 } 1832 newlen = buffer.offset / 2; 1833 buffer.writeUTF16(0); 1834 goto L1; 1835 1836 L1: 1837 if (!copied) 1838 { 1839 se = (StringExp *)e->copy(); 1840 copied = 1; 1841 } 1842 se->string = buffer.extractData(); 1843 se->len = newlen; 1844 1845 { 1846 d_uns64 szx = tb->nextOf()->size(); 1847 assert(szx <= 255); 1848 se->sz = (unsigned char)szx; 1849 } 1850 break; 1851 1852 default: 1853 assert(typeb->nextOf()->size() != tb->nextOf()->size()); 1854 goto Lcast; 1855 } 1856 } 1857 #undef X 1858 L2: 1859 assert(copied); 1860 1861 // See if need to truncate or extend the literal 1862 if (tb->ty == Tsarray) 1863 { 1864 size_t dim2 = (size_t)((TypeSArray *)tb)->dim->toInteger(); 1865 1866 //printf("dim from = %d, to = %d\n", (int)se->len, (int)dim2); 1867 1868 // Changing dimensions 1869 if (dim2 != se->len) 1870 { 1871 // Copy when changing the string literal 1872 size_t newsz = se->sz; 1873 size_t d = (dim2 < se->len) ? dim2 : se->len; 1874 void *s = (void *)mem.xmalloc((dim2 + 1) * newsz); 1875 memcpy(s, se->string, d * newsz); 1876 // Extend with 0, add terminating 0 1877 memset((char *)s + d * newsz, 0, (dim2 + 1 - d) * newsz); 1878 se->string = s; 1879 se->len = dim2; 1880 } 1881 } 1882 se->type = t; 1883 result = se; 1884 return; 1885 1886 Lcast: 1887 result = new CastExp(e->loc, se, t); 1888 result->type = t; // so semantic() won't be run on e 1889 } 1890 1891 void visit(AddrExp *e) 1892 { 1893 Type *tb; 1894 1895 result = e; 1896 1897 tb = t->toBasetype(); 1898 e->type = e->type->toBasetype(); 1899 if (!tb->equals(e->type)) 1900 { 1901 // Look for pointers to functions where the functions are overloaded. 1902 1903 if (e->e1->op == TOKoverloadset && 1904 (t->ty == Tpointer || t->ty == Tdelegate) && t->nextOf()->ty == Tfunction) 1905 { 1906 OverExp *eo = (OverExp *)e->e1; 1907 FuncDeclaration *f = NULL; 1908 for (size_t i = 0; i < eo->vars->a.dim; i++) 1909 { 1910 Dsymbol *s = eo->vars->a[i]; 1911 FuncDeclaration *f2 = s->isFuncDeclaration(); 1912 assert(f2); 1913 if (f2->overloadExactMatch(t->nextOf())) 1914 { 1915 if (f) 1916 { 1917 /* Error if match in more than one overload set, 1918 * even if one is a 'better' match than the other. 1919 */ 1920 ScopeDsymbol::multiplyDefined(e->loc, f, f2); 1921 } 1922 else 1923 f = f2; 1924 } 1925 } 1926 if (f) 1927 { 1928 f->tookAddressOf++; 1929 SymOffExp *se = new SymOffExp(e->loc, f, 0, false); 1930 ::semantic(se, sc); 1931 // Let SymOffExp::castTo() do the heavy lifting 1932 visit(se); 1933 return; 1934 } 1935 } 1936 1937 if (e->type->ty == Tpointer && e->type->nextOf()->ty == Tfunction && 1938 tb->ty == Tpointer && tb->nextOf()->ty == Tfunction && 1939 e->e1->op == TOKvar) 1940 { 1941 VarExp *ve = (VarExp *)e->e1; 1942 FuncDeclaration *f = ve->var->isFuncDeclaration(); 1943 if (f) 1944 { 1945 assert(f->isImportedSymbol()); 1946 f = f->overloadExactMatch(tb->nextOf()); 1947 if (f) 1948 { 1949 result = new VarExp(e->loc, f, false); 1950 result->type = f->type; 1951 result = new AddrExp(e->loc, result, t); 1952 return; 1953 } 1954 } 1955 } 1956 1957 if (FuncDeclaration *f = isFuncAddress(e)) 1958 { 1959 if (f->checkForwardRef(e->loc)) 1960 { 1961 result = new ErrorExp(); 1962 return; 1963 } 1964 } 1965 1966 visit((Expression *)e); 1967 } 1968 result->type = t; 1969 } 1970 1971 void visit(TupleExp *e) 1972 { 1973 if (e->type->equals(t)) 1974 { 1975 result = e; 1976 return; 1977 } 1978 1979 TupleExp *te = (TupleExp *)e->copy(); 1980 te->e0 = e->e0 ? e->e0->copy() : NULL; 1981 te->exps = (Expressions *)e->exps->copy(); 1982 for (size_t i = 0; i < te->exps->dim; i++) 1983 { 1984 Expression *ex = (*te->exps)[i]; 1985 ex = ex->castTo(sc, t); 1986 (*te->exps)[i] = ex; 1987 } 1988 result = te; 1989 1990 /* Questionable behavior: In here, result->type is not set to t. 1991 * Therefoe: 1992 * TypeTuple!(int, int) values; 1993 * auto values2 = cast(long)values; 1994 * // typeof(values2) == TypeTuple!(int, int) !! 1995 * 1996 * Only when the casted tuple is immediately expanded, it would work. 1997 * auto arr = [cast(long)values]; 1998 * // typeof(arr) == long[] 1999 */ 2000 } 2001 2002 void visit(ArrayLiteralExp *e) 2003 { 2004 if (e->type == t) 2005 { 2006 result = e; 2007 return; 2008 } 2009 ArrayLiteralExp *ae = e; 2010 Type *typeb = e->type->toBasetype(); 2011 Type *tb = t->toBasetype(); 2012 if ((tb->ty == Tarray || tb->ty == Tsarray) && 2013 (typeb->ty == Tarray || typeb->ty == Tsarray)) 2014 { 2015 if (tb->nextOf()->toBasetype()->ty == Tvoid && typeb->nextOf()->toBasetype()->ty != Tvoid) 2016 { 2017 // Don't do anything to cast non-void[] to void[] 2018 } 2019 else if (typeb->ty == Tsarray && typeb->nextOf()->toBasetype()->ty == Tvoid) 2020 { 2021 // Don't do anything for casting void[n] to others 2022 } 2023 else 2024 { 2025 if (tb->ty == Tsarray) 2026 { 2027 TypeSArray *tsa = (TypeSArray *)tb; 2028 if (e->elements->dim != tsa->dim->toInteger()) 2029 goto L1; 2030 } 2031 2032 ae = (ArrayLiteralExp *)e->copy(); 2033 if (e->basis) 2034 ae->basis = e->basis->castTo(sc, tb->nextOf()); 2035 ae->elements = e->elements->copy(); 2036 for (size_t i = 0; i < e->elements->dim; i++) 2037 { 2038 Expression *ex = (*e->elements)[i]; 2039 if (!ex) 2040 continue; 2041 ex = ex->castTo(sc, tb->nextOf()); 2042 (*ae->elements)[i] = ex; 2043 } 2044 ae->type = t; 2045 result = ae; 2046 return; 2047 } 2048 } 2049 else if (tb->ty == Tpointer && typeb->ty == Tsarray) 2050 { 2051 Type *tp = typeb->nextOf()->pointerTo(); 2052 if (!tp->equals(ae->type)) 2053 { 2054 ae = (ArrayLiteralExp *)e->copy(); 2055 ae->type = tp; 2056 } 2057 } 2058 else if (tb->ty == Tvector && 2059 (typeb->ty == Tarray || typeb->ty == Tsarray)) 2060 { 2061 // Convert array literal to vector type 2062 TypeVector *tv = (TypeVector *)tb; 2063 TypeSArray *tbase = (TypeSArray *)tv->basetype; 2064 assert(tbase->ty == Tsarray); 2065 const size_t edim = e->elements->dim; 2066 const size_t tbasedim = tbase->dim->toInteger(); 2067 if (edim > tbasedim) 2068 goto L1; 2069 2070 ae = (ArrayLiteralExp *)e->copy(); 2071 ae->type = tbase; // Bugzilla 12642 2072 ae->elements = e->elements->copy(); 2073 Type *telement = tv->elementType(); 2074 for (size_t i = 0; i < edim; i++) 2075 { 2076 Expression *ex = (*e->elements)[i]; 2077 ex = ex->castTo(sc, telement); 2078 (*ae->elements)[i] = ex; 2079 } 2080 // Fill in the rest with the default initializer 2081 ae->elements->setDim(tbasedim); 2082 for (size_t i = edim; i < tbasedim; i++) 2083 { 2084 Expression *ex = typeb->nextOf()->defaultInitLiteral(e->loc); 2085 ex = ex->castTo(sc, telement); 2086 (*ae->elements)[i] = ex; 2087 } 2088 Expression *ev = new VectorExp(e->loc, ae, tb); 2089 ev = ::semantic(ev, sc); 2090 result = ev; 2091 return; 2092 } 2093 L1: 2094 visit((Expression *)ae); 2095 } 2096 2097 void visit(AssocArrayLiteralExp *e) 2098 { 2099 if (e->type == t) 2100 { 2101 result = e; 2102 return; 2103 } 2104 Type *typeb = e->type->toBasetype(); 2105 Type *tb = t->toBasetype(); 2106 if (tb->ty == Taarray && typeb->ty == Taarray && 2107 tb->nextOf()->toBasetype()->ty != Tvoid) 2108 { 2109 AssocArrayLiteralExp *ae = (AssocArrayLiteralExp *)e->copy(); 2110 ae->keys = e->keys->copy(); 2111 ae->values = e->values->copy(); 2112 assert(e->keys->dim == e->values->dim); 2113 for (size_t i = 0; i < e->keys->dim; i++) 2114 { 2115 Expression *ex = (*e->values)[i]; 2116 ex = ex->castTo(sc, tb->nextOf()); 2117 (*ae->values)[i] = ex; 2118 2119 ex = (*e->keys)[i]; 2120 ex = ex->castTo(sc, ((TypeAArray *)tb)->index); 2121 (*ae->keys)[i] = ex; 2122 } 2123 ae->type = t; 2124 result = ae; 2125 return; 2126 } 2127 visit((Expression *)e); 2128 } 2129 2130 void visit(SymOffExp *e) 2131 { 2132 if (e->type == t && !e->hasOverloads) 2133 { 2134 result = e; 2135 return; 2136 } 2137 Type *tb = t->toBasetype(); 2138 Type *typeb = e->type->toBasetype(); 2139 2140 if (tb->equals(typeb)) 2141 { 2142 result = e->copy(); 2143 result->type = t; 2144 ((SymOffExp *)result)->hasOverloads = false; 2145 return; 2146 } 2147 2148 // Look for pointers to functions where the functions are overloaded. 2149 if (e->hasOverloads && 2150 typeb->ty == Tpointer && typeb->nextOf()->ty == Tfunction && 2151 (tb->ty == Tpointer || tb->ty == Tdelegate) && tb->nextOf()->ty == Tfunction) 2152 { 2153 FuncDeclaration *f = e->var->isFuncDeclaration(); 2154 f = f ? f->overloadExactMatch(tb->nextOf()) : NULL; 2155 if (f) 2156 { 2157 if (tb->ty == Tdelegate) 2158 { 2159 if (f->needThis() && hasThis(sc)) 2160 { 2161 result = new DelegateExp(e->loc, new ThisExp(e->loc), f, false); 2162 result = ::semantic(result, sc); 2163 } 2164 else if (f->isNested()) 2165 { 2166 result = new DelegateExp(e->loc, new IntegerExp(0), f, false); 2167 result = ::semantic(result, sc); 2168 } 2169 else if (f->needThis()) 2170 { 2171 e->error("no 'this' to create delegate for %s", f->toChars()); 2172 result = new ErrorExp(); 2173 return; 2174 } 2175 else 2176 { 2177 e->error("cannot cast from function pointer to delegate"); 2178 result = new ErrorExp(); 2179 return; 2180 } 2181 } 2182 else 2183 { 2184 result = new SymOffExp(e->loc, f, 0, false); 2185 result->type = t; 2186 } 2187 f->tookAddressOf++; 2188 return; 2189 } 2190 } 2191 2192 if (FuncDeclaration *f = isFuncAddress(e)) 2193 { 2194 if (f->checkForwardRef(e->loc)) 2195 { 2196 result = new ErrorExp(); 2197 return; 2198 } 2199 } 2200 2201 visit((Expression *)e); 2202 } 2203 2204 void visit(DelegateExp *e) 2205 { 2206 static const char msg[] = "cannot form delegate due to covariant return type"; 2207 2208 Type *tb = t->toBasetype(); 2209 Type *typeb = e->type->toBasetype(); 2210 if (!tb->equals(typeb) || e->hasOverloads) 2211 { 2212 // Look for delegates to functions where the functions are overloaded. 2213 if (typeb->ty == Tdelegate && 2214 tb->ty == Tdelegate) 2215 { 2216 if (e->func) 2217 { 2218 FuncDeclaration *f = e->func->overloadExactMatch(tb->nextOf()); 2219 if (f) 2220 { 2221 int offset; 2222 if (f->tintro && f->tintro->nextOf()->isBaseOf(f->type->nextOf(), &offset) && offset) 2223 e->error("%s", msg); 2224 if (f != e->func) // if address not already marked as taken 2225 f->tookAddressOf++; 2226 result = new DelegateExp(e->loc, e->e1, f, false); 2227 result->type = t; 2228 return; 2229 } 2230 if (e->func->tintro) 2231 e->error("%s", msg); 2232 } 2233 } 2234 2235 if (FuncDeclaration *f = isFuncAddress(e)) 2236 { 2237 if (f->checkForwardRef(e->loc)) 2238 { 2239 result = new ErrorExp(); 2240 return; 2241 } 2242 } 2243 2244 visit((Expression *)e); 2245 } 2246 else 2247 { 2248 int offset; 2249 e->func->tookAddressOf++; 2250 if (e->func->tintro && e->func->tintro->nextOf()->isBaseOf(e->func->type->nextOf(), &offset) && offset) 2251 e->error("%s", msg); 2252 result = e->copy(); 2253 result->type = t; 2254 } 2255 } 2256 2257 void visit(FuncExp *e) 2258 { 2259 //printf("FuncExp::castTo type = %s, t = %s\n", e->type->toChars(), t->toChars()); 2260 FuncExp *fe; 2261 if (e->matchType(t, sc, &fe, 1) > MATCHnomatch) 2262 { 2263 result = fe; 2264 return; 2265 } 2266 visit((Expression *)e); 2267 } 2268 2269 void visit(CondExp *e) 2270 { 2271 if (!e->type->equals(t)) 2272 { 2273 result = new CondExp(e->loc, e->econd, e->e1->castTo(sc, t), e->e2->castTo(sc, t)); 2274 result->type = t; 2275 return; 2276 } 2277 result = e; 2278 } 2279 2280 void visit(CommaExp *e) 2281 { 2282 Expression *e2c = e->e2->castTo(sc, t); 2283 2284 if (e2c != e->e2) 2285 { 2286 result = new CommaExp(e->loc, e->e1, e2c); 2287 result->type = e2c->type; 2288 } 2289 else 2290 { 2291 result = e; 2292 result->type = e->e2->type; 2293 } 2294 } 2295 2296 void visit(SliceExp *e) 2297 { 2298 //printf("SliceExp::castTo e = %s, type = %s, t = %s\n", e->toChars(), e->type->toChars(), t->toChars()); 2299 Type *typeb = e->type->toBasetype(); 2300 Type *tb = t->toBasetype(); 2301 if (e->type->equals(t) || typeb->ty != Tarray || 2302 (tb->ty != Tarray && tb->ty != Tsarray)) 2303 { 2304 visit((Expression *)e); 2305 return; 2306 } 2307 2308 if (tb->ty == Tarray) 2309 { 2310 if (typeb->nextOf()->equivalent(tb->nextOf())) 2311 { 2312 // T[] to const(T)[] 2313 result = e->copy(); 2314 result->type = t; 2315 } 2316 else 2317 { 2318 visit((Expression *)e); 2319 } 2320 return; 2321 } 2322 2323 // Handle the cast from Tarray to Tsarray with CT-known slicing 2324 2325 TypeSArray *tsa = (TypeSArray *)toStaticArrayType(e); 2326 if (tsa && tsa->size(e->loc) == tb->size(e->loc)) 2327 { 2328 /* Match if the sarray sizes are equal: 2329 * T[a .. b] to const(T)[b-a] 2330 * T[a .. b] to U[dim] if (T.sizeof*(b-a) == U.sizeof*dim) 2331 * 2332 * If a SliceExp has Tsarray, it will become lvalue. 2333 * That's handled in SliceExp::isLvalue and toLvalue 2334 */ 2335 result = e->copy(); 2336 result->type = t; 2337 return; 2338 } 2339 if (tsa && tsa->dim->equals(((TypeSArray *)tb)->dim)) 2340 { 2341 /* Match if the dimensions are equal 2342 * with the implicit conversion of e->e1: 2343 * cast(float[2]) [2.0, 1.0, 0.0][0..2]; 2344 */ 2345 Type *t1b = e->e1->type->toBasetype(); 2346 if (t1b->ty == Tsarray) 2347 t1b = tb->nextOf()->sarrayOf(((TypeSArray *)t1b)->dim->toInteger()); 2348 else if (t1b->ty == Tarray) 2349 t1b = tb->nextOf()->arrayOf(); 2350 else if (t1b->ty == Tpointer) 2351 t1b = tb->nextOf()->pointerTo(); 2352 else 2353 assert(0); 2354 if (e->e1->implicitConvTo(t1b) > MATCHnomatch) 2355 { 2356 Expression *e1x = e->e1->implicitCastTo(sc, t1b); 2357 assert(e1x->op != TOKerror); 2358 e = (SliceExp *)e->copy(); 2359 e->e1 = e1x; 2360 e->type = t; 2361 result = e; 2362 return; 2363 } 2364 } 2365 e->error("cannot cast expression %s of type %s to %s", 2366 e->toChars(), tsa ? tsa->toChars() : e->type->toChars(), 2367 t->toChars()); 2368 result = new ErrorExp(); 2369 } 2370 }; 2371 2372 CastTo v(sc, t); 2373 e->accept(&v); 2374 return v.result; 2375} 2376 2377/* ==================== inferType ====================== */ 2378 2379/**************************************** 2380 * Set type inference target 2381 * t Target type 2382 * flag 1: don't put an error when inference fails 2383 */ 2384 2385Expression *inferType(Expression *e, Type *t, int flag) 2386{ 2387 class InferType : public Visitor 2388 { 2389 public: 2390 Type *t; 2391 int flag; 2392 Expression *result; 2393 2394 InferType(Type *t, int flag) 2395 : t(t), flag(flag) 2396 { 2397 result = NULL; 2398 } 2399 2400 2401 void visit(Expression *e) 2402 { 2403 result = e; 2404 } 2405 2406 void visit(ArrayLiteralExp *ale) 2407 { 2408 Type *tb = t->toBasetype(); 2409 if (tb->ty == Tarray || tb->ty == Tsarray) 2410 { 2411 Type *tn = tb->nextOf(); 2412 if (ale->basis) 2413 ale->basis = inferType(ale->basis, tn, flag); 2414 for (size_t i = 0; i < ale->elements->dim; i++) 2415 { 2416 Expression *e = (*ale->elements)[i]; 2417 if (e) 2418 { 2419 e = inferType(e, tn, flag); 2420 (*ale->elements)[i] = e; 2421 } 2422 } 2423 } 2424 result = ale; 2425 } 2426 2427 void visit(AssocArrayLiteralExp *aale) 2428 { 2429 Type *tb = t->toBasetype(); 2430 if (tb->ty == Taarray) 2431 { 2432 TypeAArray *taa = (TypeAArray *)tb; 2433 Type *ti = taa->index; 2434 Type *tv = taa->nextOf(); 2435 for (size_t i = 0; i < aale->keys->dim; i++) 2436 { 2437 Expression *e = (*aale->keys)[i]; 2438 if (e) 2439 { 2440 e = inferType(e, ti, flag); 2441 (*aale->keys)[i] = e; 2442 } 2443 } 2444 for (size_t i = 0; i < aale->values->dim; i++) 2445 { 2446 Expression *e = (*aale->values)[i]; 2447 if (e) 2448 { 2449 e = inferType(e, tv, flag); 2450 (*aale->values)[i] = e; 2451 } 2452 } 2453 } 2454 result = aale; 2455 } 2456 2457 void visit(FuncExp *fe) 2458 { 2459 //printf("FuncExp::inferType('%s'), to=%s\n", fe->type ? fe->type->toChars() : "null", t->toChars()); 2460 if (t->ty == Tdelegate || 2461 (t->ty == Tpointer && t->nextOf()->ty == Tfunction)) 2462 { 2463 fe->fd->treq = t; 2464 } 2465 result = fe; 2466 } 2467 2468 void visit(CondExp *ce) 2469 { 2470 Type *tb = t->toBasetype(); 2471 ce->e1 = inferType(ce->e1, tb, flag); 2472 ce->e2 = inferType(ce->e2, tb, flag); 2473 result = ce; 2474 } 2475 }; 2476 2477 if (!t) 2478 return e; 2479 2480 InferType v(t, flag); 2481 e->accept(&v); 2482 return v.result; 2483} 2484 2485/* ==================== ====================== */ 2486 2487/**************************************** 2488 * Scale addition/subtraction to/from pointer. 2489 */ 2490 2491Expression *scaleFactor(BinExp *be, Scope *sc) 2492{ 2493 Type *t1b = be->e1->type->toBasetype(); 2494 Type *t2b = be->e2->type->toBasetype(); 2495 Expression *eoff; 2496 2497 if (t1b->ty == Tpointer && t2b->isintegral()) 2498 { 2499 // Need to adjust operator by the stride 2500 // Replace (ptr + int) with (ptr + (int * stride)) 2501 Type *t = Type::tptrdiff_t; 2502 2503 d_uns64 stride = t1b->nextOf()->size(be->loc); 2504 if (!t->equals(t2b)) 2505 be->e2 = be->e2->castTo(sc, t); 2506 eoff = be->e2; 2507 be->e2 = new MulExp(be->loc, be->e2, new IntegerExp(Loc(), stride, t)); 2508 be->e2->type = t; 2509 be->type = be->e1->type; 2510 } 2511 else if (t2b->ty == Tpointer && t1b->isintegral()) 2512 { 2513 // Need to adjust operator by the stride 2514 // Replace (int + ptr) with (ptr + (int * stride)) 2515 Type *t = Type::tptrdiff_t; 2516 Expression *e; 2517 2518 d_uns64 stride = t2b->nextOf()->size(be->loc); 2519 if (!t->equals(t1b)) 2520 e = be->e1->castTo(sc, t); 2521 else 2522 e = be->e1; 2523 eoff = e; 2524 e = new MulExp(be->loc, e, new IntegerExp(Loc(), stride, t)); 2525 e->type = t; 2526 be->type = be->e2->type; 2527 be->e1 = be->e2; 2528 be->e2 = e; 2529 } 2530 else 2531 assert(0); 2532 2533 if (sc->func && !sc->intypeof) 2534 { 2535 eoff = eoff->optimize(WANTvalue); 2536 if (eoff->op == TOKint64 && eoff->toInteger() == 0) 2537 ; 2538 else if (sc->func->setUnsafe()) 2539 { 2540 be->error("pointer arithmetic not allowed in @safe functions"); 2541 return new ErrorExp(); 2542 } 2543 } 2544 2545 return be; 2546} 2547 2548/************************************** 2549 * Return true if e is an empty array literal with dimensionality 2550 * equal to or less than type of other array. 2551 * [], [[]], [[[]]], etc. 2552 * I.e., make sure that [1,2] is compatible with [], 2553 * [[1,2]] is compatible with [[]], etc. 2554 */ 2555bool isVoidArrayLiteral(Expression *e, Type *other) 2556{ 2557 while (e->op == TOKarrayliteral && e->type->ty == Tarray 2558 && (((ArrayLiteralExp *)e)->elements->dim == 1)) 2559 { 2560 ArrayLiteralExp *ale = (ArrayLiteralExp *)e; 2561 e = ale->getElement(0); 2562 if (other->ty == Tsarray || other->ty == Tarray) 2563 other = other->nextOf(); 2564 else 2565 return false; 2566 } 2567 if (other->ty != Tsarray && other->ty != Tarray) 2568 return false; 2569 Type *t = e->type; 2570 return (e->op == TOKarrayliteral && t->ty == Tarray && 2571 t->nextOf()->ty == Tvoid && 2572 ((ArrayLiteralExp *)e)->elements->dim == 0); 2573} 2574 2575// used by deduceType() 2576Type *rawTypeMerge(Type *t1, Type *t2) 2577{ 2578 if (t1->equals(t2)) 2579 return t1; 2580 if (t1->equivalent(t2)) 2581 return t1->castMod(MODmerge(t1->mod, t2->mod)); 2582 2583 Type *t1b = t1->toBasetype(); 2584 Type *t2b = t2->toBasetype(); 2585 if (t1b->equals(t2b)) 2586 return t1b; 2587 if (t1b->equivalent(t2b)) 2588 return t1b->castMod(MODmerge(t1b->mod, t2b->mod)); 2589 2590 TY ty = (TY)impcnvResult[t1b->ty][t2b->ty]; 2591 if (ty != Terror) 2592 return Type::basic[ty]; 2593 2594 return NULL; 2595} 2596 2597/************************************** 2598 * Combine types. 2599 * Output: 2600 * *pt merged type, if *pt is not NULL 2601 * *pe1 rewritten e1 2602 * *pe2 rewritten e2 2603 * Returns: 2604 * true success 2605 * false failed 2606 */ 2607 2608bool typeMerge(Scope *sc, TOK op, Type **pt, Expression **pe1, Expression **pe2) 2609{ 2610 //printf("typeMerge() %s op %s\n", (*pe1)->toChars(), (*pe2)->toChars()); 2611 2612 MATCH m; 2613 Expression *e1 = *pe1; 2614 Expression *e2 = *pe2; 2615 Type *t1b = e1->type->toBasetype(); 2616 Type *t2b = e2->type->toBasetype(); 2617 2618 if (op != TOKquestion || 2619 (t1b->ty != t2b->ty && (t1b->isTypeBasic() && t2b->isTypeBasic()))) 2620 { 2621 e1 = integralPromotions(e1, sc); 2622 e2 = integralPromotions(e2, sc); 2623 } 2624 2625 Type *t1 = e1->type; 2626 Type *t2 = e2->type; 2627 assert(t1); 2628 Type *t = t1; 2629 2630 /* The start type of alias this type recursion. 2631 * In following case, we should save A, and stop recursion 2632 * if it appears again. 2633 * X -> Y -> [A] -> B -> A -> B -> ... 2634 */ 2635 Type *att1 = NULL; 2636 Type *att2 = NULL; 2637 2638 //if (t1) printf("\tt1 = %s\n", t1->toChars()); 2639 //if (t2) printf("\tt2 = %s\n", t2->toChars()); 2640 assert(t2); 2641 2642 if (t1->mod != t2->mod && 2643 t1->ty == Tenum && t2->ty == Tenum && 2644 ((TypeEnum *)t1)->sym == ((TypeEnum *)t2)->sym) 2645 { 2646 unsigned char mod = MODmerge(t1->mod, t2->mod); 2647 t1 = t1->castMod(mod); 2648 t2 = t2->castMod(mod); 2649 } 2650 2651Lagain: 2652 t1b = t1->toBasetype(); 2653 t2b = t2->toBasetype(); 2654 2655 TY ty = (TY)impcnvResult[t1b->ty][t2b->ty]; 2656 if (ty != Terror) 2657 { 2658 TY ty1 = (TY)impcnvType1[t1b->ty][t2b->ty]; 2659 TY ty2 = (TY)impcnvType2[t1b->ty][t2b->ty]; 2660 2661 if (t1b->ty == ty1) // if no promotions 2662 { 2663 if (t1->equals(t2)) 2664 { 2665 t = t1; 2666 goto Lret; 2667 } 2668 2669 if (t1b->equals(t2b)) 2670 { 2671 t = t1b; 2672 goto Lret; 2673 } 2674 } 2675 2676 t = Type::basic[ty]; 2677 2678 t1 = Type::basic[ty1]; 2679 t2 = Type::basic[ty2]; 2680 e1 = e1->castTo(sc, t1); 2681 e2 = e2->castTo(sc, t2); 2682 //printf("after typeCombine():\n"); 2683 //print(); 2684 //printf("ty = %d, ty1 = %d, ty2 = %d\n", ty, ty1, ty2); 2685 goto Lret; 2686 } 2687 2688 t1 = t1b; 2689 t2 = t2b; 2690 2691 if (t1->ty == Ttuple || t2->ty == Ttuple) 2692 goto Lincompatible; 2693 2694 if (t1->equals(t2)) 2695 { 2696 // merging can not result in new enum type 2697 if (t->ty == Tenum) 2698 t = t1b; 2699 } 2700 else if ((t1->ty == Tpointer && t2->ty == Tpointer) || 2701 (t1->ty == Tdelegate && t2->ty == Tdelegate)) 2702 { 2703 // Bring pointers to compatible type 2704 Type *t1n = t1->nextOf(); 2705 Type *t2n = t2->nextOf(); 2706 2707 if (t1n->equals(t2n)) 2708 ; 2709 else if (t1n->ty == Tvoid) // pointers to void are always compatible 2710 t = t2; 2711 else if (t2n->ty == Tvoid) 2712 ; 2713 else if (t1->implicitConvTo(t2)) 2714 { 2715 goto Lt2; 2716 } 2717 else if (t2->implicitConvTo(t1)) 2718 { 2719 goto Lt1; 2720 } 2721 else if (t1n->ty == Tfunction && t2n->ty == Tfunction) 2722 { 2723 TypeFunction *tf1 = (TypeFunction *)t1n; 2724 TypeFunction *tf2 = (TypeFunction *)t2n; 2725 tf1->purityLevel(); 2726 tf2->purityLevel(); 2727 2728 TypeFunction *d = (TypeFunction *)tf1->syntaxCopy(); 2729 2730 if (tf1->purity != tf2->purity) 2731 d->purity = PUREimpure; 2732 assert(d->purity != PUREfwdref); 2733 2734 d->isnothrow = (tf1->isnothrow && tf2->isnothrow); 2735 d->isnogc = (tf1->isnogc && tf2->isnogc); 2736 2737 if (tf1->trust == tf2->trust) 2738 d->trust = tf1->trust; 2739 else if (tf1->trust <= TRUSTsystem || tf2->trust <= TRUSTsystem) 2740 d->trust = TRUSTsystem; 2741 else 2742 d->trust = TRUSTtrusted; 2743 2744 Type *tx = NULL; 2745 if (t1->ty == Tdelegate) 2746 { 2747 tx = new TypeDelegate(d); 2748 } 2749 else 2750 tx = d->pointerTo(); 2751 2752 tx = tx->semantic(e1->loc, sc); 2753 2754 if (t1->implicitConvTo(tx) && t2->implicitConvTo(tx)) 2755 { 2756 t = tx; 2757 e1 = e1->castTo(sc, t); 2758 e2 = e2->castTo(sc, t); 2759 goto Lret; 2760 } 2761 goto Lincompatible; 2762 } 2763 else if (t1n->mod != t2n->mod) 2764 { 2765 if (!t1n->isImmutable() && !t2n->isImmutable() && t1n->isShared() != t2n->isShared()) 2766 goto Lincompatible; 2767 unsigned char mod = MODmerge(t1n->mod, t2n->mod); 2768 t1 = t1n->castMod(mod)->pointerTo(); 2769 t2 = t2n->castMod(mod)->pointerTo(); 2770 t = t1; 2771 goto Lagain; 2772 } 2773 else if (t1n->ty == Tclass && t2n->ty == Tclass) 2774 { 2775 ClassDeclaration *cd1 = t1n->isClassHandle(); 2776 ClassDeclaration *cd2 = t2n->isClassHandle(); 2777 int offset; 2778 2779 if (cd1->isBaseOf(cd2, &offset)) 2780 { 2781 if (offset) 2782 e2 = e2->castTo(sc, t); 2783 } 2784 else if (cd2->isBaseOf(cd1, &offset)) 2785 { 2786 t = t2; 2787 if (offset) 2788 e1 = e1->castTo(sc, t); 2789 } 2790 else 2791 goto Lincompatible; 2792 } 2793 else 2794 { 2795 t1 = t1n->constOf()->pointerTo(); 2796 t2 = t2n->constOf()->pointerTo(); 2797 if (t1->implicitConvTo(t2)) 2798 { 2799 goto Lt2; 2800 } 2801 else if (t2->implicitConvTo(t1)) 2802 { 2803 goto Lt1; 2804 } 2805 goto Lincompatible; 2806 } 2807 } 2808 else if ((t1->ty == Tsarray || t1->ty == Tarray) && 2809 ((e2->op == TOKnull && t2->ty == Tpointer && t2->nextOf()->ty == Tvoid) || 2810 (e2->op == TOKarrayliteral && t2->ty == Tsarray && t2->nextOf()->ty == Tvoid && ((TypeSArray *)t2)->dim->toInteger() == 0) || 2811 (isVoidArrayLiteral(e2, t1))) 2812 ) 2813 { 2814 /* (T[n] op void*) => T[] 2815 * (T[] op void*) => T[] 2816 * (T[n] op void[0]) => T[] 2817 * (T[] op void[0]) => T[] 2818 * (T[n] op void[]) => T[] 2819 * (T[] op void[]) => T[] 2820 */ 2821 goto Lx1; 2822 } 2823 else if ((t2->ty == Tsarray || t2->ty == Tarray) && 2824 ((e1->op == TOKnull && t1->ty == Tpointer && t1->nextOf()->ty == Tvoid) || 2825 (e1->op == TOKarrayliteral && t1->ty == Tsarray && t1->nextOf()->ty == Tvoid && ((TypeSArray *)t1)->dim->toInteger() == 0) || 2826 (isVoidArrayLiteral(e1, t2))) 2827 ) 2828 { 2829 /* (void* op T[n]) => T[] 2830 * (void* op T[]) => T[] 2831 * (void[0] op T[n]) => T[] 2832 * (void[0] op T[]) => T[] 2833 * (void[] op T[n]) => T[] 2834 * (void[] op T[]) => T[] 2835 */ 2836 goto Lx2; 2837 } 2838 else if ((t1->ty == Tsarray || t1->ty == Tarray) && 2839 (m = t1->implicitConvTo(t2)) != MATCHnomatch) 2840 { 2841 // Bugzilla 7285: Tsarray op [x, y, ...] should to be Tsarray 2842 // Bugzilla 14737: Tsarray ~ [x, y, ...] should to be Tarray 2843 if (t1->ty == Tsarray && e2->op == TOKarrayliteral && op != TOKcat) 2844 goto Lt1; 2845 if (m == MATCHconst && 2846 (op == TOKaddass || op == TOKminass || op == TOKmulass || 2847 op == TOKdivass || op == TOKmodass || op == TOKpowass || 2848 op == TOKandass || op == TOKorass || op == TOKxorass) 2849 ) 2850 { 2851 // Don't make the lvalue const 2852 t = t2; 2853 goto Lret; 2854 } 2855 goto Lt2; 2856 } 2857 else if ((t2->ty == Tsarray || t2->ty == Tarray) && t2->implicitConvTo(t1)) 2858 { 2859 // Bugzilla 7285 & 14737 2860 if (t2->ty == Tsarray && e1->op == TOKarrayliteral && op != TOKcat) 2861 goto Lt2; 2862 goto Lt1; 2863 } 2864 else if ((t1->ty == Tsarray || t1->ty == Tarray || t1->ty == Tpointer) && 2865 (t2->ty == Tsarray || t2->ty == Tarray || t2->ty == Tpointer) && 2866 t1->nextOf()->mod != t2->nextOf()->mod 2867 ) 2868 { 2869 /* If one is mutable and the other invariant, then retry 2870 * with both of them as const 2871 */ 2872 Type *t1n = t1->nextOf(); 2873 Type *t2n = t2->nextOf(); 2874 unsigned char mod; 2875 if (e1->op == TOKnull && e2->op != TOKnull) 2876 mod = t2n->mod; 2877 else if (e1->op != TOKnull && e2->op == TOKnull) 2878 mod = t1n->mod; 2879 else if (!t1n->isImmutable() && !t2n->isImmutable() && t1n->isShared() != t2n->isShared()) 2880 goto Lincompatible; 2881 else 2882 mod = MODmerge(t1n->mod, t2n->mod); 2883 2884 if (t1->ty == Tpointer) 2885 t1 = t1n->castMod(mod)->pointerTo(); 2886 else 2887 t1 = t1n->castMod(mod)->arrayOf(); 2888 2889 if (t2->ty == Tpointer) 2890 t2 = t2n->castMod(mod)->pointerTo(); 2891 else 2892 t2 = t2n->castMod(mod)->arrayOf(); 2893 t = t1; 2894 goto Lagain; 2895 } 2896 else if (t1->ty == Tclass && t2->ty == Tclass) 2897 { 2898 if (t1->mod != t2->mod) 2899 { 2900 unsigned char mod; 2901 if (e1->op == TOKnull && e2->op != TOKnull) 2902 mod = t2->mod; 2903 else if (e1->op != TOKnull && e2->op == TOKnull) 2904 mod = t1->mod; 2905 else if (!t1->isImmutable() && !t2->isImmutable() && t1->isShared() != t2->isShared()) 2906 goto Lincompatible; 2907 else 2908 mod = MODmerge(t1->mod, t2->mod); 2909 t1 = t1->castMod(mod); 2910 t2 = t2->castMod(mod); 2911 t = t1; 2912 goto Lagain; 2913 } 2914 goto Lcc; 2915 } 2916 else if (t1->ty == Tclass || t2->ty == Tclass) 2917 { 2918Lcc: 2919 while (1) 2920 { 2921 MATCH i1 = e2->implicitConvTo(t1); 2922 MATCH i2 = e1->implicitConvTo(t2); 2923 2924 if (i1 && i2) 2925 { 2926 // We have the case of class vs. void*, so pick class 2927 if (t1->ty == Tpointer) 2928 i1 = MATCHnomatch; 2929 else if (t2->ty == Tpointer) 2930 i2 = MATCHnomatch; 2931 } 2932 2933 if (i2) 2934 { 2935 e2 = e2->castTo(sc, t2); 2936 goto Lt2; 2937 } 2938 else if (i1) 2939 { 2940 e1 = e1->castTo(sc, t1); 2941 goto Lt1; 2942 } 2943 else if (t1->ty == Tclass && t2->ty == Tclass) 2944 { 2945 TypeClass *tc1 = (TypeClass *)t1; 2946 TypeClass *tc2 = (TypeClass *)t2; 2947 2948 /* Pick 'tightest' type 2949 */ 2950 ClassDeclaration *cd1 = tc1->sym->baseClass; 2951 ClassDeclaration *cd2 = tc2->sym->baseClass; 2952 2953 if (cd1 && cd2) 2954 { 2955 t1 = cd1->type->castMod(t1->mod); 2956 t2 = cd2->type->castMod(t2->mod); 2957 } 2958 else if (cd1) 2959 t1 = cd1->type; 2960 else if (cd2) 2961 t2 = cd2->type; 2962 else 2963 goto Lincompatible; 2964 } 2965 else if (t1->ty == Tstruct && ((TypeStruct *)t1)->sym->aliasthis) 2966 { 2967 if (att1 && e1->type == att1) 2968 goto Lincompatible; 2969 if (!att1 && e1->type->checkAliasThisRec()) 2970 att1 = e1->type; 2971 //printf("att tmerge(c || c) e1 = %s\n", e1->type->toChars()); 2972 e1 = resolveAliasThis(sc, e1); 2973 t1 = e1->type; 2974 continue; 2975 } 2976 else if (t2->ty == Tstruct && ((TypeStruct *)t2)->sym->aliasthis) 2977 { 2978 if (att2 && e2->type == att2) 2979 goto Lincompatible; 2980 if (!att2 && e2->type->checkAliasThisRec()) 2981 att2 = e2->type; 2982 //printf("att tmerge(c || c) e2 = %s\n", e2->type->toChars()); 2983 e2 = resolveAliasThis(sc, e2); 2984 t2 = e2->type; 2985 continue; 2986 } 2987 else 2988 goto Lincompatible; 2989 } 2990 } 2991 else if (t1->ty == Tstruct && t2->ty == Tstruct) 2992 { 2993 if (t1->mod != t2->mod) 2994 { 2995 if (!t1->isImmutable() && !t2->isImmutable() && t1->isShared() != t2->isShared()) 2996 goto Lincompatible; 2997 unsigned char mod = MODmerge(t1->mod, t2->mod); 2998 t1 = t1->castMod(mod); 2999 t2 = t2->castMod(mod); 3000 t = t1; 3001 goto Lagain; 3002 } 3003 3004 TypeStruct *ts1 = (TypeStruct *)t1; 3005 TypeStruct *ts2 = (TypeStruct *)t2; 3006 if (ts1->sym != ts2->sym) 3007 { 3008 if (!ts1->sym->aliasthis && !ts2->sym->aliasthis) 3009 goto Lincompatible; 3010 3011 MATCH i1 = MATCHnomatch; 3012 MATCH i2 = MATCHnomatch; 3013 3014 Expression *e1b = NULL; 3015 Expression *e2b = NULL; 3016 if (ts2->sym->aliasthis) 3017 { 3018 if (att2 && e2->type == att2) 3019 goto Lincompatible; 3020 if (!att2 && e2->type->checkAliasThisRec()) 3021 att2 = e2->type; 3022 //printf("att tmerge(s && s) e2 = %s\n", e2->type->toChars()); 3023 e2b = resolveAliasThis(sc, e2); 3024 i1 = e2b->implicitConvTo(t1); 3025 } 3026 if (ts1->sym->aliasthis) 3027 { 3028 if (att1 && e1->type == att1) 3029 goto Lincompatible; 3030 if (!att1 && e1->type->checkAliasThisRec()) 3031 att1 = e1->type; 3032 //printf("att tmerge(s && s) e1 = %s\n", e1->type->toChars()); 3033 e1b = resolveAliasThis(sc, e1); 3034 i2 = e1b->implicitConvTo(t2); 3035 } 3036 if (i1 && i2) 3037 goto Lincompatible; 3038 3039 if (i1) 3040 goto Lt1; 3041 else if (i2) 3042 goto Lt2; 3043 3044 if (e1b) 3045 { 3046 e1 = e1b; 3047 t1 = e1b->type->toBasetype(); 3048 } 3049 if (e2b) 3050 { 3051 e2 = e2b; 3052 t2 = e2b->type->toBasetype(); 3053 } 3054 t = t1; 3055 goto Lagain; 3056 } 3057 } 3058 else if (t1->ty == Tstruct || t2->ty == Tstruct) 3059 { 3060 if (t1->ty == Tstruct && ((TypeStruct *)t1)->sym->aliasthis) 3061 { 3062 if (att1 && e1->type == att1) 3063 goto Lincompatible; 3064 if (!att1 && e1->type->checkAliasThisRec()) 3065 att1 = e1->type; 3066 //printf("att tmerge(s || s) e1 = %s\n", e1->type->toChars()); 3067 e1 = resolveAliasThis(sc, e1); 3068 t1 = e1->type; 3069 t = t1; 3070 goto Lagain; 3071 } 3072 if (t2->ty == Tstruct && ((TypeStruct *)t2)->sym->aliasthis) 3073 { 3074 if (att2 && e2->type == att2) 3075 goto Lincompatible; 3076 if (!att2 && e2->type->checkAliasThisRec()) 3077 att2 = e2->type; 3078 //printf("att tmerge(s || s) e2 = %s\n", e2->type->toChars()); 3079 e2 = resolveAliasThis(sc, e2); 3080 t2 = e2->type; 3081 t = t2; 3082 goto Lagain; 3083 } 3084 goto Lincompatible; 3085 } 3086 else if ((e1->op == TOKstring || e1->op == TOKnull) && e1->implicitConvTo(t2)) 3087 { 3088 goto Lt2; 3089 } 3090 else if ((e2->op == TOKstring || e2->op == TOKnull) && e2->implicitConvTo(t1)) 3091 { 3092 goto Lt1; 3093 } 3094 else if (t1->ty == Tsarray && t2->ty == Tsarray && 3095 e2->implicitConvTo(t1->nextOf()->arrayOf())) 3096 { 3097 Lx1: 3098 t = t1->nextOf()->arrayOf(); // T[] 3099 e1 = e1->castTo(sc, t); 3100 e2 = e2->castTo(sc, t); 3101 } 3102 else if (t1->ty == Tsarray && t2->ty == Tsarray && 3103 e1->implicitConvTo(t2->nextOf()->arrayOf())) 3104 { 3105 Lx2: 3106 t = t2->nextOf()->arrayOf(); 3107 e1 = e1->castTo(sc, t); 3108 e2 = e2->castTo(sc, t); 3109 } 3110 else if (t1->ty == Tvector && t2->ty == Tvector) 3111 { 3112 // Bugzilla 13841, all vector types should have no common types between 3113 // different vectors, even though their sizes are same. 3114 TypeVector *tv1 = (TypeVector *)t1; 3115 TypeVector *tv2 = (TypeVector *)t2; 3116 if (!tv1->basetype->equals(tv2->basetype)) 3117 goto Lincompatible; 3118 3119 goto LmodCompare; 3120 } 3121 else if (t1->ty == Tvector && t2->ty != Tvector && 3122 e2->implicitConvTo(t1)) 3123 { 3124 e2 = e2->castTo(sc, t1); 3125 t2 = t1; 3126 t = t1; 3127 goto Lagain; 3128 } 3129 else if (t2->ty == Tvector && t1->ty != Tvector && 3130 e1->implicitConvTo(t2)) 3131 { 3132 e1 = e1->castTo(sc, t2); 3133 t1 = t2; 3134 t = t1; 3135 goto Lagain; 3136 } 3137 else if (t1->isintegral() && t2->isintegral()) 3138 { 3139 if (t1->ty != t2->ty) 3140 { 3141 if (t1->ty == Tvector || t2->ty == Tvector) 3142 goto Lincompatible; 3143 e1 = integralPromotions(e1, sc); 3144 e2 = integralPromotions(e2, sc); 3145 t1 = e1->type; 3146 t2 = e2->type; 3147 goto Lagain; 3148 } 3149 assert(t1->ty == t2->ty); 3150LmodCompare: 3151 if (!t1->isImmutable() && !t2->isImmutable() && t1->isShared() != t2->isShared()) 3152 goto Lincompatible; 3153 unsigned char mod = MODmerge(t1->mod, t2->mod); 3154 3155 t1 = t1->castMod(mod); 3156 t2 = t2->castMod(mod); 3157 t = t1; 3158 e1 = e1->castTo(sc, t); 3159 e2 = e2->castTo(sc, t); 3160 goto Lagain; 3161 } 3162 else if (t1->ty == Tnull && t2->ty == Tnull) 3163 { 3164 unsigned char mod = MODmerge(t1->mod, t2->mod); 3165 3166 t = t1->castMod(mod); 3167 e1 = e1->castTo(sc, t); 3168 e2 = e2->castTo(sc, t); 3169 goto Lret; 3170 } 3171 else if (t2->ty == Tnull && 3172 (t1->ty == Tpointer || t1->ty == Taarray || t1->ty == Tarray)) 3173 { 3174 goto Lt1; 3175 } 3176 else if (t1->ty == Tnull && 3177 (t2->ty == Tpointer || t2->ty == Taarray || t2->ty == Tarray)) 3178 { 3179 goto Lt2; 3180 } 3181 else if (t1->ty == Tarray && isBinArrayOp(op) && isArrayOpOperand(e1)) 3182 { 3183 if (e2->implicitConvTo(t1->nextOf())) 3184 { 3185 // T[] op T 3186 // T[] op cast(T)U 3187 e2 = e2->castTo(sc, t1->nextOf()); 3188 t = t1->nextOf()->arrayOf(); 3189 } 3190 else if (t1->nextOf()->implicitConvTo(e2->type)) 3191 { 3192 // (cast(T)U)[] op T (Bugzilla 12780) 3193 // e1 is left as U[], it will be handled in arrayOp() later. 3194 t = e2->type->arrayOf(); 3195 } 3196 else if (t2->ty == Tarray && isArrayOpOperand(e2)) 3197 { 3198 if (t1->nextOf()->implicitConvTo(t2->nextOf())) 3199 { 3200 // (cast(T)U)[] op T[] (Bugzilla 12780) 3201 // e1 is left as U[], it will be handled in arrayOp() later. 3202 t = t2->nextOf()->arrayOf(); 3203 } 3204 else if (t2->nextOf()->implicitConvTo(t1->nextOf())) 3205 { 3206 // T[] op (cast(T)U)[] (Bugzilla 12780) 3207 // e2 is left as U[], it will be handled in arrayOp() later. 3208 t = t1->nextOf()->arrayOf(); 3209 } 3210 else 3211 goto Lincompatible; 3212 } 3213 else 3214 goto Lincompatible; 3215 } 3216 else if (t2->ty == Tarray && isBinArrayOp(op) && isArrayOpOperand(e2)) 3217 { 3218 if (e1->implicitConvTo(t2->nextOf())) 3219 { 3220 // T op T[] 3221 // cast(T)U op T[] 3222 e1 = e1->castTo(sc, t2->nextOf()); 3223 t = t2->nextOf()->arrayOf(); 3224 } 3225 else if (t2->nextOf()->implicitConvTo(e1->type)) 3226 { 3227 // T op (cast(T)U)[] (Bugzilla 12780) 3228 // e2 is left as U[], it will be handled in arrayOp() later. 3229 t = e1->type->arrayOf(); 3230 } 3231 else 3232 goto Lincompatible; 3233 3234 //printf("test %s\n", Token::toChars(op)); 3235 e1 = e1->optimize(WANTvalue); 3236 if (isCommutative(op) && e1->isConst()) 3237 { 3238 /* Swap operands to minimize number of functions generated 3239 */ 3240 //printf("swap %s\n", Token::toChars(op)); 3241 Expression *tmp = e1; 3242 e1 = e2; 3243 e2 = tmp; 3244 } 3245 } 3246 else 3247 { 3248 Lincompatible: 3249 return false; 3250 } 3251Lret: 3252 if (!*pt) 3253 *pt = t; 3254 *pe1 = e1; 3255 *pe2 = e2; 3256 //print(); 3257 return true; 3258 3259 3260Lt1: 3261 e2 = e2->castTo(sc, t1); 3262 t = t1; 3263 goto Lret; 3264 3265Lt2: 3266 e1 = e1->castTo(sc, t2); 3267 t = t2; 3268 goto Lret; 3269} 3270 3271/************************************ 3272 * Bring leaves to common type. 3273 * Returns ErrorExp if error occurs. otherwise returns NULL. 3274 */ 3275 3276Expression *typeCombine(BinExp *be, Scope *sc) 3277{ 3278 Type *t1 = be->e1->type->toBasetype(); 3279 Type *t2 = be->e2->type->toBasetype(); 3280 3281 if (be->op == TOKmin || be->op == TOKadd) 3282 { 3283 // struct+struct, and class+class are errors 3284 if (t1->ty == Tstruct && t2->ty == Tstruct) 3285 goto Lerror; 3286 else if (t1->ty == Tclass && t2->ty == Tclass) 3287 goto Lerror; 3288 else if (t1->ty == Taarray && t2->ty == Taarray) 3289 goto Lerror; 3290 } 3291 3292 if (!typeMerge(sc, be->op, &be->type, &be->e1, &be->e2)) 3293 goto Lerror; 3294 // If the types have no value, return an error 3295 if (be->e1->op == TOKerror) 3296 return be->e1; 3297 if (be->e2->op == TOKerror) 3298 return be->e2; 3299 return NULL; 3300 3301Lerror: 3302 Expression *ex = be->incompatibleTypes(); 3303 if (ex->op == TOKerror) 3304 return ex; 3305 return new ErrorExp(); 3306} 3307 3308/*********************************** 3309 * Do integral promotions (convertchk). 3310 * Don't convert <array of> to <pointer to> 3311 */ 3312 3313Expression *integralPromotions(Expression *e, Scope *sc) 3314{ 3315 //printf("integralPromotions %s %s\n", e->toChars(), e->type->toChars()); 3316 switch (e->type->toBasetype()->ty) 3317 { 3318 case Tvoid: 3319 e->error("void has no value"); 3320 return new ErrorExp(); 3321 3322 case Tint8: 3323 case Tuns8: 3324 case Tint16: 3325 case Tuns16: 3326 case Tbool: 3327 case Tchar: 3328 case Twchar: 3329 e = e->castTo(sc, Type::tint32); 3330 break; 3331 3332 case Tdchar: 3333 e = e->castTo(sc, Type::tuns32); 3334 break; 3335 default: 3336 break; 3337 } 3338 return e; 3339} 3340 3341/*********************************** 3342 * See if both types are arrays that can be compared 3343 * for equality. Return true if so. 3344 * If they are arrays, but incompatible, issue error. 3345 * This is to enable comparing things like an immutable 3346 * array with a mutable one. 3347 */ 3348 3349bool arrayTypeCompatible(Loc loc, Type *t1, Type *t2) 3350{ 3351 t1 = t1->toBasetype()->merge2(); 3352 t2 = t2->toBasetype()->merge2(); 3353 3354 if ((t1->ty == Tarray || t1->ty == Tsarray || t1->ty == Tpointer) && 3355 (t2->ty == Tarray || t2->ty == Tsarray || t2->ty == Tpointer)) 3356 { 3357 if (t1->nextOf()->implicitConvTo(t2->nextOf()) < MATCHconst && 3358 t2->nextOf()->implicitConvTo(t1->nextOf()) < MATCHconst && 3359 (t1->nextOf()->ty != Tvoid && t2->nextOf()->ty != Tvoid)) 3360 { 3361 error(loc, "array equality comparison type mismatch, %s vs %s", t1->toChars(), t2->toChars()); 3362 } 3363 return true; 3364 } 3365 return false; 3366} 3367 3368/*********************************** 3369 * See if both types are arrays that can be compared 3370 * for equality without any casting. Return true if so. 3371 * This is to enable comparing things like an immutable 3372 * array with a mutable one. 3373 */ 3374bool arrayTypeCompatibleWithoutCasting(Type *t1, Type *t2) 3375{ 3376 t1 = t1->toBasetype(); 3377 t2 = t2->toBasetype(); 3378 3379 if ((t1->ty == Tarray || t1->ty == Tsarray || t1->ty == Tpointer) && 3380 t2->ty == t1->ty) 3381 { 3382 if (t1->nextOf()->implicitConvTo(t2->nextOf()) >= MATCHconst || 3383 t2->nextOf()->implicitConvTo(t1->nextOf()) >= MATCHconst) 3384 return true; 3385 } 3386 return false; 3387} 3388 3389/******************************************************************/ 3390 3391/* Determine the integral ranges of an expression. 3392 * This is used to determine if implicit narrowing conversions will 3393 * be allowed. 3394 */ 3395 3396IntRange getIntRange(Expression *e) 3397{ 3398 class IntRangeVisitor : public Visitor 3399 { 3400 public: 3401 IntRange range; 3402 3403 void visit(Expression *e) 3404 { 3405 range = IntRange::fromType(e->type); 3406 } 3407 3408 void visit(IntegerExp *e) 3409 { 3410 range = IntRange(SignExtendedNumber(e->getInteger())).cast(e->type); 3411 } 3412 3413 void visit(CastExp *e) 3414 { 3415 range = getIntRange(e->e1).cast(e->type); 3416 } 3417 3418 void visit(AddExp *e) 3419 { 3420 IntRange ir1 = getIntRange(e->e1); 3421 IntRange ir2 = getIntRange(e->e2); 3422 range = (ir1 + ir2).cast(e->type); 3423 } 3424 3425 void visit(MinExp *e) 3426 { 3427 IntRange ir1 = getIntRange(e->e1); 3428 IntRange ir2 = getIntRange(e->e2); 3429 range = (ir1 - ir2).cast(e->type); 3430 } 3431 3432 void visit(DivExp *e) 3433 { 3434 IntRange ir1 = getIntRange(e->e1); 3435 IntRange ir2 = getIntRange(e->e2); 3436 3437 range = (ir1 / ir2).cast(e->type); 3438 } 3439 3440 void visit(MulExp *e) 3441 { 3442 IntRange ir1 = getIntRange(e->e1); 3443 IntRange ir2 = getIntRange(e->e2); 3444 3445 range = (ir1 * ir2).cast(e->type); 3446 } 3447 3448 void visit(ModExp *e) 3449 { 3450 IntRange ir1 = getIntRange(e->e1); 3451 IntRange ir2 = getIntRange(e->e2); 3452 3453 // Modding on 0 is invalid anyway. 3454 if (!ir2.absNeg().imin.negative) 3455 { 3456 visit((Expression *)e); 3457 return; 3458 } 3459 range = (ir1 % ir2).cast(e->type); 3460 } 3461 3462 void visit(AndExp *e) 3463 { 3464 IntRange result; 3465 bool hasResult = false; 3466 result.unionOrAssign(getIntRange(e->e1) & getIntRange(e->e2), hasResult); 3467 3468 assert(hasResult); 3469 range = result.cast(e->type); 3470 } 3471 3472 void visit(OrExp *e) 3473 { 3474 IntRange result; 3475 bool hasResult = false; 3476 result.unionOrAssign(getIntRange(e->e1) | getIntRange(e->e2), hasResult); 3477 3478 assert(hasResult); 3479 range = result.cast(e->type); 3480 } 3481 3482 void visit(XorExp *e) 3483 { 3484 IntRange result; 3485 bool hasResult = false; 3486 result.unionOrAssign(getIntRange(e->e1) ^ getIntRange(e->e2), hasResult); 3487 3488 assert(hasResult); 3489 range = result.cast(e->type); 3490 } 3491 3492 void visit(ShlExp *e) 3493 { 3494 IntRange ir1 = getIntRange(e->e1); 3495 IntRange ir2 = getIntRange(e->e2); 3496 3497 range = (ir1 << ir2).cast(e->type); 3498 } 3499 3500 void visit(ShrExp *e) 3501 { 3502 IntRange ir1 = getIntRange(e->e1); 3503 IntRange ir2 = getIntRange(e->e2); 3504 3505 range = (ir1 >> ir2).cast(e->type); 3506 } 3507 3508 void visit(UshrExp *e) 3509 { 3510 IntRange ir1 = getIntRange(e->e1).castUnsigned(e->e1->type); 3511 IntRange ir2 = getIntRange(e->e2); 3512 3513 range = (ir1 >> ir2).cast(e->type); 3514 } 3515 3516 void visit(AssignExp *e) 3517 { 3518 range = getIntRange(e->e2).cast(e->type); 3519 } 3520 3521 void visit(CondExp *e) 3522 { 3523 // No need to check e->econd; assume caller has called optimize() 3524 IntRange ir1 = getIntRange(e->e1); 3525 IntRange ir2 = getIntRange(e->e2); 3526 range = ir1.unionWith(ir2).cast(e->type); 3527 } 3528 3529 void visit(VarExp *e) 3530 { 3531 Expression *ie; 3532 VarDeclaration* vd = e->var->isVarDeclaration(); 3533 if (vd && vd->range) 3534 range = vd->range->cast(e->type); 3535 else if (vd && vd->_init && !vd->type->isMutable() && 3536 (ie = vd->getConstInitializer()) != NULL) 3537 ie->accept(this); 3538 else 3539 visit((Expression *)e); 3540 } 3541 3542 void visit(CommaExp *e) 3543 { 3544 e->e2->accept(this); 3545 } 3546 3547 void visit(ComExp *e) 3548 { 3549 IntRange ir = getIntRange(e->e1); 3550 range = IntRange(SignExtendedNumber(~ir.imax.value, !ir.imax.negative), 3551 SignExtendedNumber(~ir.imin.value, !ir.imin.negative)).cast(e->type); 3552 } 3553 3554 void visit(NegExp *e) 3555 { 3556 IntRange ir = getIntRange(e->e1); 3557 range = (-ir).cast(e->type); 3558 } 3559 }; 3560 3561 IntRangeVisitor v; 3562 e->accept(&v); 3563 return v.range; 3564} 3565