1 /** 2 * Define the implicit `opEquals`, `opAssign`, post blit, copy constructor and destructor for structs. 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/clone.d, _clone.d) 8 * Documentation: https://dlang.org/phobos/dmd_clone.html 9 * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/clone.d 10 */ 11 12 module dmd.clone; 13 14 import core.stdc.stdio; 15 import dmd.aggregate; 16 import dmd.arraytypes; 17 import dmd.dclass; 18 import dmd.declaration; 19 import dmd.dscope; 20 import dmd.dstruct; 21 import dmd.dsymbol; 22 import dmd.dsymbolsem; 23 import dmd.dtemplate; 24 import dmd.expression; 25 import dmd.expressionsem; 26 import dmd.func; 27 import dmd.globals; 28 import dmd.id; 29 import dmd.identifier; 30 import dmd.init; 31 import dmd.mtype; 32 import dmd.opover; 33 import dmd.semantic2; 34 import dmd.statement; 35 import dmd.target; 36 import dmd.typesem; 37 import dmd.tokens; 38 39 /******************************************* 40 * Merge function attributes pure, nothrow, @safe, @nogc, and @disable 41 * from f into s1. 42 * Params: 43 * s1 = storage class to merge into 44 * f = function 45 * Returns: 46 * merged storage class 47 */ 48 StorageClass mergeFuncAttrs(StorageClass s1, const FuncDeclaration f) pure 49 { 50 if (!f) 51 return s1; 52 StorageClass s2 = (f.storage_class & STC.disable); 53 54 TypeFunction tf = cast(TypeFunction)f.type; 55 if (tf.trust == TRUST.safe) 56 s2 |= STC.safe; 57 else if (tf.trust == TRUST.system) 58 s2 |= STC.system; 59 else if (tf.trust == TRUST.trusted) 60 s2 |= STC.trusted; 61 62 if (tf.purity != PURE.impure) 63 s2 |= STC.pure_; 64 if (tf.isnothrow) 65 s2 |= STC.nothrow_; 66 if (tf.isnogc) 67 s2 |= STC.nogc; 68 69 const sa = s1 & s2; 70 const so = s1 | s2; 71 72 StorageClass stc = (sa & (STC.pure_ | STC.nothrow_ | STC.nogc)) | (so & STC.disable); 73 74 if (so & STC.system) 75 stc |= STC.system; 76 else if (sa & STC.trusted) 77 stc |= STC.trusted; 78 else if ((so & (STC.trusted | STC.safe)) == (STC.trusted | STC.safe)) 79 stc |= STC.trusted; 80 else if (sa & STC.safe) 81 stc |= STC.safe; 82 83 return stc; 84 } 85 86 /******************************************* 87 * Check given aggregate actually has an identity opAssign or not. 88 * Params: 89 * ad = struct or class 90 * sc = current scope 91 * Returns: 92 * if found, returns FuncDeclaration of opAssign, otherwise null 93 */ 94 FuncDeclaration hasIdentityOpAssign(AggregateDeclaration ad, Scope* sc) 95 { 96 Dsymbol assign = search_function(ad, Id.assign); 97 if (assign) 98 { 99 /* check identity opAssign exists 100 */ 101 scope er = new NullExp(ad.loc, ad.type); // dummy rvalue 102 scope el = new IdentifierExp(ad.loc, Id.p); // dummy lvalue 103 el.type = ad.type; 104 Expressions a; 105 a.setDim(1); 106 const errors = global.startGagging(); // Do not report errors, even if the template opAssign fbody makes it. 107 sc = sc.push(); 108 sc.tinst = null; 109 sc.minst = null; 110 111 a[0] = er; 112 auto f = resolveFuncCall(ad.loc, sc, assign, null, ad.type, &a, FuncResolveFlag.quiet); 113 if (!f) 114 { 115 a[0] = el; 116 f = resolveFuncCall(ad.loc, sc, assign, null, ad.type, &a, FuncResolveFlag.quiet); 117 } 118 119 sc = sc.pop(); 120 global.endGagging(errors); 121 if (f) 122 { 123 if (f.errors) 124 return null; 125 auto fparams = f.getParameterList(); 126 if (fparams.length) 127 { 128 auto fparam0 = fparams[0]; 129 if (fparam0.type.toDsymbol(null) != ad) 130 f = null; 131 } 132 } 133 // BUGS: This detection mechanism cannot find some opAssign-s like follows: 134 // struct S { void opAssign(ref immutable S) const; } 135 return f; 136 } 137 return null; 138 } 139 140 /******************************************* 141 * We need an opAssign for the struct if 142 * it has a destructor or a postblit. 143 * We need to generate one if a user-specified one does not exist. 144 */ 145 private bool needOpAssign(StructDeclaration sd) 146 { 147 //printf("StructDeclaration::needOpAssign() %s\n", sd.toChars()); 148 149 static bool isNeeded() 150 { 151 //printf("\tneed\n"); 152 return true; 153 } 154 155 if (sd.isUnionDeclaration()) 156 return !isNeeded(); 157 158 if (sd.hasIdentityAssign || // because has identity==elaborate opAssign 159 sd.dtor || 160 sd.postblit) 161 return isNeeded(); 162 163 /* If any of the fields need an opAssign, then we 164 * need it too. 165 */ 166 foreach (v; sd.fields) 167 { 168 if (v.storage_class & STC.ref_) 169 continue; 170 if (v.overlapped) // if field of a union 171 continue; // user must handle it themselves 172 Type tv = v.type.baseElemOf(); 173 if (tv.ty == Tstruct) 174 { 175 TypeStruct ts = cast(TypeStruct)tv; 176 if (ts.sym.isUnionDeclaration()) 177 continue; 178 if (needOpAssign(ts.sym)) 179 return isNeeded(); 180 } 181 } 182 return !isNeeded(); 183 } 184 185 /****************************************** 186 * Build opAssign for a `struct`. 187 * 188 * The generated `opAssign` function has the following signature: 189 *--- 190 *ref S opAssign(S s) // S is the name of the `struct` 191 *--- 192 * 193 * The opAssign function will be built for a struct `S` if the 194 * following constraints are met: 195 * 196 * 1. `S` does not have an identity `opAssign` defined. 197 * 198 * 2. `S` has at least one of the following members: a postblit (user-defined or 199 * generated for fields that have a defined postblit), a destructor 200 * (user-defined or generated for fields that have a defined destructor) 201 * or at least one field that has a defined `opAssign`. 202 * 203 * 3. `S` does not have any non-mutable fields. 204 * 205 * If `S` has a disabled destructor or at least one field that has a disabled 206 * `opAssign`, `S.opAssign` is going to be generated, but marked with `@disable` 207 * 208 * If `S` defines a destructor, the generated code for `opAssign` is: 209 * 210 *--- 211 *S __swap = void; 212 *__swap = this; // bit copy 213 *this = s; // bit copy 214 *__swap.dtor(); 215 *--- 216 * 217 * Otherwise, if `S` defines a postblit, the generated code for `opAssign` is: 218 * 219 *--- 220 *this = s; 221 *--- 222 * 223 * Note that the parameter to the generated `opAssign` is passed by value, which means 224 * that the postblit is going to be called (if it is defined) in both of the above 225 * situations before entering the body of `opAssign`. The assignments in the above generated 226 * function bodies are blit expressions, so they can be regarded as `memcpy`s 227 * (`opAssign` is not called as this will result in an infinite recursion; the postblit 228 * is not called because it has already been called when the parameter was passed by value). 229 * 230 * If `S` does not have a postblit or a destructor, but contains at least one field that defines 231 * an `opAssign` function (which is not disabled), then the body will make member-wise 232 * assignments: 233 * 234 *--- 235 *this.field1 = s.field1; 236 *this.field2 = s.field2; 237 *...; 238 *--- 239 * 240 * In this situation, the assignemnts are actual assign expressions (`opAssign` is used 241 * if defined). 242 * 243 * References: 244 * https://dlang.org/spec/struct.html#assign-overload 245 * Params: 246 * sd = struct to generate opAssign for 247 * sc = context 248 * Returns: 249 * generated `opAssign` function 250 */ 251 FuncDeclaration buildOpAssign(StructDeclaration sd, Scope* sc) 252 { 253 if (FuncDeclaration f = hasIdentityOpAssign(sd, sc)) 254 { 255 sd.hasIdentityAssign = true; 256 return f; 257 } 258 // Even if non-identity opAssign is defined, built-in identity opAssign 259 // will be defined. 260 if (!needOpAssign(sd)) 261 return null; 262 263 //printf("StructDeclaration::buildOpAssign() %s\n", sd.toChars()); 264 StorageClass stc = STC.safe | STC.nothrow_ | STC.pure_ | STC.nogc; 265 Loc declLoc = sd.loc; 266 Loc loc; // internal code should have no loc to prevent coverage 267 268 // One of our sub-field might have `@disable opAssign` so we need to 269 // check for it. 270 // In this event, it will be reflected by having `stc` (opAssign's 271 // storage class) include `STC.disabled`. 272 foreach (v; sd.fields) 273 { 274 if (v.storage_class & STC.ref_) 275 continue; 276 if (v.overlapped) 277 continue; 278 Type tv = v.type.baseElemOf(); 279 if (tv.ty != Tstruct) 280 continue; 281 StructDeclaration sdv = (cast(TypeStruct)tv).sym; 282 stc = mergeFuncAttrs(stc, hasIdentityOpAssign(sdv, sc)); 283 } 284 285 if (sd.dtor || sd.postblit) 286 { 287 // if the type is not assignable, we cannot generate opAssign 288 if (!sd.type.isAssignable()) // https://issues.dlang.org/show_bug.cgi?id=13044 289 return null; 290 stc = mergeFuncAttrs(stc, sd.dtor); 291 if (stc & STC.safe) 292 stc = (stc & ~STC.safe) | STC.trusted; 293 } 294 295 auto fparams = new Parameters(); 296 fparams.push(new Parameter(STC.nodtor, sd.type, Id.p, null, null)); 297 auto tf = new TypeFunction(ParameterList(fparams), sd.handleType(), LINK.d, stc | STC.ref_); 298 auto fop = new FuncDeclaration(declLoc, Loc.initial, Id.assign, stc, tf); 299 fop.storage_class |= STC.inference; 300 fop.generated = true; 301 Expression e; 302 if (stc & STC.disable) 303 { 304 e = null; 305 } 306 /* Do swap this and rhs. 307 * __swap = this; this = s; __swap.dtor(); 308 */ 309 else if (sd.dtor) 310 { 311 //printf("\tswap copy\n"); 312 TypeFunction tdtor = cast(TypeFunction)sd.dtor.type; 313 assert(tdtor.ty == Tfunction); 314 315 auto idswap = Identifier.generateId("__swap"); 316 auto swap = new VarDeclaration(loc, sd.type, idswap, new VoidInitializer(loc)); 317 swap.storage_class |= STC.nodtor | STC.temp | STC.ctfe; 318 if (tdtor.isScopeQual) 319 swap.storage_class |= STC.scope_; 320 auto e1 = new DeclarationExp(loc, swap); 321 322 auto e2 = new BlitExp(loc, new VarExp(loc, swap), new ThisExp(loc)); 323 auto e3 = new BlitExp(loc, new ThisExp(loc), new IdentifierExp(loc, Id.p)); 324 325 /* Instead of running the destructor on s, run it 326 * on swap. This avoids needing to copy swap back in to s. 327 */ 328 auto e4 = new CallExp(loc, new DotVarExp(loc, new VarExp(loc, swap), sd.dtor, false)); 329 330 e = Expression.combine(e1, e2, e3, e4); 331 } 332 /* postblit was called when the value was passed to opAssign, we just need to blit the result */ 333 else if (sd.postblit) 334 { 335 e = new BlitExp(loc, new ThisExp(loc), new IdentifierExp(loc, Id.p)); 336 sd.hasBlitAssign = true; 337 } 338 else 339 { 340 /* Do memberwise copy. 341 * 342 * If sd is a nested struct, its vthis field assignment is: 343 * 1. If it's nested in a class, it's a rebind of class reference. 344 * 2. If it's nested in a function or struct, it's an update of void*. 345 * In both cases, it will change the parent context. 346 */ 347 //printf("\tmemberwise copy\n"); 348 e = null; 349 foreach (v; sd.fields) 350 { 351 // this.v = s.v; 352 auto ec = new AssignExp(loc, 353 new DotVarExp(loc, new ThisExp(loc), v), 354 new DotVarExp(loc, new IdentifierExp(loc, Id.p), v)); 355 e = Expression.combine(e, ec); 356 } 357 } 358 if (e) 359 { 360 Statement s1 = new ExpStatement(loc, e); 361 /* Add: 362 * return this; 363 */ 364 auto er = new ThisExp(loc); 365 Statement s2 = new ReturnStatement(loc, er); 366 fop.fbody = new CompoundStatement(loc, s1, s2); 367 tf.isreturn = true; 368 } 369 sd.members.push(fop); 370 fop.addMember(sc, sd); 371 sd.hasIdentityAssign = true; // temporary mark identity assignable 372 const errors = global.startGagging(); // Do not report errors, even if the template opAssign fbody makes it. 373 Scope* sc2 = sc.push(); 374 sc2.stc = 0; 375 sc2.linkage = LINK.d; 376 fop.dsymbolSemantic(sc2); 377 fop.semantic2(sc2); 378 // https://issues.dlang.org/show_bug.cgi?id=15044 379 //semantic3(fop, sc2); // isn't run here for lazy forward reference resolution. 380 381 sc2.pop(); 382 if (global.endGagging(errors)) // if errors happened 383 { 384 // Disable generated opAssign, because some members forbid identity assignment. 385 fop.storage_class |= STC.disable; 386 fop.fbody = null; // remove fbody which contains the error 387 } 388 389 //printf("-StructDeclaration::buildOpAssign() %s, errors = %d\n", sd.toChars(), (fop.storage_class & STC.disable) != 0); 390 //printf("fop.type: %s\n", fop.type.toPrettyChars()); 391 return fop; 392 } 393 394 /******************************************* 395 * We need an opEquals for the struct if 396 * any fields has an opEquals. 397 * Generate one if a user-specified one does not exist. 398 */ 399 bool needOpEquals(StructDeclaration sd) 400 { 401 //printf("StructDeclaration::needOpEquals() %s\n", sd.toChars()); 402 if (sd.isUnionDeclaration()) 403 goto Ldontneed; 404 if (sd.hasIdentityEquals) 405 goto Lneed; 406 /* If any of the fields has an opEquals, then we 407 * need it too. 408 */ 409 for (size_t i = 0; i < sd.fields.dim; i++) 410 { 411 VarDeclaration v = sd.fields[i]; 412 if (v.storage_class & STC.ref_) 413 continue; 414 if (v.overlapped) 415 continue; 416 Type tv = v.type.toBasetype(); 417 auto tvbase = tv.baseElemOf(); 418 if (tvbase.ty == Tstruct) 419 { 420 TypeStruct ts = cast(TypeStruct)tvbase; 421 if (ts.sym.isUnionDeclaration()) 422 continue; 423 if (needOpEquals(ts.sym)) 424 goto Lneed; 425 if (ts.sym.aliasthis) // https://issues.dlang.org/show_bug.cgi?id=14806 426 goto Lneed; 427 } 428 if (tvbase.isfloating()) 429 { 430 // This is necessray for: 431 // 1. comparison of +0.0 and -0.0 should be true. 432 // 2. comparison of NANs should be false always. 433 goto Lneed; 434 } 435 if (tvbase.ty == Tarray) 436 goto Lneed; 437 if (tvbase.ty == Taarray) 438 goto Lneed; 439 if (tvbase.ty == Tclass) 440 goto Lneed; 441 } 442 Ldontneed: 443 //printf("\tdontneed\n"); 444 return false; 445 Lneed: 446 //printf("\tneed\n"); 447 return true; 448 } 449 450 /******************************************* 451 * Check given aggregate actually has an identity opEquals or not. 452 */ 453 private FuncDeclaration hasIdentityOpEquals(AggregateDeclaration ad, Scope* sc) 454 { 455 FuncDeclaration f; 456 if (Dsymbol eq = search_function(ad, Id.eq)) 457 { 458 /* check identity opEquals exists 459 */ 460 scope er = new NullExp(ad.loc, null); // dummy rvalue 461 scope el = new IdentifierExp(ad.loc, Id.p); // dummy lvalue 462 Expressions a; 463 a.setDim(1); 464 465 bool hasIt(Type tthis) 466 { 467 const errors = global.startGagging(); // Do not report errors, even if the template opAssign fbody makes it 468 sc = sc.push(); 469 sc.tinst = null; 470 sc.minst = null; 471 472 FuncDeclaration rfc(Expression e) 473 { 474 a[0] = e; 475 a[0].type = tthis; 476 return resolveFuncCall(ad.loc, sc, eq, null, tthis, &a, FuncResolveFlag.quiet); 477 } 478 479 f = rfc(er); 480 if (!f) 481 f = rfc(el); 482 483 sc = sc.pop(); 484 global.endGagging(errors); 485 486 return f !is null; 487 } 488 489 if (hasIt(ad.type) || 490 hasIt(ad.type.constOf()) || 491 hasIt(ad.type.immutableOf()) || 492 hasIt(ad.type.sharedOf()) || 493 hasIt(ad.type.sharedConstOf())) 494 { 495 if (f.errors) 496 return null; 497 } 498 } 499 return f; 500 } 501 502 /****************************************** 503 * Build opEquals for struct. 504 * const bool opEquals(const S s) { ... } 505 * 506 * By fixing https://issues.dlang.org/show_bug.cgi?id=3789 507 * opEquals is changed to be never implicitly generated. 508 * Now, struct objects comparison s1 == s2 is translated to: 509 * s1.tupleof == s2.tupleof 510 * to calculate structural equality. See EqualExp.op_overload. 511 */ 512 FuncDeclaration buildOpEquals(StructDeclaration sd, Scope* sc) 513 { 514 if (hasIdentityOpEquals(sd, sc)) 515 { 516 sd.hasIdentityEquals = true; 517 } 518 return null; 519 } 520 521 /****************************************** 522 * Build __xopEquals for TypeInfo_Struct 523 * static bool __xopEquals(ref const S p, ref const S q) 524 * { 525 * return p == q; 526 * } 527 * 528 * This is called by TypeInfo.equals(p1, p2). If the struct does not support 529 * const objects comparison, it will throw "not implemented" Error in runtime. 530 */ 531 FuncDeclaration buildXopEquals(StructDeclaration sd, Scope* sc) 532 { 533 if (!needOpEquals(sd)) 534 return null; // bitwise comparison would work 535 536 //printf("StructDeclaration::buildXopEquals() %s\n", sd.toChars()); 537 if (Dsymbol eq = search_function(sd, Id.eq)) 538 { 539 if (FuncDeclaration fd = eq.isFuncDeclaration()) 540 { 541 TypeFunction tfeqptr; 542 { 543 Scope scx; 544 /* const bool opEquals(ref const S s); 545 */ 546 auto parameters = new Parameters(); 547 parameters.push(new Parameter(STC.ref_ | STC.const_, sd.type, null, null, null)); 548 tfeqptr = new TypeFunction(ParameterList(parameters), Type.tbool, LINK.d); 549 tfeqptr.mod = MODFlags.const_; 550 tfeqptr = cast(TypeFunction)tfeqptr.typeSemantic(Loc.initial, &scx); 551 } 552 fd = fd.overloadExactMatch(tfeqptr); 553 if (fd) 554 return fd; 555 } 556 } 557 if (!sd.xerreq) 558 { 559 // object._xopEquals 560 Identifier id = Identifier.idPool("_xopEquals"); 561 Expression e = new IdentifierExp(sd.loc, Id.empty); 562 e = new DotIdExp(sd.loc, e, Id.object); 563 e = new DotIdExp(sd.loc, e, id); 564 e = e.expressionSemantic(sc); 565 Dsymbol s = getDsymbol(e); 566 assert(s); 567 sd.xerreq = s.isFuncDeclaration(); 568 } 569 Loc declLoc; // loc is unnecessary so __xopEquals is never called directly 570 Loc loc; // loc is unnecessary so errors are gagged 571 auto parameters = new Parameters(); 572 parameters.push(new Parameter(STC.ref_ | STC.const_, sd.type, Id.p, null, null)) 573 .push(new Parameter(STC.ref_ | STC.const_, sd.type, Id.q, null, null)); 574 auto tf = new TypeFunction(ParameterList(parameters), Type.tbool, LINK.d); 575 Identifier id = Id.xopEquals; 576 auto fop = new FuncDeclaration(declLoc, Loc.initial, id, STC.static_, tf); 577 fop.generated = true; 578 Expression e1 = new IdentifierExp(loc, Id.p); 579 Expression e2 = new IdentifierExp(loc, Id.q); 580 Expression e = new EqualExp(TOK.equal, loc, e1, e2); 581 fop.fbody = new ReturnStatement(loc, e); 582 uint errors = global.startGagging(); // Do not report errors 583 Scope* sc2 = sc.push(); 584 sc2.stc = 0; 585 sc2.linkage = LINK.d; 586 fop.dsymbolSemantic(sc2); 587 fop.semantic2(sc2); 588 sc2.pop(); 589 if (global.endGagging(errors)) // if errors happened 590 fop = sd.xerreq; 591 return fop; 592 } 593 594 /****************************************** 595 * Build __xopCmp for TypeInfo_Struct 596 * static bool __xopCmp(ref const S p, ref const S q) 597 * { 598 * return p.opCmp(q); 599 * } 600 * 601 * This is called by TypeInfo.compare(p1, p2). If the struct does not support 602 * const objects comparison, it will throw "not implemented" Error in runtime. 603 */ 604 FuncDeclaration buildXopCmp(StructDeclaration sd, Scope* sc) 605 { 606 //printf("StructDeclaration::buildXopCmp() %s\n", toChars()); 607 if (Dsymbol cmp = search_function(sd, Id.cmp)) 608 { 609 if (FuncDeclaration fd = cmp.isFuncDeclaration()) 610 { 611 TypeFunction tfcmpptr; 612 { 613 Scope scx; 614 /* const int opCmp(ref const S s); 615 */ 616 auto parameters = new Parameters(); 617 parameters.push(new Parameter(STC.ref_ | STC.const_, sd.type, null, null, null)); 618 tfcmpptr = new TypeFunction(ParameterList(parameters), Type.tint32, LINK.d); 619 tfcmpptr.mod = MODFlags.const_; 620 tfcmpptr = cast(TypeFunction)tfcmpptr.typeSemantic(Loc.initial, &scx); 621 } 622 fd = fd.overloadExactMatch(tfcmpptr); 623 if (fd) 624 return fd; 625 } 626 } 627 else 628 { 629 version (none) // FIXME: doesn't work for recursive alias this 630 { 631 /* Check opCmp member exists. 632 * Consider 'alias this', but except opDispatch. 633 */ 634 Expression e = new DsymbolExp(sd.loc, sd); 635 e = new DotIdExp(sd.loc, e, Id.cmp); 636 Scope* sc2 = sc.push(); 637 e = e.trySemantic(sc2); 638 sc2.pop(); 639 if (e) 640 { 641 Dsymbol s = null; 642 switch (e.op) 643 { 644 case TOK.overloadSet: 645 s = (cast(OverExp)e).vars; 646 break; 647 case TOK.scope_: 648 s = (cast(ScopeExp)e).sds; 649 break; 650 case TOK.variable: 651 s = (cast(VarExp)e).var; 652 break; 653 default: 654 break; 655 } 656 if (!s || s.ident != Id.cmp) 657 e = null; // there's no valid member 'opCmp' 658 } 659 if (!e) 660 return null; // bitwise comparison would work 661 /* Essentially, a struct which does not define opCmp is not comparable. 662 * At this time, typeid(S).compare might be correct that throwing "not implement" Error. 663 * But implementing it would break existing code, such as: 664 * 665 * struct S { int value; } // no opCmp 666 * int[S] aa; // Currently AA key uses bitwise comparison 667 * // (It's default behavior of TypeInfo_Strust.compare). 668 * 669 * Not sure we should fix this inconsistency, so just keep current behavior. 670 */ 671 } 672 else 673 { 674 return null; 675 } 676 } 677 if (!sd.xerrcmp) 678 { 679 // object._xopCmp 680 Identifier id = Identifier.idPool("_xopCmp"); 681 Expression e = new IdentifierExp(sd.loc, Id.empty); 682 e = new DotIdExp(sd.loc, e, Id.object); 683 e = new DotIdExp(sd.loc, e, id); 684 e = e.expressionSemantic(sc); 685 Dsymbol s = getDsymbol(e); 686 assert(s); 687 sd.xerrcmp = s.isFuncDeclaration(); 688 } 689 Loc declLoc; // loc is unnecessary so __xopCmp is never called directly 690 Loc loc; // loc is unnecessary so errors are gagged 691 auto parameters = new Parameters(); 692 parameters.push(new Parameter(STC.ref_ | STC.const_, sd.type, Id.p, null, null)); 693 parameters.push(new Parameter(STC.ref_ | STC.const_, sd.type, Id.q, null, null)); 694 auto tf = new TypeFunction(ParameterList(parameters), Type.tint32, LINK.d); 695 Identifier id = Id.xopCmp; 696 auto fop = new FuncDeclaration(declLoc, Loc.initial, id, STC.static_, tf); 697 fop.generated = true; 698 Expression e1 = new IdentifierExp(loc, Id.p); 699 Expression e2 = new IdentifierExp(loc, Id.q); 700 Expression e = new CallExp(loc, new DotIdExp(loc, e2, Id.cmp), e1); 701 fop.fbody = new ReturnStatement(loc, e); 702 uint errors = global.startGagging(); // Do not report errors 703 Scope* sc2 = sc.push(); 704 sc2.stc = 0; 705 sc2.linkage = LINK.d; 706 fop.dsymbolSemantic(sc2); 707 fop.semantic2(sc2); 708 sc2.pop(); 709 if (global.endGagging(errors)) // if errors happened 710 fop = sd.xerrcmp; 711 return fop; 712 } 713 714 /******************************************* 715 * We need a toHash for the struct if 716 * any fields has a toHash. 717 * Generate one if a user-specified one does not exist. 718 */ 719 private bool needToHash(StructDeclaration sd) 720 { 721 //printf("StructDeclaration::needToHash() %s\n", sd.toChars()); 722 if (sd.isUnionDeclaration()) 723 goto Ldontneed; 724 if (sd.xhash) 725 goto Lneed; 726 727 /* If any of the fields has an opEquals, then we 728 * need it too. 729 */ 730 for (size_t i = 0; i < sd.fields.dim; i++) 731 { 732 VarDeclaration v = sd.fields[i]; 733 if (v.storage_class & STC.ref_) 734 continue; 735 if (v.overlapped) 736 continue; 737 Type tv = v.type.toBasetype(); 738 auto tvbase = tv.baseElemOf(); 739 if (tvbase.ty == Tstruct) 740 { 741 TypeStruct ts = cast(TypeStruct)tvbase; 742 if (ts.sym.isUnionDeclaration()) 743 continue; 744 if (needToHash(ts.sym)) 745 goto Lneed; 746 if (ts.sym.aliasthis) // https://issues.dlang.org/show_bug.cgi?id=14948 747 goto Lneed; 748 } 749 if (tvbase.isfloating()) 750 { 751 /* This is necessary because comparison of +0.0 and -0.0 should be true, 752 * i.e. not a bit compare. 753 */ 754 goto Lneed; 755 } 756 if (tvbase.ty == Tarray) 757 goto Lneed; 758 if (tvbase.ty == Taarray) 759 goto Lneed; 760 if (tvbase.ty == Tclass) 761 goto Lneed; 762 } 763 Ldontneed: 764 //printf("\tdontneed\n"); 765 return false; 766 Lneed: 767 //printf("\tneed\n"); 768 return true; 769 } 770 771 /****************************************** 772 * Build __xtoHash for non-bitwise hashing 773 * static hash_t xtoHash(ref const S p) nothrow @trusted; 774 */ 775 FuncDeclaration buildXtoHash(StructDeclaration sd, Scope* sc) 776 { 777 if (Dsymbol s = search_function(sd, Id.tohash)) 778 { 779 __gshared TypeFunction tftohash; 780 if (!tftohash) 781 { 782 tftohash = new TypeFunction(ParameterList(), Type.thash_t, LINK.d); 783 tftohash.mod = MODFlags.const_; 784 tftohash = cast(TypeFunction)tftohash.merge(); 785 } 786 if (FuncDeclaration fd = s.isFuncDeclaration()) 787 { 788 fd = fd.overloadExactMatch(tftohash); 789 if (fd) 790 return fd; 791 } 792 } 793 if (!needToHash(sd)) 794 return null; 795 796 //printf("StructDeclaration::buildXtoHash() %s\n", sd.toPrettyChars()); 797 Loc declLoc; // loc is unnecessary so __xtoHash is never called directly 798 Loc loc; // internal code should have no loc to prevent coverage 799 auto parameters = new Parameters(); 800 parameters.push(new Parameter(STC.ref_ | STC.const_, sd.type, Id.p, null, null)); 801 auto tf = new TypeFunction(ParameterList(parameters), Type.thash_t, LINK.d, STC.nothrow_ | STC.trusted); 802 Identifier id = Id.xtoHash; 803 auto fop = new FuncDeclaration(declLoc, Loc.initial, id, STC.static_, tf); 804 fop.generated = true; 805 806 /* Do memberwise hashing. 807 * 808 * If sd is a nested struct, and if it's nested in a class, the calculated 809 * hash value will also contain the result of parent class's toHash(). 810 */ 811 const(char)[] code = 812 ".object.size_t h = 0;" ~ 813 "foreach (i, T; typeof(p.tupleof))" ~ 814 // workaround https://issues.dlang.org/show_bug.cgi?id=17968 815 " static if(is(T* : const(.object.Object)*)) " ~ 816 " h = h * 33 + typeid(const(.object.Object)).getHash(cast(const void*)&p.tupleof[i]);" ~ 817 " else " ~ 818 " h = h * 33 + typeid(T).getHash(cast(const void*)&p.tupleof[i]);" ~ 819 "return h;"; 820 fop.fbody = new CompileStatement(loc, new StringExp(loc, code)); 821 Scope* sc2 = sc.push(); 822 sc2.stc = 0; 823 sc2.linkage = LINK.d; 824 fop.dsymbolSemantic(sc2); 825 fop.semantic2(sc2); 826 sc2.pop(); 827 828 //printf("%s fop = %s %s\n", sd.toChars(), fop.toChars(), fop.type.toChars()); 829 return fop; 830 } 831 832 /***************************************** 833 * Create inclusive destructor for struct/class by aggregating 834 * all the destructors in dtors[] with the destructors for 835 * all the members. 836 * Params: 837 * ad = struct or class to build destructor for 838 * sc = context 839 * Returns: 840 * generated function, null if none needed 841 * Note: 842 * Close similarity with StructDeclaration::buildPostBlit(), 843 * and the ordering changes (runs backward instead of forwards). 844 */ 845 DtorDeclaration buildDtor(AggregateDeclaration ad, Scope* sc) 846 { 847 //printf("AggregateDeclaration::buildDtor() %s\n", ad.toChars()); 848 if (ad.isUnionDeclaration()) 849 return null; // unions don't have destructors 850 851 StorageClass stc = STC.safe | STC.nothrow_ | STC.pure_ | STC.nogc; 852 Loc declLoc = ad.dtors.dim ? ad.dtors[0].loc : ad.loc; 853 Loc loc; // internal code should have no loc to prevent coverage 854 FuncDeclaration xdtor_fwd = null; 855 856 // if the dtor is an extern(C++) prototype, then we expect it performs a full-destruction; we don't need to build a full-dtor 857 const bool dtorIsCppPrototype = ad.dtors.dim == 1 && ad.dtors[0].linkage == LINK.cpp && !ad.dtors[0].fbody; 858 if (!dtorIsCppPrototype) 859 { 860 Expression e = null; 861 for (size_t i = 0; i < ad.fields.dim; i++) 862 { 863 auto v = ad.fields[i]; 864 if (v.storage_class & STC.ref_) 865 continue; 866 if (v.overlapped) 867 continue; 868 auto tv = v.type.baseElemOf(); 869 if (tv.ty != Tstruct) 870 continue; 871 auto sdv = (cast(TypeStruct)tv).sym; 872 if (!sdv.dtor) 873 continue; 874 875 // fix: https://issues.dlang.org/show_bug.cgi?id=17257 876 // braces for shrink wrapping scope of a 877 { 878 xdtor_fwd = sdv.dtor; // this dtor is temporary it could be anything 879 auto a = new AliasDeclaration(Loc.initial, Id.__xdtor, xdtor_fwd); 880 a.addMember(sc, ad); // temporarily add to symbol table 881 } 882 883 sdv.dtor.functionSemantic(); 884 885 stc = mergeFuncAttrs(stc, sdv.dtor); 886 if (stc & STC.disable) 887 { 888 e = null; 889 break; 890 } 891 892 Expression ex; 893 tv = v.type.toBasetype(); 894 if (tv.ty == Tstruct) 895 { 896 // this.v.__xdtor() 897 898 ex = new ThisExp(loc); 899 ex = new DotVarExp(loc, ex, v); 900 901 // This is a hack so we can call destructors on const/immutable objects. 902 // Do it as a type 'paint'. 903 ex = new CastExp(loc, ex, v.type.mutableOf()); 904 if (stc & STC.safe) 905 stc = (stc & ~STC.safe) | STC.trusted; 906 907 ex = new DotVarExp(loc, ex, sdv.dtor, false); 908 ex = new CallExp(loc, ex); 909 } 910 else 911 { 912 // __ArrayDtor((cast(S*)this.v.ptr)[0 .. n]) 913 914 const n = tv.numberOfElems(loc); 915 if (n == 0) 916 continue; 917 918 ex = new ThisExp(loc); 919 ex = new DotVarExp(loc, ex, v); 920 921 // This is a hack so we can call destructors on const/immutable objects. 922 ex = new DotIdExp(loc, ex, Id.ptr); 923 ex = new CastExp(loc, ex, sdv.type.pointerTo()); 924 if (stc & STC.safe) 925 stc = (stc & ~STC.safe) | STC.trusted; 926 927 ex = new SliceExp(loc, ex, new IntegerExp(loc, 0, Type.tsize_t), 928 new IntegerExp(loc, n, Type.tsize_t)); 929 // Prevent redundant bounds check 930 (cast(SliceExp)ex).upperIsInBounds = true; 931 (cast(SliceExp)ex).lowerIsLessThanUpper = true; 932 933 ex = new CallExp(loc, new IdentifierExp(loc, Id.__ArrayDtor), ex); 934 } 935 e = Expression.combine(ex, e); // combine in reverse order 936 } 937 938 /* extern(C++) destructors call into super to destruct the full hierarchy 939 */ 940 ClassDeclaration cldec = ad.isClassDeclaration(); 941 if (cldec && cldec.classKind == ClassKind.cpp && cldec.baseClass && cldec.baseClass.primaryDtor) 942 { 943 // WAIT BUT: do I need to run `cldec.baseClass.dtor` semantic? would it have been run before? 944 cldec.baseClass.dtor.functionSemantic(); 945 946 stc = mergeFuncAttrs(stc, cldec.baseClass.primaryDtor); 947 if (!(stc & STC.disable)) 948 { 949 // super.__xdtor() 950 951 Expression ex = new SuperExp(loc); 952 953 // This is a hack so we can call destructors on const/immutable objects. 954 // Do it as a type 'paint'. 955 ex = new CastExp(loc, ex, cldec.baseClass.type.mutableOf()); 956 if (stc & STC.safe) 957 stc = (stc & ~STC.safe) | STC.trusted; 958 959 ex = new DotVarExp(loc, ex, cldec.baseClass.primaryDtor, false); 960 ex = new CallExp(loc, ex); 961 962 e = Expression.combine(e, ex); // super dtor last 963 } 964 } 965 966 /* Build our own "destructor" which executes e 967 */ 968 if (e || (stc & STC.disable)) 969 { 970 //printf("Building __fieldDtor(), %s\n", e.toChars()); 971 auto dd = new DtorDeclaration(declLoc, Loc.initial, stc, Id.__fieldDtor); 972 dd.generated = true; 973 dd.storage_class |= STC.inference; 974 dd.fbody = new ExpStatement(loc, e); 975 ad.dtors.shift(dd); 976 ad.members.push(dd); 977 dd.dsymbolSemantic(sc); 978 ad.fieldDtor = dd; 979 } 980 } 981 982 DtorDeclaration xdtor = null; 983 switch (ad.dtors.dim) 984 { 985 case 0: 986 break; 987 988 case 1: 989 xdtor = ad.dtors[0]; 990 break; 991 992 default: 993 assert(!dtorIsCppPrototype); 994 Expression e = null; 995 e = null; 996 stc = STC.safe | STC.nothrow_ | STC.pure_ | STC.nogc; 997 for (size_t i = 0; i < ad.dtors.dim; i++) 998 { 999 FuncDeclaration fd = ad.dtors[i]; 1000 stc = mergeFuncAttrs(stc, fd); 1001 if (stc & STC.disable) 1002 { 1003 e = null; 1004 break; 1005 } 1006 Expression ex = new ThisExp(loc); 1007 ex = new DotVarExp(loc, ex, fd, false); 1008 ex = new CallExp(loc, ex); 1009 e = Expression.combine(ex, e); 1010 } 1011 auto dd = new DtorDeclaration(declLoc, Loc.initial, stc, Id.__aggrDtor); 1012 dd.generated = true; 1013 dd.storage_class |= STC.inference; 1014 dd.fbody = new ExpStatement(loc, e); 1015 ad.members.push(dd); 1016 dd.dsymbolSemantic(sc); 1017 xdtor = dd; 1018 break; 1019 } 1020 1021 ad.primaryDtor = xdtor; 1022 1023 if (xdtor && xdtor.linkage == LINK.cpp && !target.cpp.twoDtorInVtable) 1024 xdtor = buildWindowsCppDtor(ad, xdtor, sc); 1025 1026 // Add an __xdtor alias to make the inclusive dtor accessible 1027 if (xdtor) 1028 { 1029 auto _alias = new AliasDeclaration(Loc.initial, Id.__xdtor, xdtor); 1030 _alias.dsymbolSemantic(sc); 1031 ad.members.push(_alias); 1032 if (xdtor_fwd) 1033 ad.symtab.update(_alias); // update forward dtor to correct one 1034 else 1035 _alias.addMember(sc, ad); // add to symbol table 1036 } 1037 1038 return xdtor; 1039 } 1040 1041 /** 1042 * build a shim function around the compound dtor that accepts an argument 1043 * that is used to implement the deleting C++ destructor 1044 * 1045 * Params: 1046 * ad = the aggregate that contains the destructor to wrap 1047 * dtor = the destructor to wrap 1048 * sc = the scope in which to analyze the new function 1049 * 1050 * Returns: 1051 * the shim destructor, semantically analyzed and added to the class as a member 1052 */ 1053 private DtorDeclaration buildWindowsCppDtor(AggregateDeclaration ad, DtorDeclaration dtor, Scope* sc) 1054 { 1055 auto cldec = ad.isClassDeclaration(); 1056 if (!cldec || cldec.cppDtorVtblIndex == -1) // scalar deleting dtor not built for non-virtual dtors 1057 return dtor; 1058 1059 // generate deleting C++ destructor corresponding to: 1060 // void* C::~C(int del) 1061 // { 1062 // this->~C(); 1063 // // TODO: if (del) delete (char*)this; 1064 // return (void*) this; 1065 // } 1066 Parameter delparam = new Parameter(STC.undefined_, Type.tuns32, Identifier.idPool("del"), new IntegerExp(dtor.loc, 0, Type.tuns32), null); 1067 Parameters* params = new Parameters; 1068 params.push(delparam); 1069 auto ftype = new TypeFunction(ParameterList(params), Type.tvoidptr, LINK.cpp, dtor.storage_class); 1070 auto func = new DtorDeclaration(dtor.loc, dtor.loc, dtor.storage_class, Id.cppdtor); 1071 func.type = ftype; 1072 if (dtor.fbody) 1073 { 1074 const loc = dtor.loc; 1075 auto stmts = new Statements; 1076 auto call = new CallExp(loc, dtor, null); 1077 call.directcall = true; 1078 stmts.push(new ExpStatement(loc, call)); 1079 stmts.push(new ReturnStatement(loc, new CastExp(loc, new ThisExp(loc), Type.tvoidptr))); 1080 func.fbody = new CompoundStatement(loc, stmts); 1081 func.generated = true; 1082 } 1083 1084 auto sc2 = sc.push(); 1085 sc2.stc &= ~STC.static_; // not a static destructor 1086 sc2.linkage = LINK.cpp; 1087 1088 ad.members.push(func); 1089 func.addMember(sc2, ad); 1090 func.dsymbolSemantic(sc2); 1091 1092 sc2.pop(); 1093 return func; 1094 } 1095 1096 /** 1097 * build a shim function around the compound dtor that translates 1098 * a C++ destructor to a destructor with extern(D) calling convention 1099 * 1100 * Params: 1101 * ad = the aggregate that contains the destructor to wrap 1102 * sc = the scope in which to analyze the new function 1103 * 1104 * Returns: 1105 * the shim destructor, semantically analyzed and added to the class as a member 1106 */ 1107 DtorDeclaration buildExternDDtor(AggregateDeclaration ad, Scope* sc) 1108 { 1109 auto dtor = ad.primaryDtor; 1110 if (!dtor) 1111 return null; 1112 1113 // ABI incompatible on all (?) x86 32-bit platforms 1114 if (ad.classKind != ClassKind.cpp || global.params.is64bit) 1115 return dtor; 1116 1117 // generate member function that adjusts calling convention 1118 // (EAX used for 'this' instead of ECX on Windows/stack on others): 1119 // extern(D) void __ticppdtor() 1120 // { 1121 // Class.__dtor(); 1122 // } 1123 auto ftype = new TypeFunction(ParameterList(), Type.tvoid, LINK.d, dtor.storage_class); 1124 auto func = new DtorDeclaration(dtor.loc, dtor.loc, dtor.storage_class, Id.ticppdtor); 1125 func.type = ftype; 1126 1127 auto call = new CallExp(dtor.loc, dtor, null); 1128 call.directcall = true; // non-virtual call Class.__dtor(); 1129 func.fbody = new ExpStatement(dtor.loc, call); 1130 func.generated = true; 1131 func.storage_class |= STC.inference; 1132 1133 auto sc2 = sc.push(); 1134 sc2.stc &= ~STC.static_; // not a static destructor 1135 sc2.linkage = LINK.d; 1136 1137 ad.members.push(func); 1138 func.addMember(sc2, ad); 1139 func.dsymbolSemantic(sc2); 1140 func.functionSemantic(); // to infer attributes 1141 1142 sc2.pop(); 1143 return func; 1144 } 1145 1146 /****************************************** 1147 * Create inclusive invariant for struct/class by aggregating 1148 * all the invariants in invs[]. 1149 * --- 1150 * void __invariant() const [pure nothrow @trusted] 1151 * { 1152 * invs[0](), invs[1](), ...; 1153 * } 1154 * --- 1155 */ 1156 FuncDeclaration buildInv(AggregateDeclaration ad, Scope* sc) 1157 { 1158 switch (ad.invs.dim) 1159 { 1160 case 0: 1161 return null; 1162 1163 case 1: 1164 // Don't return invs[0] so it has uniquely generated name. 1165 goto default; 1166 1167 default: 1168 Expression e = null; 1169 StorageClass stcx = 0; 1170 StorageClass stc = STC.safe | STC.nothrow_ | STC.pure_ | STC.nogc; 1171 foreach (i, inv; ad.invs) 1172 { 1173 stc = mergeFuncAttrs(stc, inv); 1174 if (stc & STC.disable) 1175 { 1176 // What should do? 1177 } 1178 const stcy = (inv.storage_class & STC.synchronized_) | 1179 (inv.type.mod & MODFlags.shared_ ? STC.shared_ : 0); 1180 if (i == 0) 1181 stcx = stcy; 1182 else if (stcx ^ stcy) 1183 { 1184 version (all) 1185 { 1186 // currently rejects 1187 ad.error(inv.loc, "mixing invariants with different `shared`/`synchronized` qualifiers is not supported"); 1188 e = null; 1189 break; 1190 } 1191 } 1192 e = Expression.combine(e, new CallExp(Loc.initial, new VarExp(Loc.initial, inv, false))); 1193 } 1194 auto inv = new InvariantDeclaration(ad.loc, Loc.initial, stc | stcx, 1195 Id.classInvariant, new ExpStatement(Loc.initial, e)); 1196 ad.members.push(inv); 1197 inv.dsymbolSemantic(sc); 1198 return inv; 1199 } 1200 }