1 /** 2 * Defines a `class` declaration. 3 * 4 * Specification: $(LINK2 https://dlang.org/spec/class.html, Classes) 5 * 6 * Copyright: Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved 7 * Authors: $(LINK2 https://www.digitalmars.com, Walter Bright) 8 * License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) 9 * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/dclass.d, _dclass.d) 10 * Documentation: https://dlang.org/phobos/dmd_dclass.html 11 * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/dclass.d 12 */ 13 14 module dmd.dclass; 15 16 import core.stdc.stdio; 17 import core.stdc.string; 18 19 import dmd.aggregate; 20 import dmd.apply; 21 import dmd.arraytypes; 22 import dmd.astenums; 23 import dmd.attrib; 24 import dmd.gluelayer; 25 import dmd.declaration; 26 import dmd.dscope; 27 import dmd.dsymbol; 28 import dmd.dsymbolsem; 29 import dmd.func; 30 import dmd.globals; 31 import dmd.id; 32 import dmd.identifier; 33 import dmd.location; 34 import dmd.mtype; 35 import dmd.objc; 36 import dmd.root.rmem; 37 import dmd.target; 38 import dmd.visitor; 39 40 /*********************************************************** 41 */ 42 extern (C++) struct BaseClass 43 { 44 Type type; // (before semantic processing) 45 46 ClassDeclaration sym; 47 uint offset; // 'this' pointer offset 48 49 // for interfaces: Array of FuncDeclaration's making up the vtbl[] 50 FuncDeclarations vtbl; 51 52 // if BaseClass is an interface, these 53 // are a copy of the InterfaceDeclaration.interfaces 54 BaseClass[] baseInterfaces; 55 56 extern (D) this(Type type) 57 { 58 //printf("BaseClass(this = %p, '%s')\n", this, type.toChars()); 59 this.type = type; 60 } 61 62 /**************************************** 63 * Fill in vtbl[] for base class based on member functions of class cd. 64 * Input: 65 * vtbl if !=NULL, fill it in 66 * newinstance !=0 means all entries must be filled in by members 67 * of cd, not members of any base classes of cd. 68 * Returns: 69 * true if any entries were filled in by members of cd (not exclusively 70 * by base classes) 71 */ 72 extern (C++) bool fillVtbl(ClassDeclaration cd, FuncDeclarations* vtbl, int newinstance) 73 { 74 bool result = false; 75 76 //printf("BaseClass.fillVtbl(this='%s', cd='%s')\n", sym.toChars(), cd.toChars()); 77 if (vtbl) 78 vtbl.setDim(sym.vtbl.length); 79 80 // first entry is ClassInfo reference 81 for (size_t j = sym.vtblOffset(); j < sym.vtbl.length; j++) 82 { 83 FuncDeclaration ifd = sym.vtbl[j].isFuncDeclaration(); 84 85 //printf(" vtbl[%d] is '%s'\n", j, ifd ? ifd.toChars() : "null"); 86 assert(ifd); 87 88 // Find corresponding function in this class 89 auto tf = ifd.type.toTypeFunction(); 90 auto fd = cd.findFunc(ifd.ident, tf); 91 if (fd && !fd.isAbstract()) 92 { 93 if (fd.toParent() == cd) 94 result = true; 95 } 96 else 97 fd = null; 98 if (vtbl) 99 (*vtbl)[j] = fd; 100 } 101 return result; 102 } 103 104 extern (D) void copyBaseInterfaces(BaseClasses* vtblInterfaces) 105 { 106 //printf("+copyBaseInterfaces(), %s\n", sym.toChars()); 107 // if (baseInterfaces.length) 108 // return; 109 auto bc = cast(BaseClass*)mem.xcalloc(sym.interfaces.length, BaseClass.sizeof); 110 baseInterfaces = bc[0 .. sym.interfaces.length]; 111 //printf("%s.copyBaseInterfaces()\n", sym.toChars()); 112 for (size_t i = 0; i < baseInterfaces.length; i++) 113 { 114 BaseClass* b = &baseInterfaces[i]; 115 BaseClass* b2 = sym.interfaces[i]; 116 117 assert(b2.vtbl.length == 0); // should not be filled yet 118 memcpy(b, b2, BaseClass.sizeof); 119 120 if (i) // single inheritance is i==0 121 vtblInterfaces.push(b); // only need for M.I. 122 b.copyBaseInterfaces(vtblInterfaces); 123 } 124 //printf("-copyBaseInterfaces\n"); 125 } 126 } 127 128 enum ClassFlags : uint 129 { 130 none = 0x0, 131 isCOMclass = 0x1, 132 noPointers = 0x2, 133 hasOffTi = 0x4, 134 hasCtor = 0x8, 135 hasGetMembers = 0x10, 136 hasTypeInfo = 0x20, 137 isAbstract = 0x40, 138 isCPPclass = 0x80, 139 hasDtor = 0x100, 140 } 141 142 /*********************************************************** 143 */ 144 extern (C++) class ClassDeclaration : AggregateDeclaration 145 { 146 extern (C++) __gshared 147 { 148 // Names found by reading object.d in druntime 149 ClassDeclaration object; 150 ClassDeclaration throwable; 151 ClassDeclaration exception; 152 ClassDeclaration errorException; 153 ClassDeclaration cpp_type_info_ptr; // Object.__cpp_type_info_ptr 154 } 155 156 ClassDeclaration baseClass; // NULL only if this is Object 157 FuncDeclaration staticCtor; 158 FuncDeclaration staticDtor; 159 Dsymbols vtbl; // Array of FuncDeclaration's making up the vtbl[] 160 Dsymbols vtblFinal; // More FuncDeclaration's that aren't in vtbl[] 161 162 // Array of BaseClass's; first is super, rest are Interface's 163 BaseClasses* baseclasses; 164 165 /* Slice of baseclasses[] that does not include baseClass 166 */ 167 BaseClass*[] interfaces; 168 169 // array of base interfaces that have their own vtbl[] 170 BaseClasses* vtblInterfaces; 171 172 // the ClassInfo object for this ClassDeclaration 173 TypeInfoClassDeclaration vclassinfo; 174 175 // true if this is a COM class 176 bool com; 177 178 /// true if this is a scope class 179 bool stack; 180 181 /// if this is a C++ class, this is the slot reserved for the virtual destructor 182 int cppDtorVtblIndex = -1; 183 184 /// to prevent recursive attempts 185 private bool inuse; 186 187 ThreeState isabstract; 188 189 /// set the progress of base classes resolving 190 Baseok baseok; 191 192 /** 193 * Data for a class declaration that is needed for the Objective-C 194 * integration. 195 */ 196 ObjcClassDeclaration objc; 197 198 Symbol* cpp_type_info_ptr_sym; // cached instance of class Id.cpp_type_info_ptr 199 200 final extern (D) this(const ref Loc loc, Identifier id, BaseClasses* baseclasses, Dsymbols* members, bool inObject) 201 { 202 objc = ObjcClassDeclaration(this); 203 204 if (!id) 205 id = Identifier.generateAnonymousId("class"); 206 207 super(loc, id); 208 209 static immutable msg = "only object.d can define this reserved class name"; 210 211 if (baseclasses) 212 { 213 // Actually, this is a transfer 214 this.baseclasses = baseclasses; 215 } 216 else 217 this.baseclasses = new BaseClasses(); 218 219 this.members = members; 220 221 //printf("ClassDeclaration(%s), dim = %d\n", ident.toChars(), this.baseclasses.length); 222 223 // For forward references 224 type = new TypeClass(this); 225 226 // Look for special class names 227 if (id == Id.__sizeof || id == Id.__xalignof || id == Id._mangleof) 228 error("illegal class name"); 229 230 // BUG: What if this is the wrong TypeInfo, i.e. it is nested? 231 if (id.toChars()[0] == 'T') 232 { 233 if (id == Id.TypeInfo) 234 { 235 if (!inObject) 236 error("%s", msg.ptr); 237 Type.dtypeinfo = this; 238 } 239 if (id == Id.TypeInfo_Class) 240 { 241 if (!inObject) 242 error("%s", msg.ptr); 243 Type.typeinfoclass = this; 244 } 245 if (id == Id.TypeInfo_Interface) 246 { 247 if (!inObject) 248 error("%s", msg.ptr); 249 Type.typeinfointerface = this; 250 } 251 if (id == Id.TypeInfo_Struct) 252 { 253 if (!inObject) 254 error("%s", msg.ptr); 255 Type.typeinfostruct = this; 256 } 257 if (id == Id.TypeInfo_Pointer) 258 { 259 if (!inObject) 260 error("%s", msg.ptr); 261 Type.typeinfopointer = this; 262 } 263 if (id == Id.TypeInfo_Array) 264 { 265 if (!inObject) 266 error("%s", msg.ptr); 267 Type.typeinfoarray = this; 268 } 269 if (id == Id.TypeInfo_StaticArray) 270 { 271 //if (!inObject) 272 // Type.typeinfostaticarray.error("%s", msg); 273 Type.typeinfostaticarray = this; 274 } 275 if (id == Id.TypeInfo_AssociativeArray) 276 { 277 if (!inObject) 278 error("%s", msg.ptr); 279 Type.typeinfoassociativearray = this; 280 } 281 if (id == Id.TypeInfo_Enum) 282 { 283 if (!inObject) 284 error("%s", msg.ptr); 285 Type.typeinfoenum = this; 286 } 287 if (id == Id.TypeInfo_Function) 288 { 289 if (!inObject) 290 error("%s", msg.ptr); 291 Type.typeinfofunction = this; 292 } 293 if (id == Id.TypeInfo_Delegate) 294 { 295 if (!inObject) 296 error("%s", msg.ptr); 297 Type.typeinfodelegate = this; 298 } 299 if (id == Id.TypeInfo_Tuple) 300 { 301 if (!inObject) 302 error("%s", msg.ptr); 303 Type.typeinfotypelist = this; 304 } 305 if (id == Id.TypeInfo_Const) 306 { 307 if (!inObject) 308 error("%s", msg.ptr); 309 Type.typeinfoconst = this; 310 } 311 if (id == Id.TypeInfo_Invariant) 312 { 313 if (!inObject) 314 error("%s", msg.ptr); 315 Type.typeinfoinvariant = this; 316 } 317 if (id == Id.TypeInfo_Shared) 318 { 319 if (!inObject) 320 error("%s", msg.ptr); 321 Type.typeinfoshared = this; 322 } 323 if (id == Id.TypeInfo_Wild) 324 { 325 if (!inObject) 326 error("%s", msg.ptr); 327 Type.typeinfowild = this; 328 } 329 if (id == Id.TypeInfo_Vector) 330 { 331 if (!inObject) 332 error("%s", msg.ptr); 333 Type.typeinfovector = this; 334 } 335 } 336 337 if (id == Id.Object) 338 { 339 if (!inObject) 340 error("%s", msg.ptr); 341 object = this; 342 } 343 344 if (id == Id.Throwable) 345 { 346 if (!inObject) 347 error("%s", msg.ptr); 348 throwable = this; 349 } 350 if (id == Id.Exception) 351 { 352 if (!inObject) 353 error("%s", msg.ptr); 354 exception = this; 355 } 356 if (id == Id.Error) 357 { 358 if (!inObject) 359 error("%s", msg.ptr); 360 errorException = this; 361 } 362 if (id == Id.cpp_type_info_ptr) 363 { 364 if (!inObject) 365 error("%s", msg.ptr); 366 cpp_type_info_ptr = this; 367 } 368 369 baseok = Baseok.none; 370 } 371 372 static ClassDeclaration create(const ref Loc loc, Identifier id, BaseClasses* baseclasses, Dsymbols* members, bool inObject) 373 { 374 return new ClassDeclaration(loc, id, baseclasses, members, inObject); 375 } 376 377 override const(char)* toPrettyChars(bool qualifyTypes = false) 378 { 379 if (objc.isMeta) 380 return .objc.toPrettyChars(this, qualifyTypes); 381 382 return super.toPrettyChars(qualifyTypes); 383 } 384 385 override ClassDeclaration syntaxCopy(Dsymbol s) 386 { 387 //printf("ClassDeclaration.syntaxCopy('%s')\n", toChars()); 388 ClassDeclaration cd = 389 s ? cast(ClassDeclaration)s 390 : new ClassDeclaration(loc, ident, null, null, false); 391 392 cd.storage_class |= storage_class; 393 394 cd.baseclasses.setDim(this.baseclasses.length); 395 for (size_t i = 0; i < cd.baseclasses.length; i++) 396 { 397 BaseClass* b = (*this.baseclasses)[i]; 398 auto b2 = new BaseClass(b.type.syntaxCopy()); 399 (*cd.baseclasses)[i] = b2; 400 } 401 402 ScopeDsymbol.syntaxCopy(cd); 403 return cd; 404 } 405 406 override Scope* newScope(Scope* sc) 407 { 408 auto sc2 = super.newScope(sc); 409 if (isCOMclass()) 410 { 411 /* This enables us to use COM objects under Linux and 412 * work with things like XPCOM 413 */ 414 sc2.linkage = target.systemLinkage(); 415 } 416 return sc2; 417 } 418 419 /********************************************* 420 * Determine if 'this' is a base class of cd. 421 * This is used to detect circular inheritance only. 422 */ 423 final bool isBaseOf2(ClassDeclaration cd) pure nothrow @nogc 424 { 425 if (!cd) 426 return false; 427 //printf("ClassDeclaration.isBaseOf2(this = '%s', cd = '%s')\n", toChars(), cd.toChars()); 428 for (size_t i = 0; i < cd.baseclasses.length; i++) 429 { 430 BaseClass* b = (*cd.baseclasses)[i]; 431 if (b.sym == this || isBaseOf2(b.sym)) 432 return true; 433 } 434 return false; 435 } 436 437 enum OFFSET_RUNTIME = 0x76543210; 438 enum OFFSET_FWDREF = 0x76543211; 439 440 /******************************************* 441 * Determine if 'this' is a base class of cd. 442 */ 443 bool isBaseOf(ClassDeclaration cd, int* poffset) pure nothrow @nogc 444 { 445 //printf("ClassDeclaration.isBaseOf(this = '%s', cd = '%s')\n", toChars(), cd.toChars()); 446 if (poffset) 447 *poffset = 0; 448 while (cd) 449 { 450 assert(cd.baseClass || cd.semanticRun >= PASS.semanticdone || cd.isInterfaceDeclaration()); 451 if (this == cd.baseClass) 452 return true; 453 454 cd = cd.baseClass; 455 } 456 return false; 457 } 458 459 /********************************************* 460 * Determine if 'this' has complete base class information. 461 * This is used to detect forward references in covariant overloads. 462 */ 463 final bool isBaseInfoComplete() const 464 { 465 return baseok >= Baseok.done; 466 } 467 468 override final Dsymbol search(const ref Loc loc, Identifier ident, int flags = SearchLocalsOnly) 469 { 470 //printf("%s.ClassDeclaration.search('%s', flags=x%x)\n", toChars(), ident.toChars(), flags); 471 //if (_scope) printf("%s baseok = %d\n", toChars(), baseok); 472 if (_scope && baseok < Baseok.semanticdone) 473 { 474 if (!inuse) 475 { 476 // must semantic on base class/interfaces 477 inuse = true; 478 dsymbolSemantic(this, null); 479 inuse = false; 480 } 481 } 482 483 if (!members || !symtab) // opaque or addMember is not yet done 484 { 485 // .stringof is always defined (but may be hidden by some other symbol) 486 if (ident != Id.stringof && !(flags & IgnoreErrors) && semanticRun < PASS.semanticdone) 487 error("is forward referenced when looking for `%s`", ident.toChars()); 488 //*(char*)0=0; 489 return null; 490 } 491 492 auto s = ScopeDsymbol.search(loc, ident, flags); 493 494 // don't search imports of base classes 495 if (flags & SearchImportsOnly) 496 return s; 497 498 if (s) 499 return s; 500 501 // Search bases classes in depth-first, left to right order 502 foreach (b; (*baseclasses)[]) 503 { 504 if (!b.sym) 505 continue; 506 507 if (!b.sym.symtab) 508 { 509 error("base `%s` is forward referenced", b.sym.ident.toChars()); 510 continue; 511 } 512 513 import dmd.access : symbolIsVisible; 514 515 s = b.sym.search(loc, ident, flags); 516 if (!s) 517 continue; 518 else if (s == this) // happens if s is nested in this and derives from this 519 s = null; 520 else if (!(flags & IgnoreSymbolVisibility) && !(s.visible().kind == Visibility.Kind.protected_) && !symbolIsVisible(this, s)) 521 s = null; 522 else 523 break; 524 } 525 526 return s; 527 } 528 529 /************************************ 530 * Search base classes in depth-first, left-to-right order for 531 * a class or interface named 'ident'. 532 * Stops at first found. Does not look for additional matches. 533 * Params: 534 * ident = identifier to search for 535 * Returns: 536 * ClassDeclaration if found, null if not 537 */ 538 final ClassDeclaration searchBase(Identifier ident) 539 { 540 foreach (b; *baseclasses) 541 { 542 auto cdb = b.type.isClassHandle(); 543 if (!cdb) // https://issues.dlang.org/show_bug.cgi?id=10616 544 return null; 545 if (cdb.ident.equals(ident)) 546 return cdb; 547 auto result = cdb.searchBase(ident); 548 if (result) 549 return result; 550 } 551 return null; 552 } 553 554 final override void finalizeSize() 555 { 556 assert(sizeok != Sizeok.done); 557 558 // Set the offsets of the fields and determine the size of the class 559 if (baseClass) 560 { 561 assert(baseClass.sizeok == Sizeok.done); 562 563 alignsize = baseClass.alignsize; 564 if (classKind == ClassKind.cpp) 565 structsize = target.cpp.derivedClassOffset(baseClass); 566 else 567 structsize = baseClass.structsize; 568 } 569 else if (classKind == ClassKind.objc) 570 structsize = 0; // no hidden member for an Objective-C class 571 else if (isInterfaceDeclaration()) 572 { 573 if (interfaces.length == 0) 574 { 575 alignsize = target.ptrsize; 576 structsize = target.ptrsize; // allow room for __vptr 577 } 578 } 579 else 580 { 581 alignsize = target.ptrsize; 582 structsize = target.ptrsize; // allow room for __vptr 583 if (hasMonitor()) 584 structsize += target.ptrsize; // allow room for __monitor 585 } 586 587 //printf("finalizeSize() %s, sizeok = %d\n", toChars(), sizeok); 588 size_t bi = 0; // index into vtblInterfaces[] 589 590 /**** 591 * Runs through the inheritance graph to set the BaseClass.offset fields. 592 * Recursive in order to account for the size of the interface classes, if they are 593 * more than just interfaces. 594 * Params: 595 * cd = interface to look at 596 * baseOffset = offset of where cd will be placed 597 * Returns: 598 * subset of instantiated size used by cd for interfaces 599 */ 600 uint membersPlace(ClassDeclaration cd, uint baseOffset) 601 { 602 //printf(" membersPlace(%s, %d)\n", cd.toChars(), baseOffset); 603 uint offset = baseOffset; 604 605 foreach (BaseClass* b; cd.interfaces) 606 { 607 if (b.sym.sizeok != Sizeok.done) 608 b.sym.finalizeSize(); 609 assert(b.sym.sizeok == Sizeok.done); 610 611 if (!b.sym.alignsize) 612 b.sym.alignsize = target.ptrsize; 613 alignmember(structalign_t(cast(ushort)b.sym.alignsize), b.sym.alignsize, &offset); 614 assert(bi < vtblInterfaces.length); 615 616 BaseClass* bv = (*vtblInterfaces)[bi]; 617 if (b.sym.interfaces.length == 0) 618 { 619 //printf("\tvtblInterfaces[%d] b=%p b.sym = %s, offset = %d\n", bi, bv, bv.sym.toChars(), offset); 620 bv.offset = offset; 621 ++bi; 622 // All the base interfaces down the left side share the same offset 623 for (BaseClass* b2 = bv; b2.baseInterfaces.length; ) 624 { 625 b2 = &b2.baseInterfaces[0]; 626 b2.offset = offset; 627 //printf("\tvtblInterfaces[%d] b=%p sym = %s, offset = %d\n", bi, b2, b2.sym.toChars(), b2.offset); 628 } 629 } 630 membersPlace(b.sym, offset); 631 //printf(" %s size = %d\n", b.sym.toChars(), b.sym.structsize); 632 offset += b.sym.structsize; 633 if (alignsize < b.sym.alignsize) 634 alignsize = b.sym.alignsize; 635 } 636 return offset - baseOffset; 637 } 638 639 structsize += membersPlace(this, structsize); 640 641 if (isInterfaceDeclaration()) 642 { 643 sizeok = Sizeok.done; 644 return; 645 } 646 647 // FIXME: Currently setFieldOffset functions need to increase fields 648 // to calculate each variable offsets. It can be improved later. 649 fields.setDim(0); 650 651 FieldState fieldState; 652 fieldState.offset = structsize; 653 foreach (s; *members) 654 { 655 s.setFieldOffset(this, fieldState, false); 656 } 657 658 sizeok = Sizeok.done; 659 660 // Calculate fields[i].overlapped 661 checkOverlappedFields(); 662 } 663 664 /************** 665 * Returns: true if there's a __monitor field 666 */ 667 final bool hasMonitor() 668 { 669 return classKind == ClassKind.d; 670 } 671 672 final bool isFuncHidden(FuncDeclaration fd) 673 { 674 //printf("ClassDeclaration.isFuncHidden(class = %s, fd = %s)\n", toChars(), fd.toPrettyChars()); 675 Dsymbol s = search(Loc.initial, fd.ident, IgnoreAmbiguous | IgnoreErrors); 676 if (!s) 677 { 678 //printf("not found\n"); 679 /* Because, due to a hack, if there are multiple definitions 680 * of fd.ident, NULL is returned. 681 */ 682 return false; 683 } 684 s = s.toAlias(); 685 if (auto os = s.isOverloadSet()) 686 { 687 foreach (sm; os.a) 688 { 689 auto fm = sm.isFuncDeclaration(); 690 if (overloadApply(fm, s => fd == s.isFuncDeclaration())) 691 return false; 692 } 693 return true; 694 } 695 else 696 { 697 auto f = s.isFuncDeclaration(); 698 //printf("%s fdstart = %p\n", s.kind(), fdstart); 699 if (overloadApply(f, s => fd == s.isFuncDeclaration())) 700 return false; 701 return !fd.parent.isTemplateMixin(); 702 } 703 } 704 705 /**************** 706 * Find virtual function matching identifier and type. 707 * Used to build virtual function tables for interface implementations. 708 * Params: 709 * ident = function's identifier 710 * tf = function's type 711 * Returns: 712 * function symbol if found, null if not 713 * Errors: 714 * prints error message if more than one match 715 */ 716 final FuncDeclaration findFunc(Identifier ident, TypeFunction tf) 717 { 718 //printf("ClassDeclaration.findFunc(%s, %s) %s\n", ident.toChars(), tf.toChars(), toChars()); 719 FuncDeclaration fdmatch = null; 720 FuncDeclaration fdambig = null; 721 722 void updateBestMatch(FuncDeclaration fd) 723 { 724 fdmatch = fd; 725 fdambig = null; 726 //printf("Lfd fdmatch = %s %s [%s]\n", fdmatch.toChars(), fdmatch.type.toChars(), fdmatch.loc.toChars()); 727 } 728 729 void searchVtbl(ref Dsymbols vtbl) 730 { 731 bool seenInterfaceVirtual; 732 foreach (s; vtbl) 733 { 734 auto fd = s.isFuncDeclaration(); 735 if (!fd) 736 continue; 737 738 // the first entry might be a ClassInfo 739 //printf("\t[%d] = %s\n", i, fd.toChars()); 740 if (ident != fd.ident || fd.type.covariant(tf) != Covariant.yes) 741 { 742 //printf("\t\t%d\n", fd.type.covariant(tf)); 743 continue; 744 } 745 746 //printf("fd.parent.isClassDeclaration() = %p\n", fd.parent.isClassDeclaration()); 747 if (!fdmatch) 748 { 749 updateBestMatch(fd); 750 continue; 751 } 752 if (fd == fdmatch) 753 continue; 754 755 /* Functions overriding interface functions for extern(C++) with VC++ 756 * are not in the normal vtbl, but in vtblFinal. If the implementation 757 * is again overridden in a child class, both would be found here. 758 * The function in the child class should override the function 759 * in the base class, which is done here, because searchVtbl is first 760 * called for the child class. Checking seenInterfaceVirtual makes 761 * sure, that the compared functions are not in the same vtbl. 762 */ 763 if (fd.interfaceVirtual && 764 fd.interfaceVirtual is fdmatch.interfaceVirtual && 765 !seenInterfaceVirtual && 766 fdmatch.type.covariant(fd.type) == Covariant.yes) 767 { 768 seenInterfaceVirtual = true; 769 continue; 770 } 771 772 { 773 // Function type matching: exact > covariant 774 MATCH m1 = tf.equals(fd.type) ? MATCH.exact : MATCH.nomatch; 775 MATCH m2 = tf.equals(fdmatch.type) ? MATCH.exact : MATCH.nomatch; 776 if (m1 > m2) 777 { 778 updateBestMatch(fd); 779 continue; 780 } 781 else if (m1 < m2) 782 continue; 783 } 784 { 785 MATCH m1 = (tf.mod == fd.type.mod) ? MATCH.exact : MATCH.nomatch; 786 MATCH m2 = (tf.mod == fdmatch.type.mod) ? MATCH.exact : MATCH.nomatch; 787 if (m1 > m2) 788 { 789 updateBestMatch(fd); 790 continue; 791 } 792 else if (m1 < m2) 793 continue; 794 } 795 { 796 // The way of definition: non-mixin > mixin 797 MATCH m1 = fd.parent.isClassDeclaration() ? MATCH.exact : MATCH.nomatch; 798 MATCH m2 = fdmatch.parent.isClassDeclaration() ? MATCH.exact : MATCH.nomatch; 799 if (m1 > m2) 800 { 801 updateBestMatch(fd); 802 continue; 803 } 804 else if (m1 < m2) 805 continue; 806 } 807 808 fdambig = fd; 809 //printf("Lambig fdambig = %s %s [%s]\n", fdambig.toChars(), fdambig.type.toChars(), fdambig.loc.toChars()); 810 } 811 } 812 813 searchVtbl(vtbl); 814 for (auto cd = this; cd; cd = cd.baseClass) 815 { 816 searchVtbl(cd.vtblFinal); 817 } 818 819 if (fdambig) 820 error("ambiguous virtual function `%s`", fdambig.toChars()); 821 822 return fdmatch; 823 } 824 825 /**************************************** 826 */ 827 final bool isCOMclass() const 828 { 829 return com; 830 } 831 832 bool isCOMinterface() const 833 { 834 return false; 835 } 836 837 final bool isCPPclass() const 838 { 839 return classKind == ClassKind.cpp; 840 } 841 842 bool isCPPinterface() const 843 { 844 return false; 845 } 846 847 /**************************************** 848 */ 849 final bool isAbstract() 850 { 851 enum log = false; 852 if (isabstract != ThreeState.none) 853 return isabstract == ThreeState.yes; 854 855 if (log) printf("isAbstract(%s)\n", toChars()); 856 857 bool no() { if (log) printf("no\n"); isabstract = ThreeState.no; return false; } 858 bool yes() { if (log) printf("yes\n"); isabstract = ThreeState.yes; return true; } 859 860 if (storage_class & STC.abstract_ || _scope && _scope.stc & STC.abstract_) 861 return yes(); 862 863 if (errors) 864 return no(); 865 866 /* https://issues.dlang.org/show_bug.cgi?id=11169 867 * Resolve forward references to all class member functions, 868 * and determine whether this class is abstract. 869 */ 870 static int func(Dsymbol s) 871 { 872 auto fd = s.isFuncDeclaration(); 873 if (!fd) 874 return 0; 875 if (fd.storage_class & STC.static_) 876 return 0; 877 878 if (fd.isAbstract()) 879 return 1; 880 return 0; 881 } 882 883 for (size_t i = 0; i < members.length; i++) 884 { 885 auto s = (*members)[i]; 886 if (s.apply(&func)) 887 { 888 return yes(); 889 } 890 } 891 892 /* If the base class is not abstract, then this class cannot 893 * be abstract. 894 */ 895 if (!isInterfaceDeclaration() && (!baseClass || !baseClass.isAbstract())) 896 return no(); 897 898 /* If any abstract functions are inherited, but not overridden, 899 * then the class is abstract. Do this by checking the vtbl[]. 900 * Need to do semantic() on class to fill the vtbl[]. 901 */ 902 this.dsymbolSemantic(null); 903 904 /* The next line should work, but does not because when ClassDeclaration.dsymbolSemantic() 905 * is called recursively it can set PASS.semanticdone without finishing it. 906 */ 907 //if (semanticRun < PASS.semanticdone) 908 { 909 /* Could not complete semantic(). Try running semantic() on 910 * each of the virtual functions, 911 * which will fill in the vtbl[] overrides. 912 */ 913 static int virtualSemantic(Dsymbol s) 914 { 915 auto fd = s.isFuncDeclaration(); 916 if (fd && !(fd.storage_class & STC.static_) && !fd.isUnitTestDeclaration()) 917 fd.dsymbolSemantic(null); 918 return 0; 919 } 920 921 for (size_t i = 0; i < members.length; i++) 922 { 923 auto s = (*members)[i]; 924 s.apply(&virtualSemantic); 925 } 926 } 927 928 /* Finally, check the vtbl[] 929 */ 930 foreach (i; 1 .. vtbl.length) 931 { 932 auto fd = vtbl[i].isFuncDeclaration(); 933 //if (fd) printf("\tvtbl[%d] = [%s] %s\n", i, fd.loc.toChars(), fd.toPrettyChars()); 934 if (!fd || fd.isAbstract()) 935 { 936 return yes(); 937 } 938 } 939 940 return no(); 941 } 942 943 /**************************************** 944 * Determine if slot 0 of the vtbl[] is reserved for something else. 945 * For class objects, yes, this is where the classinfo ptr goes. 946 * For COM interfaces, no. 947 * For non-COM interfaces, yes, this is where the Interface ptr goes. 948 * Returns: 949 * 0 vtbl[0] is first virtual function pointer 950 * 1 vtbl[0] is classinfo/interfaceinfo pointer 951 */ 952 int vtblOffset() const 953 { 954 return classKind == ClassKind.cpp ? 0 : 1; 955 } 956 957 /**************************************** 958 */ 959 override const(char)* kind() const 960 { 961 return "class"; 962 } 963 964 /**************************************** 965 */ 966 override final void addObjcSymbols(ClassDeclarations* classes, ClassDeclarations* categories) 967 { 968 .objc.addSymbols(this, classes, categories); 969 } 970 971 // Back end 972 Dsymbol vtblsym; 973 974 final Dsymbol vtblSymbol() 975 { 976 if (!vtblsym) 977 { 978 auto vtype = Type.tvoidptr.immutableOf().sarrayOf(vtbl.length); 979 auto var = new VarDeclaration(loc, vtype, Identifier.idPool("__vtbl"), null, STC.immutable_ | STC.static_); 980 var.addMember(null, this); 981 var.isdataseg = 1; 982 var._linkage = LINK.d; 983 var.semanticRun = PASS.semanticdone; // no more semantic wanted 984 vtblsym = var; 985 } 986 return vtblsym; 987 } 988 989 extern (D) final bool isErrorException() 990 { 991 return errorException && (this == errorException || errorException.isBaseOf(this, null)); 992 } 993 994 override final inout(ClassDeclaration) isClassDeclaration() inout @nogc nothrow pure @safe 995 { 996 return this; 997 } 998 999 override void accept(Visitor v) 1000 { 1001 v.visit(this); 1002 } 1003 } 1004 1005 /*********************************************************** 1006 */ 1007 extern (C++) final class InterfaceDeclaration : ClassDeclaration 1008 { 1009 extern (D) this(const ref Loc loc, Identifier id, BaseClasses* baseclasses) 1010 { 1011 super(loc, id, baseclasses, null, false); 1012 if (id == Id.IUnknown) // IUnknown is the root of all COM interfaces 1013 { 1014 com = true; 1015 classKind = ClassKind.cpp; // IUnknown is also a C++ interface 1016 } 1017 } 1018 1019 override InterfaceDeclaration syntaxCopy(Dsymbol s) 1020 { 1021 InterfaceDeclaration id = 1022 s ? cast(InterfaceDeclaration)s 1023 : new InterfaceDeclaration(loc, ident, null); 1024 ClassDeclaration.syntaxCopy(id); 1025 return id; 1026 } 1027 1028 1029 override Scope* newScope(Scope* sc) 1030 { 1031 auto sc2 = super.newScope(sc); 1032 if (com) 1033 sc2.linkage = LINK.windows; 1034 else if (classKind == ClassKind.cpp) 1035 sc2.linkage = LINK.cpp; 1036 else if (classKind == ClassKind.objc) 1037 sc2.linkage = LINK.objc; 1038 return sc2; 1039 } 1040 1041 /******************************************* 1042 * Determine if 'this' is a base class of cd. 1043 * (Actually, if it is an interface supported by cd) 1044 * Output: 1045 * *poffset offset to start of class 1046 * OFFSET_RUNTIME must determine offset at runtime 1047 * Returns: 1048 * false not a base 1049 * true is a base 1050 */ 1051 override bool isBaseOf(ClassDeclaration cd, int* poffset) pure nothrow @nogc 1052 { 1053 //printf("%s.InterfaceDeclaration.isBaseOf(cd = '%s')\n", toChars(), cd.toChars()); 1054 assert(!baseClass); 1055 foreach (b; cd.interfaces) 1056 { 1057 //printf("\tX base %s\n", b.sym.toChars()); 1058 if (this == b.sym) 1059 { 1060 //printf("\tfound at offset %d\n", b.offset); 1061 if (poffset) 1062 { 1063 // don't return incorrect offsets 1064 // https://issues.dlang.org/show_bug.cgi?id=16980 1065 *poffset = cd.sizeok == Sizeok.done ? b.offset : OFFSET_FWDREF; 1066 } 1067 // printf("\tfound at offset %d\n", b.offset); 1068 return true; 1069 } 1070 if (baseClassImplementsInterface(this, b, poffset)) 1071 return true; 1072 } 1073 if (cd.baseClass && isBaseOf(cd.baseClass, poffset)) 1074 return true; 1075 1076 if (poffset) 1077 *poffset = 0; 1078 return false; 1079 } 1080 1081 /******************************************* 1082 */ 1083 override const(char)* kind() const 1084 { 1085 return "interface"; 1086 } 1087 1088 /**************************************** 1089 * Determine if slot 0 of the vtbl[] is reserved for something else. 1090 * For class objects, yes, this is where the ClassInfo ptr goes. 1091 * For COM interfaces, no. 1092 * For non-COM interfaces, yes, this is where the Interface ptr goes. 1093 */ 1094 override int vtblOffset() const 1095 { 1096 if (isCOMinterface() || isCPPinterface()) 1097 return 0; 1098 return 1; 1099 } 1100 1101 override bool isCPPinterface() const 1102 { 1103 return classKind == ClassKind.cpp; 1104 } 1105 1106 override bool isCOMinterface() const 1107 { 1108 return com; 1109 } 1110 1111 override inout(InterfaceDeclaration) isInterfaceDeclaration() inout 1112 { 1113 return this; 1114 } 1115 1116 override void accept(Visitor v) 1117 { 1118 v.visit(this); 1119 } 1120 } 1121 1122 /** 1123 * Returns whether `bc` implements `id`, including indirectly (`bc` implements an interfaces 1124 * that inherits from `id`) 1125 * 1126 * Params: 1127 * id = the interface 1128 * bc = the base class 1129 * poffset = out parameter, offset of the interface in an object 1130 * 1131 * Returns: 1132 * true if the `bc` implements `id`, false otherwise 1133 **/ 1134 private bool baseClassImplementsInterface(InterfaceDeclaration id, BaseClass* bc, int* poffset) pure nothrow @nogc 1135 { 1136 //printf("%s.InterfaceDeclaration.isBaseOf(bc = '%s')\n", id.toChars(), bc.sym.toChars()); 1137 for (size_t j = 0; j < bc.baseInterfaces.length; j++) 1138 { 1139 BaseClass* b = &bc.baseInterfaces[j]; 1140 //printf("\tY base %s\n", b.sym.toChars()); 1141 if (id == b.sym) 1142 { 1143 //printf("\tfound at offset %d\n", b.offset); 1144 if (poffset) 1145 { 1146 *poffset = b.offset; 1147 } 1148 return true; 1149 } 1150 if (baseClassImplementsInterface(id, b, poffset)) 1151 { 1152 return true; 1153 } 1154 } 1155 1156 if (poffset) 1157 *poffset = 0; 1158 return false; 1159 }