1 /** 2 * The base class for a D symbol, which can be a module, variable, function, enum, etc. 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/dsymbol.d, _dsymbol.d) 8 * Documentation: https://dlang.org/phobos/dmd_dsymbol.html 9 * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/dsymbol.d 10 */ 11 12 module dmd.dsymbol; 13 14 import core.stdc.stdarg; 15 import core.stdc.stdio; 16 import core.stdc.string; 17 import core.stdc.stdlib; 18 19 import dmd.aggregate; 20 import dmd.aliasthis; 21 import dmd.arraytypes; 22 import dmd.attrib; 23 import dmd.ast_node; 24 import dmd.gluelayer; 25 import dmd.dclass; 26 import dmd.declaration; 27 import dmd.denum; 28 import dmd.dimport; 29 import dmd.dmodule; 30 import dmd.dscope; 31 import dmd.dstruct; 32 import dmd.dsymbolsem; 33 import dmd.dtemplate; 34 import dmd.errors; 35 import dmd.expression; 36 import dmd.expressionsem; 37 import dmd.func; 38 import dmd.globals; 39 import dmd.id; 40 import dmd.identifier; 41 import dmd.init; 42 import dmd.lexer; 43 import dmd.mtype; 44 import dmd.nspace; 45 import dmd.opover; 46 import dmd.root.aav; 47 import dmd.root.rmem; 48 import dmd.root.rootobject; 49 import dmd.root.speller; 50 import dmd.root.string; 51 import dmd.statement; 52 import dmd.tokens; 53 import dmd.visitor; 54 55 /*************************************** 56 * Calls dg(Dsymbol *sym) for each Dsymbol. 57 * If dg returns !=0, stops and returns that value else returns 0. 58 * Params: 59 * symbols = Dsymbols 60 * dg = delegate to call for each Dsymbol 61 * Returns: 62 * last value returned by dg() 63 */ 64 int foreachDsymbol(Dsymbols* symbols, scope int delegate(Dsymbol) dg) 65 { 66 assert(dg); 67 if (symbols) 68 { 69 /* Do not use foreach, as the size of the array may expand during iteration 70 */ 71 for (size_t i = 0; i < symbols.dim; ++i) 72 { 73 Dsymbol s = (*symbols)[i]; 74 const result = dg(s); 75 if (result) 76 return result; 77 } 78 } 79 return 0; 80 } 81 82 /*************************************** 83 * Calls dg(Dsymbol *sym) for each Dsymbol. 84 * Params: 85 * symbols = Dsymbols 86 * dg = delegate to call for each Dsymbol 87 */ 88 void foreachDsymbol(Dsymbols* symbols, scope void delegate(Dsymbol) dg) 89 { 90 assert(dg); 91 if (symbols) 92 { 93 /* Do not use foreach, as the size of the array may expand during iteration 94 */ 95 for (size_t i = 0; i < symbols.dim; ++i) 96 { 97 Dsymbol s = (*symbols)[i]; 98 dg(s); 99 } 100 } 101 } 102 103 104 struct Ungag 105 { 106 uint oldgag; 107 108 extern (D) this(uint old) 109 { 110 this.oldgag = old; 111 } 112 113 extern (C++) ~this() 114 { 115 global.gag = oldgag; 116 } 117 } 118 119 struct Prot 120 { 121 /// 122 enum Kind : int 123 { 124 undefined, 125 none, // no access 126 private_, 127 package_, 128 protected_, 129 public_, 130 export_, 131 } 132 133 Kind kind; 134 Package pkg; 135 136 extern (D) this(Prot.Kind kind) pure nothrow @nogc @safe 137 { 138 this.kind = kind; 139 } 140 141 extern (C++): 142 143 /** 144 * Checks if `this` is superset of `other` restrictions. 145 * For example, "protected" is more restrictive than "public". 146 */ 147 bool isMoreRestrictiveThan(const Prot other) const 148 { 149 return this.kind < other.kind; 150 } 151 152 /** 153 * Checks if `this` is absolutely identical protection attribute to `other` 154 */ 155 bool opEquals(ref const Prot other) const 156 { 157 if (this.kind == other.kind) 158 { 159 if (this.kind == Prot.Kind.package_) 160 return this.pkg == other.pkg; 161 return true; 162 } 163 return false; 164 } 165 166 /** 167 * Checks if parent defines different access restrictions than this one. 168 * 169 * Params: 170 * parent = protection attribute for scope that hosts this one 171 * 172 * Returns: 173 * 'true' if parent is already more restrictive than this one and thus 174 * no differentiation is needed. 175 */ 176 bool isSubsetOf(ref const Prot parent) const 177 { 178 if (this.kind != parent.kind) 179 return false; 180 if (this.kind == Prot.Kind.package_) 181 { 182 if (!this.pkg) 183 return true; 184 if (!parent.pkg) 185 return false; 186 if (parent.pkg.isAncestorPackageOf(this.pkg)) 187 return true; 188 } 189 return true; 190 } 191 } 192 193 enum PASS : int 194 { 195 init, // initial state 196 semantic, // semantic() started 197 semanticdone, // semantic() done 198 semantic2, // semantic2() started 199 semantic2done, // semantic2() done 200 semantic3, // semantic3() started 201 semantic3done, // semantic3() done 202 inline, // inline started 203 inlinedone, // inline done 204 obj, // toObjFile() run 205 } 206 207 // Search options 208 enum : int 209 { 210 IgnoreNone = 0x00, // default 211 IgnorePrivateImports = 0x01, // don't search private imports 212 IgnoreErrors = 0x02, // don't give error messages 213 IgnoreAmbiguous = 0x04, // return NULL if ambiguous 214 SearchLocalsOnly = 0x08, // only look at locals (don't search imports) 215 SearchImportsOnly = 0x10, // only look in imports 216 SearchUnqualifiedModule = 0x20, // the module scope search is unqualified, 217 // meaning don't search imports in that scope, 218 // because qualified module searches search 219 // their imports 220 IgnoreSymbolVisibility = 0x80, // also find private and package protected symbols 221 } 222 223 /*********************************************************** 224 */ 225 extern (C++) class Dsymbol : ASTNode 226 { 227 Identifier ident; 228 Dsymbol parent; 229 /// C++ namespace this symbol belongs to 230 CPPNamespaceDeclaration cppnamespace; 231 Symbol* csym; // symbol for code generator 232 Symbol* isym; // import version of csym 233 const(char)* comment; // documentation comment for this Dsymbol 234 const Loc loc; // where defined 235 Scope* _scope; // !=null means context to use for semantic() 236 const(char)* prettystring; // cached value of toPrettyChars() 237 bool errors; // this symbol failed to pass semantic() 238 PASS semanticRun = PASS.init; 239 240 DeprecatedDeclaration depdecl; // customized deprecation message 241 UserAttributeDeclaration userAttribDecl; // user defined attributes 242 243 // !=null means there's a ddoc unittest associated with this symbol 244 // (only use this with ddoc) 245 UnitTestDeclaration ddocUnittest; 246 247 final extern (D) this() 248 { 249 //printf("Dsymbol::Dsymbol(%p)\n", this); 250 loc = Loc(null, 0, 0); 251 } 252 253 final extern (D) this(Identifier ident) 254 { 255 //printf("Dsymbol::Dsymbol(%p, ident)\n", this); 256 this.loc = Loc(null, 0, 0); 257 this.ident = ident; 258 } 259 260 final extern (D) this(const ref Loc loc, Identifier ident) 261 { 262 //printf("Dsymbol::Dsymbol(%p, ident)\n", this); 263 this.loc = loc; 264 this.ident = ident; 265 } 266 267 static Dsymbol create(Identifier ident) 268 { 269 return new Dsymbol(ident); 270 } 271 272 override const(char)* toChars() const 273 { 274 return ident ? ident.toChars() : "__anonymous"; 275 } 276 277 // helper to print fully qualified (template) arguments 278 const(char)* toPrettyCharsHelper() 279 { 280 return toChars(); 281 } 282 283 final const(Loc) getLoc() 284 { 285 if (!loc.isValid()) // avoid bug 5861. 286 if (const m = getModule()) 287 return Loc(m.srcfile.toChars(), 0, 0); 288 return loc; 289 } 290 291 final const(char)* locToChars() 292 { 293 return getLoc().toChars(); 294 } 295 296 override bool equals(const RootObject o) const 297 { 298 if (this == o) 299 return true; 300 if (o.dyncast() != DYNCAST.dsymbol) 301 return false; 302 auto s = cast(Dsymbol)o; 303 // Overload sets don't have an ident 304 if (s && ident && s.ident && ident.equals(s.ident)) 305 return true; 306 return false; 307 } 308 309 bool isAnonymous() 310 { 311 return ident is null; 312 } 313 314 extern(D) private const(char)[] prettyFormatHelper() 315 { 316 const cstr = toPrettyChars(); 317 return '`' ~ cstr.toDString() ~ "`\0"; 318 } 319 320 final void error(const ref Loc loc, const(char)* format, ...) 321 { 322 va_list ap; 323 va_start(ap, format); 324 .verror(loc, format, ap, kind(), prettyFormatHelper().ptr); 325 va_end(ap); 326 } 327 328 final void error(const(char)* format, ...) 329 { 330 va_list ap; 331 va_start(ap, format); 332 const loc = getLoc(); 333 .verror(loc, format, ap, kind(), prettyFormatHelper().ptr); 334 va_end(ap); 335 } 336 337 final void deprecation(const ref Loc loc, const(char)* format, ...) 338 { 339 va_list ap; 340 va_start(ap, format); 341 .vdeprecation(loc, format, ap, kind(), prettyFormatHelper().ptr); 342 va_end(ap); 343 } 344 345 final void deprecation(const(char)* format, ...) 346 { 347 va_list ap; 348 va_start(ap, format); 349 const loc = getLoc(); 350 .vdeprecation(loc, format, ap, kind(), prettyFormatHelper().ptr); 351 va_end(ap); 352 } 353 354 final bool checkDeprecated(const ref Loc loc, Scope* sc) 355 { 356 if (global.params.useDeprecated == DiagnosticReporting.off) 357 return false; 358 if (!this.isDeprecated()) 359 return false; 360 // Don't complain if we're inside a deprecated symbol's scope 361 if (sc.isDeprecated()) 362 return false; 363 364 const(char)* message = null; 365 for (Dsymbol p = this; p; p = p.parent) 366 { 367 message = p.depdecl ? p.depdecl.getMessage() : null; 368 if (message) 369 break; 370 } 371 if (message) 372 deprecation(loc, "is deprecated - %s", message); 373 else 374 deprecation(loc, "is deprecated"); 375 376 return true; 377 } 378 379 /********************************** 380 * Determine which Module a Dsymbol is in. 381 */ 382 final Module getModule() 383 { 384 //printf("Dsymbol::getModule()\n"); 385 if (TemplateInstance ti = isInstantiated()) 386 return ti.tempdecl.getModule(); 387 Dsymbol s = this; 388 while (s) 389 { 390 //printf("\ts = %s '%s'\n", s.kind(), s.toPrettyChars()); 391 Module m = s.isModule(); 392 if (m) 393 return m; 394 s = s.parent; 395 } 396 return null; 397 } 398 399 /********************************** 400 * Determine which Module a Dsymbol is in, as far as access rights go. 401 */ 402 final Module getAccessModule() 403 { 404 //printf("Dsymbol::getAccessModule()\n"); 405 if (TemplateInstance ti = isInstantiated()) 406 return ti.tempdecl.getAccessModule(); 407 Dsymbol s = this; 408 while (s) 409 { 410 //printf("\ts = %s '%s'\n", s.kind(), s.toPrettyChars()); 411 Module m = s.isModule(); 412 if (m) 413 return m; 414 TemplateInstance ti = s.isTemplateInstance(); 415 if (ti && ti.enclosing) 416 { 417 /* Because of local template instantiation, the parent isn't where the access 418 * rights come from - it's the template declaration 419 */ 420 s = ti.tempdecl; 421 } 422 else 423 s = s.parent; 424 } 425 return null; 426 } 427 428 /** 429 * `pastMixin` returns the enclosing symbol if this is a template mixin. 430 * 431 * `pastMixinAndNspace` does likewise, additionally skipping over Nspaces that 432 * are mangleOnly. 433 * 434 * See also `parent`, `toParent` and `toParent2`. 435 */ 436 final inout(Dsymbol) pastMixin() inout 437 { 438 //printf("Dsymbol::pastMixin() %s\n", toChars()); 439 if (!isTemplateMixin() && !isForwardingAttribDeclaration() && !isForwardingScopeDsymbol()) 440 return this; 441 if (!parent) 442 return null; 443 return parent.pastMixin(); 444 } 445 446 /********************************** 447 * `parent` field returns a lexically enclosing scope symbol this is a member of. 448 * 449 * `toParent()` returns a logically enclosing scope symbol this is a member of. 450 * It skips over TemplateMixin's. 451 * 452 * `toParent2()` returns an enclosing scope symbol this is living at runtime. 453 * It skips over both TemplateInstance's and TemplateMixin's. 454 * It's used when looking for the 'this' pointer of the enclosing function/class. 455 * 456 * `toParentDecl()` similar to `toParent2()` but always follows the template declaration scope 457 * instead of the instantiation scope. 458 * 459 * `toParentLocal()` similar to `toParentDecl()` but follows the instantiation scope 460 * if a template declaration is non-local i.e. global or static. 461 * 462 * Examples: 463 * module mod; 464 * template Foo(alias a) { mixin Bar!(); } 465 * mixin template Bar() { 466 * public { // ProtDeclaration 467 * void baz() { a = 2; } 468 * } 469 * } 470 * void test() { 471 * int v = 1; 472 * alias foo = Foo!(v); 473 * foo.baz(); 474 * assert(v == 2); 475 * } 476 * 477 * // s == FuncDeclaration('mod.test.Foo!().Bar!().baz()') 478 * // s.parent == TemplateMixin('mod.test.Foo!().Bar!()') 479 * // s.toParent() == TemplateInstance('mod.test.Foo!()') 480 * // s.toParent2() == FuncDeclaration('mod.test') 481 * // s.toParentDecl() == Module('mod') 482 * // s.toParentLocal() == FuncDeclaration('mod.test') 483 */ 484 final inout(Dsymbol) toParent() inout 485 { 486 return parent ? parent.pastMixin() : null; 487 } 488 489 /// ditto 490 final inout(Dsymbol) toParent2() inout 491 { 492 if (!parent || !parent.isTemplateInstance && !parent.isForwardingAttribDeclaration() && !parent.isForwardingScopeDsymbol()) 493 return parent; 494 return parent.toParent2; 495 } 496 497 /// ditto 498 final inout(Dsymbol) toParentDecl() inout 499 { 500 return toParentDeclImpl(false); 501 } 502 503 /// ditto 504 final inout(Dsymbol) toParentLocal() inout 505 { 506 return toParentDeclImpl(true); 507 } 508 509 private inout(Dsymbol) toParentDeclImpl(bool localOnly) inout 510 { 511 auto p = toParent(); 512 if (!p || !p.isTemplateInstance()) 513 return p; 514 auto ti = p.isTemplateInstance(); 515 if (ti.tempdecl && (!localOnly || !(cast(TemplateDeclaration)ti.tempdecl).isstatic)) 516 return ti.tempdecl.toParentDeclImpl(localOnly); 517 return parent.toParentDeclImpl(localOnly); 518 } 519 520 /** 521 * Returns the declaration scope scope of `this` unless any of the symbols 522 * `p1` or `p2` resides in its enclosing instantiation scope then the 523 * latter is returned. 524 */ 525 final Dsymbol toParentP(Dsymbol p1, Dsymbol p2 = null) 526 { 527 return followInstantiationContext(p1, p2) ? toParent2() : toParentLocal(); 528 } 529 530 final inout(TemplateInstance) isInstantiated() inout 531 { 532 if (!parent) 533 return null; 534 auto ti = parent.isTemplateInstance(); 535 if (ti && !ti.isTemplateMixin()) 536 return ti; 537 return parent.isInstantiated(); 538 } 539 540 /*** 541 * Returns true if any of the symbols `p1` or `p2` resides in the enclosing 542 * instantiation scope of `this`. 543 */ 544 final bool followInstantiationContext(Dsymbol p1, Dsymbol p2 = null) 545 { 546 static bool has2This(Dsymbol s) 547 { 548 if (auto f = s.isFuncDeclaration()) 549 return f.isThis2; 550 if (auto ad = s.isAggregateDeclaration()) 551 return ad.vthis2 !is null; 552 return false; 553 } 554 555 if (has2This(this)) 556 { 557 assert(p1); 558 auto outer = toParent(); 559 while (outer) 560 { 561 auto ti = outer.isTemplateInstance(); 562 if (!ti) 563 break; 564 foreach (oarg; *ti.tiargs) 565 { 566 auto sa = getDsymbol(oarg); 567 if (!sa) 568 continue; 569 sa = sa.toAlias().toParent2(); 570 if (!sa) 571 continue; 572 if (sa == p1) 573 return true; 574 else if (p2 && sa == p2) 575 return true; 576 } 577 outer = ti.tempdecl.toParent(); 578 } 579 return false; 580 } 581 return false; 582 } 583 584 // Check if this function is a member of a template which has only been 585 // instantiated speculatively, eg from inside is(typeof()). 586 // Return the speculative template instance it is part of, 587 // or NULL if not speculative. 588 final inout(TemplateInstance) isSpeculative() inout 589 { 590 if (!parent) 591 return null; 592 auto ti = parent.isTemplateInstance(); 593 if (ti && ti.gagged) 594 return ti; 595 if (!parent.toParent()) 596 return null; 597 return parent.isSpeculative(); 598 } 599 600 final Ungag ungagSpeculative() const 601 { 602 uint oldgag = global.gag; 603 if (global.gag && !isSpeculative() && !toParent2().isFuncDeclaration()) 604 global.gag = 0; 605 return Ungag(oldgag); 606 } 607 608 // kludge for template.isSymbol() 609 override final DYNCAST dyncast() const 610 { 611 return DYNCAST.dsymbol; 612 } 613 614 /************************************* 615 * Do syntax copy of an array of Dsymbol's. 616 */ 617 extern (D) static Dsymbols* arraySyntaxCopy(Dsymbols* a) 618 { 619 Dsymbols* b = null; 620 if (a) 621 { 622 b = a.copy(); 623 for (size_t i = 0; i < b.dim; i++) 624 { 625 (*b)[i] = (*b)[i].syntaxCopy(null); 626 } 627 } 628 return b; 629 } 630 631 Identifier getIdent() 632 { 633 return ident; 634 } 635 636 const(char)* toPrettyChars(bool QualifyTypes = false) 637 { 638 if (prettystring && !QualifyTypes) 639 return prettystring; 640 641 //printf("Dsymbol::toPrettyChars() '%s'\n", toChars()); 642 if (!parent) 643 { 644 auto s = toChars(); 645 if (!QualifyTypes) 646 prettystring = s; 647 return s; 648 } 649 650 // Computer number of components 651 size_t complength = 0; 652 for (Dsymbol p = this; p; p = p.parent) 653 ++complength; 654 655 // Allocate temporary array comp[] 656 alias T = const(char)[]; 657 auto compptr = cast(T*)Mem.check(malloc(complength * T.sizeof)); 658 auto comp = compptr[0 .. complength]; 659 660 // Fill in comp[] and compute length of final result 661 size_t length = 0; 662 int i; 663 for (Dsymbol p = this; p; p = p.parent) 664 { 665 const s = QualifyTypes ? p.toPrettyCharsHelper() : p.toChars(); 666 const len = strlen(s); 667 comp[i] = s[0 .. len]; 668 ++i; 669 length += len + 1; 670 } 671 672 auto s = cast(char*)mem.xmalloc_noscan(length); 673 auto q = s + length - 1; 674 *q = 0; 675 foreach (j; 0 .. complength) 676 { 677 const t = comp[j].ptr; 678 const len = comp[j].length; 679 q -= len; 680 memcpy(q, t, len); 681 if (q == s) 682 break; 683 *--q = '.'; 684 } 685 free(comp.ptr); 686 if (!QualifyTypes) 687 prettystring = s; 688 return s; 689 } 690 691 const(char)* kind() const pure nothrow @nogc @safe 692 { 693 return "symbol"; 694 } 695 696 /********************************* 697 * If this symbol is really an alias for another, 698 * return that other. 699 * If needed, semantic() is invoked due to resolve forward reference. 700 */ 701 Dsymbol toAlias() 702 { 703 return this; 704 } 705 706 /********************************* 707 * Resolve recursive tuple expansion in eponymous template. 708 */ 709 Dsymbol toAlias2() 710 { 711 return toAlias(); 712 } 713 714 void addMember(Scope* sc, ScopeDsymbol sds) 715 { 716 //printf("Dsymbol::addMember('%s')\n", toChars()); 717 //printf("Dsymbol::addMember(this = %p, '%s' scopesym = '%s')\n", this, toChars(), sds.toChars()); 718 //printf("Dsymbol::addMember(this = %p, '%s' sds = %p, sds.symtab = %p)\n", this, toChars(), sds, sds.symtab); 719 parent = sds; 720 if (isAnonymous()) // no name, so can't add it to symbol table 721 return; 722 723 if (!sds.symtabInsert(this)) // if name is already defined 724 { 725 if (isAliasDeclaration() && !_scope) 726 setScope(sc); 727 Dsymbol s2 = sds.symtabLookup(this,ident); 728 if (!s2.overloadInsert(this)) 729 { 730 sds.multiplyDefined(Loc.initial, this, s2); 731 errors = true; 732 } 733 } 734 if (sds.isAggregateDeclaration() || sds.isEnumDeclaration()) 735 { 736 if (ident == Id.__sizeof || ident == Id.__xalignof || ident == Id._mangleof) 737 { 738 error("`.%s` property cannot be redefined", ident.toChars()); 739 errors = true; 740 } 741 } 742 } 743 744 /************************************* 745 * Set scope for future semantic analysis so we can 746 * deal better with forward references. 747 */ 748 void setScope(Scope* sc) 749 { 750 //printf("Dsymbol::setScope() %p %s, %p stc = %llx\n", this, toChars(), sc, sc.stc); 751 if (!sc.nofree) 752 sc.setNoFree(); // may need it even after semantic() finishes 753 _scope = sc; 754 if (sc.depdecl) 755 depdecl = sc.depdecl; 756 if (!userAttribDecl) 757 userAttribDecl = sc.userAttribDecl; 758 } 759 760 void importAll(Scope* sc) 761 { 762 } 763 764 /********************************************* 765 * Search for ident as member of s. 766 * Params: 767 * loc = location to print for error messages 768 * ident = identifier to search for 769 * flags = IgnoreXXXX 770 * Returns: 771 * null if not found 772 */ 773 Dsymbol search(const ref Loc loc, Identifier ident, int flags = IgnoreNone) 774 { 775 //printf("Dsymbol::search(this=%p,%s, ident='%s')\n", this, toChars(), ident.toChars()); 776 return null; 777 } 778 779 extern (D) final Dsymbol search_correct(Identifier ident) 780 { 781 /*************************************************** 782 * Search for symbol with correct spelling. 783 */ 784 extern (D) Dsymbol symbol_search_fp(const(char)[] seed, ref int cost) 785 { 786 /* If not in the lexer's string table, it certainly isn't in the symbol table. 787 * Doing this first is a lot faster. 788 */ 789 if (!seed.length) 790 return null; 791 Identifier id = Identifier.lookup(seed); 792 if (!id) 793 return null; 794 cost = 0; 795 Dsymbol s = this; 796 Module.clearCache(); 797 return s.search(Loc.initial, id, IgnoreErrors); 798 } 799 800 if (global.gag) 801 return null; // don't do it for speculative compiles; too time consuming 802 // search for exact name first 803 if (auto s = search(Loc.initial, ident, IgnoreErrors)) 804 return s; 805 return speller!symbol_search_fp(ident.toString()); 806 } 807 808 /*************************************** 809 * Search for identifier id as a member of `this`. 810 * `id` may be a template instance. 811 * 812 * Params: 813 * loc = location to print the error messages 814 * sc = the scope where the symbol is located 815 * id = the id of the symbol 816 * flags = the search flags which can be `SearchLocalsOnly` or `IgnorePrivateImports` 817 * 818 * Returns: 819 * symbol found, NULL if not 820 */ 821 extern (D) final Dsymbol searchX(const ref Loc loc, Scope* sc, RootObject id, int flags) 822 { 823 //printf("Dsymbol::searchX(this=%p,%s, ident='%s')\n", this, toChars(), ident.toChars()); 824 Dsymbol s = toAlias(); 825 Dsymbol sm; 826 if (Declaration d = s.isDeclaration()) 827 { 828 if (d.inuse) 829 { 830 .error(loc, "circular reference to `%s`", d.toPrettyChars()); 831 return null; 832 } 833 } 834 switch (id.dyncast()) 835 { 836 case DYNCAST.identifier: 837 sm = s.search(loc, cast(Identifier)id, flags); 838 break; 839 case DYNCAST.dsymbol: 840 { 841 // It's a template instance 842 //printf("\ttemplate instance id\n"); 843 Dsymbol st = cast(Dsymbol)id; 844 TemplateInstance ti = st.isTemplateInstance(); 845 sm = s.search(loc, ti.name); 846 if (!sm) 847 { 848 sm = s.search_correct(ti.name); 849 if (sm) 850 .error(loc, "template identifier `%s` is not a member of %s `%s`, did you mean %s `%s`?", ti.name.toChars(), s.kind(), s.toPrettyChars(), sm.kind(), sm.toChars()); 851 else 852 .error(loc, "template identifier `%s` is not a member of %s `%s`", ti.name.toChars(), s.kind(), s.toPrettyChars()); 853 return null; 854 } 855 sm = sm.toAlias(); 856 TemplateDeclaration td = sm.isTemplateDeclaration(); 857 if (!td) 858 { 859 .error(loc, "`%s.%s` is not a template, it is a %s", s.toPrettyChars(), ti.name.toChars(), sm.kind()); 860 return null; 861 } 862 ti.tempdecl = td; 863 if (!ti.semanticRun) 864 ti.dsymbolSemantic(sc); 865 sm = ti.toAlias(); 866 break; 867 } 868 case DYNCAST.type: 869 case DYNCAST.expression: 870 default: 871 assert(0); 872 } 873 return sm; 874 } 875 876 bool overloadInsert(Dsymbol s) 877 { 878 //printf("Dsymbol::overloadInsert('%s')\n", s.toChars()); 879 return false; 880 } 881 882 /********************************* 883 * Returns: 884 * SIZE_INVALID when the size cannot be determined 885 */ 886 d_uns64 size(const ref Loc loc) 887 { 888 error("Dsymbol `%s` has no size", toChars()); 889 return SIZE_INVALID; 890 } 891 892 bool isforwardRef() 893 { 894 return false; 895 } 896 897 // is a 'this' required to access the member 898 inout(AggregateDeclaration) isThis() inout 899 { 900 return null; 901 } 902 903 // is Dsymbol exported? 904 bool isExport() const 905 { 906 return false; 907 } 908 909 // is Dsymbol imported? 910 bool isImportedSymbol() const 911 { 912 return false; 913 } 914 915 // is Dsymbol deprecated? 916 bool isDeprecated() const 917 { 918 return false; 919 } 920 921 bool isOverloadable() const 922 { 923 return false; 924 } 925 926 // is this a LabelDsymbol()? 927 LabelDsymbol isLabel() 928 { 929 return null; 930 } 931 932 /// Returns an AggregateDeclaration when toParent() is that. 933 final inout(AggregateDeclaration) isMember() inout 934 { 935 //printf("Dsymbol::isMember() %s\n", toChars()); 936 auto p = toParent(); 937 //printf("parent is %s %s\n", p.kind(), p.toChars()); 938 return p ? p.isAggregateDeclaration() : null; 939 } 940 941 /// Returns an AggregateDeclaration when toParent2() is that. 942 final inout(AggregateDeclaration) isMember2() inout 943 { 944 //printf("Dsymbol::isMember2() '%s'\n", toChars()); 945 auto p = toParent2(); 946 //printf("parent is %s %s\n", p.kind(), p.toChars()); 947 return p ? p.isAggregateDeclaration() : null; 948 } 949 950 /// Returns an AggregateDeclaration when toParentDecl() is that. 951 final inout(AggregateDeclaration) isMemberDecl() inout 952 { 953 //printf("Dsymbol::isMemberDecl() '%s'\n", toChars()); 954 auto p = toParentDecl(); 955 //printf("parent is %s %s\n", p.kind(), p.toChars()); 956 return p ? p.isAggregateDeclaration() : null; 957 } 958 959 /// Returns an AggregateDeclaration when toParentLocal() is that. 960 final inout(AggregateDeclaration) isMemberLocal() inout 961 { 962 //printf("Dsymbol::isMemberLocal() '%s'\n", toChars()); 963 auto p = toParentLocal(); 964 //printf("parent is %s %s\n", p.kind(), p.toChars()); 965 return p ? p.isAggregateDeclaration() : null; 966 } 967 968 // is this a member of a ClassDeclaration? 969 final ClassDeclaration isClassMember() 970 { 971 auto ad = isMember(); 972 return ad ? ad.isClassDeclaration() : null; 973 } 974 975 // is this a type? 976 Type getType() 977 { 978 return null; 979 } 980 981 // need a 'this' pointer? 982 bool needThis() 983 { 984 return false; 985 } 986 987 /************************************* 988 */ 989 Prot prot() pure nothrow @nogc @safe 990 { 991 return Prot(Prot.Kind.public_); 992 } 993 994 /************************************** 995 * Copy the syntax. 996 * Used for template instantiations. 997 * If s is NULL, allocate the new object, otherwise fill it in. 998 */ 999 Dsymbol syntaxCopy(Dsymbol s) 1000 { 1001 printf("%s %s\n", kind(), toChars()); 1002 assert(0); 1003 } 1004 1005 /************************************** 1006 * Determine if this symbol is only one. 1007 * Returns: 1008 * false, *ps = NULL: There are 2 or more symbols 1009 * true, *ps = NULL: There are zero symbols 1010 * true, *ps = symbol: The one and only one symbol 1011 */ 1012 bool oneMember(Dsymbol* ps, Identifier ident) 1013 { 1014 //printf("Dsymbol::oneMember()\n"); 1015 *ps = this; 1016 return true; 1017 } 1018 1019 /***************************************** 1020 * Same as Dsymbol::oneMember(), but look at an array of Dsymbols. 1021 */ 1022 extern (D) static bool oneMembers(Dsymbols* members, Dsymbol* ps, Identifier ident) 1023 { 1024 //printf("Dsymbol::oneMembers() %d\n", members ? members.dim : 0); 1025 Dsymbol s = null; 1026 if (!members) 1027 { 1028 *ps = null; 1029 return true; 1030 } 1031 1032 for (size_t i = 0; i < members.dim; i++) 1033 { 1034 Dsymbol sx = (*members)[i]; 1035 bool x = sx.oneMember(ps, ident); 1036 //printf("\t[%d] kind %s = %d, s = %p\n", i, sx.kind(), x, *ps); 1037 if (!x) 1038 { 1039 //printf("\tfalse 1\n"); 1040 assert(*ps is null); 1041 return false; 1042 } 1043 if (*ps) 1044 { 1045 assert(ident); 1046 if (!(*ps).ident || !(*ps).ident.equals(ident)) 1047 continue; 1048 if (!s) 1049 s = *ps; 1050 else if (s.isOverloadable() && (*ps).isOverloadable()) 1051 { 1052 // keep head of overload set 1053 FuncDeclaration f1 = s.isFuncDeclaration(); 1054 FuncDeclaration f2 = (*ps).isFuncDeclaration(); 1055 if (f1 && f2) 1056 { 1057 assert(!f1.isFuncAliasDeclaration()); 1058 assert(!f2.isFuncAliasDeclaration()); 1059 for (; f1 != f2; f1 = f1.overnext0) 1060 { 1061 if (f1.overnext0 is null) 1062 { 1063 f1.overnext0 = f2; 1064 break; 1065 } 1066 } 1067 } 1068 } 1069 else // more than one symbol 1070 { 1071 *ps = null; 1072 //printf("\tfalse 2\n"); 1073 return false; 1074 } 1075 } 1076 } 1077 *ps = s; // s is the one symbol, null if none 1078 //printf("\ttrue\n"); 1079 return true; 1080 } 1081 1082 void setFieldOffset(AggregateDeclaration ad, uint* poffset, bool isunion) 1083 { 1084 } 1085 1086 /***************************************** 1087 * Is Dsymbol a variable that contains pointers? 1088 */ 1089 bool hasPointers() 1090 { 1091 //printf("Dsymbol::hasPointers() %s\n", toChars()); 1092 return false; 1093 } 1094 1095 bool hasStaticCtorOrDtor() 1096 { 1097 //printf("Dsymbol::hasStaticCtorOrDtor() %s\n", toChars()); 1098 return false; 1099 } 1100 1101 void addLocalClass(ClassDeclarations*) 1102 { 1103 } 1104 1105 void addObjcSymbols(ClassDeclarations* classes, ClassDeclarations* categories) 1106 { 1107 } 1108 1109 void checkCtorConstInit() 1110 { 1111 } 1112 1113 /**************************************** 1114 * Add documentation comment to Dsymbol. 1115 * Ignore NULL comments. 1116 */ 1117 void addComment(const(char)* comment) 1118 { 1119 //if (comment) 1120 // printf("adding comment '%s' to symbol %p '%s'\n", comment, this, toChars()); 1121 if (!this.comment) 1122 this.comment = comment; 1123 else if (comment && strcmp(cast(char*)comment, cast(char*)this.comment) != 0) 1124 { 1125 // Concatenate the two 1126 this.comment = Lexer.combineComments(this.comment.toDString(), comment.toDString(), true); 1127 } 1128 } 1129 1130 /**************************************** 1131 * Returns true if this symbol is defined in a non-root module without instantiation. 1132 */ 1133 final bool inNonRoot() 1134 { 1135 Dsymbol s = parent; 1136 for (; s; s = s.toParent()) 1137 { 1138 if (auto ti = s.isTemplateInstance()) 1139 { 1140 return false; 1141 } 1142 if (auto m = s.isModule()) 1143 { 1144 if (!m.isRoot()) 1145 return true; 1146 break; 1147 } 1148 } 1149 return false; 1150 } 1151 1152 /************ 1153 */ 1154 override void accept(Visitor v) 1155 { 1156 v.visit(this); 1157 } 1158 1159 pure nothrow @safe @nogc: 1160 1161 // Eliminate need for dynamic_cast 1162 inout(Package) isPackage() inout { return null; } 1163 inout(Module) isModule() inout { return null; } 1164 inout(EnumMember) isEnumMember() inout { return null; } 1165 inout(TemplateDeclaration) isTemplateDeclaration() inout { return null; } 1166 inout(TemplateInstance) isTemplateInstance() inout { return null; } 1167 inout(TemplateMixin) isTemplateMixin() inout { return null; } 1168 inout(ForwardingAttribDeclaration) isForwardingAttribDeclaration() inout { return null; } 1169 inout(Nspace) isNspace() inout { return null; } 1170 inout(Declaration) isDeclaration() inout { return null; } 1171 inout(StorageClassDeclaration) isStorageClassDeclaration() inout { return null; } 1172 inout(ExpressionDsymbol) isExpressionDsymbol() inout { return null; } 1173 inout(ThisDeclaration) isThisDeclaration() inout { return null; } 1174 inout(TypeInfoDeclaration) isTypeInfoDeclaration() inout { return null; } 1175 inout(TupleDeclaration) isTupleDeclaration() inout { return null; } 1176 inout(AliasDeclaration) isAliasDeclaration() inout { return null; } 1177 inout(AggregateDeclaration) isAggregateDeclaration() inout { return null; } 1178 inout(FuncDeclaration) isFuncDeclaration() inout { return null; } 1179 inout(FuncAliasDeclaration) isFuncAliasDeclaration() inout { return null; } 1180 inout(OverDeclaration) isOverDeclaration() inout { return null; } 1181 inout(FuncLiteralDeclaration) isFuncLiteralDeclaration() inout { return null; } 1182 inout(CtorDeclaration) isCtorDeclaration() inout { return null; } 1183 inout(PostBlitDeclaration) isPostBlitDeclaration() inout { return null; } 1184 inout(DtorDeclaration) isDtorDeclaration() inout { return null; } 1185 inout(StaticCtorDeclaration) isStaticCtorDeclaration() inout { return null; } 1186 inout(StaticDtorDeclaration) isStaticDtorDeclaration() inout { return null; } 1187 inout(SharedStaticCtorDeclaration) isSharedStaticCtorDeclaration() inout { return null; } 1188 inout(SharedStaticDtorDeclaration) isSharedStaticDtorDeclaration() inout { return null; } 1189 inout(InvariantDeclaration) isInvariantDeclaration() inout { return null; } 1190 inout(UnitTestDeclaration) isUnitTestDeclaration() inout { return null; } 1191 inout(NewDeclaration) isNewDeclaration() inout { return null; } 1192 inout(VarDeclaration) isVarDeclaration() inout { return null; } 1193 inout(ClassDeclaration) isClassDeclaration() inout { return null; } 1194 inout(StructDeclaration) isStructDeclaration() inout { return null; } 1195 inout(UnionDeclaration) isUnionDeclaration() inout { return null; } 1196 inout(InterfaceDeclaration) isInterfaceDeclaration() inout { return null; } 1197 inout(ScopeDsymbol) isScopeDsymbol() inout { return null; } 1198 inout(ForwardingScopeDsymbol) isForwardingScopeDsymbol() inout { return null; } 1199 inout(WithScopeSymbol) isWithScopeSymbol() inout { return null; } 1200 inout(ArrayScopeSymbol) isArrayScopeSymbol() inout { return null; } 1201 inout(Import) isImport() inout { return null; } 1202 inout(EnumDeclaration) isEnumDeclaration() inout { return null; } 1203 inout(SymbolDeclaration) isSymbolDeclaration() inout { return null; } 1204 inout(AttribDeclaration) isAttribDeclaration() inout { return null; } 1205 inout(AnonDeclaration) isAnonDeclaration() inout { return null; } 1206 inout(CPPNamespaceDeclaration) isCPPNamespaceDeclaration() inout { return null; } 1207 inout(ProtDeclaration) isProtDeclaration() inout { return null; } 1208 inout(OverloadSet) isOverloadSet() inout { return null; } 1209 inout(CompileDeclaration) isCompileDeclaration() inout { return null; } 1210 } 1211 1212 /*********************************************************** 1213 * Dsymbol that generates a scope 1214 */ 1215 extern (C++) class ScopeDsymbol : Dsymbol 1216 { 1217 Dsymbols* members; // all Dsymbol's in this scope 1218 DsymbolTable symtab; // members[] sorted into table 1219 uint endlinnum; // the linnumber of the statement after the scope (0 if unknown) 1220 1221 private: 1222 /// symbols whose members have been imported, i.e. imported modules and template mixins 1223 Dsymbols* importedScopes; 1224 Prot.Kind* prots; // array of Prot.Kind, one for each import 1225 1226 import dmd.root.bitarray; 1227 BitArray accessiblePackages, privateAccessiblePackages;// whitelists of accessible (imported) packages 1228 1229 public: 1230 final extern (D) this() 1231 { 1232 } 1233 1234 final extern (D) this(Identifier ident) 1235 { 1236 super(ident); 1237 } 1238 1239 final extern (D) this(const ref Loc loc, Identifier ident) 1240 { 1241 super(loc, ident); 1242 } 1243 1244 override Dsymbol syntaxCopy(Dsymbol s) 1245 { 1246 //printf("ScopeDsymbol::syntaxCopy('%s')\n", toChars()); 1247 ScopeDsymbol sds = s ? cast(ScopeDsymbol)s : new ScopeDsymbol(ident); 1248 sds.comment = comment; 1249 sds.members = arraySyntaxCopy(members); 1250 sds.endlinnum = endlinnum; 1251 return sds; 1252 } 1253 1254 /***************************************** 1255 * This function is #1 on the list of functions that eat cpu time. 1256 * Be very, very careful about slowing it down. 1257 */ 1258 override Dsymbol search(const ref Loc loc, Identifier ident, int flags = SearchLocalsOnly) 1259 { 1260 //printf("%s.ScopeDsymbol::search(ident='%s', flags=x%x)\n", toChars(), ident.toChars(), flags); 1261 //if (strcmp(ident.toChars(),"c") == 0) *(char*)0=0; 1262 1263 // Look in symbols declared in this module 1264 if (symtab && !(flags & SearchImportsOnly)) 1265 { 1266 //printf(" look in locals\n"); 1267 auto s1 = symtab.lookup(ident); 1268 if (s1) 1269 { 1270 //printf("\tfound in locals = '%s.%s'\n",toChars(),s1.toChars()); 1271 return s1; 1272 } 1273 } 1274 //printf(" not found in locals\n"); 1275 1276 // Look in imported scopes 1277 if (!importedScopes) 1278 return null; 1279 1280 //printf(" look in imports\n"); 1281 Dsymbol s = null; 1282 OverloadSet a = null; 1283 // Look in imported modules 1284 for (size_t i = 0; i < importedScopes.dim; i++) 1285 { 1286 // If private import, don't search it 1287 if ((flags & IgnorePrivateImports) && prots[i] == Prot.Kind.private_) 1288 continue; 1289 int sflags = flags & (IgnoreErrors | IgnoreAmbiguous); // remember these in recursive searches 1290 Dsymbol ss = (*importedScopes)[i]; 1291 //printf("\tscanning import '%s', prots = %d, isModule = %p, isImport = %p\n", ss.toChars(), prots[i], ss.isModule(), ss.isImport()); 1292 1293 if (ss.isModule()) 1294 { 1295 if (flags & SearchLocalsOnly) 1296 continue; 1297 } 1298 else // mixin template 1299 { 1300 if (flags & SearchImportsOnly) 1301 continue; 1302 1303 sflags |= SearchLocalsOnly; 1304 } 1305 1306 /* Don't find private members if ss is a module 1307 */ 1308 Dsymbol s2 = ss.search(loc, ident, sflags | (ss.isModule() ? IgnorePrivateImports : IgnoreNone)); 1309 import dmd.access : symbolIsVisible; 1310 if (!s2 || !(flags & IgnoreSymbolVisibility) && !symbolIsVisible(this, s2)) 1311 continue; 1312 if (!s) 1313 { 1314 s = s2; 1315 if (s && s.isOverloadSet()) 1316 a = mergeOverloadSet(ident, a, s); 1317 } 1318 else if (s2 && s != s2) 1319 { 1320 if (s.toAlias() == s2.toAlias() || s.getType() == s2.getType() && s.getType()) 1321 { 1322 /* After following aliases, we found the same 1323 * symbol, so it's not an ambiguity. But if one 1324 * alias is deprecated or less accessible, prefer 1325 * the other. 1326 */ 1327 if (s.isDeprecated() || s.prot().isMoreRestrictiveThan(s2.prot()) && s2.prot().kind != Prot.Kind.none) 1328 s = s2; 1329 } 1330 else 1331 { 1332 /* Two imports of the same module should be regarded as 1333 * the same. 1334 */ 1335 Import i1 = s.isImport(); 1336 Import i2 = s2.isImport(); 1337 if (!(i1 && i2 && (i1.mod == i2.mod || (!i1.parent.isImport() && !i2.parent.isImport() && i1.ident.equals(i2.ident))))) 1338 { 1339 /* https://issues.dlang.org/show_bug.cgi?id=8668 1340 * Public selective import adds AliasDeclaration in module. 1341 * To make an overload set, resolve aliases in here and 1342 * get actual overload roots which accessible via s and s2. 1343 */ 1344 s = s.toAlias(); 1345 s2 = s2.toAlias(); 1346 /* If both s2 and s are overloadable (though we only 1347 * need to check s once) 1348 */ 1349 1350 auto so2 = s2.isOverloadSet(); 1351 if ((so2 || s2.isOverloadable()) && (a || s.isOverloadable())) 1352 { 1353 if (symbolIsVisible(this, s2)) 1354 { 1355 a = mergeOverloadSet(ident, a, s2); 1356 } 1357 if (!symbolIsVisible(this, s)) 1358 s = s2; 1359 continue; 1360 } 1361 1362 /* Two different overflow sets can have the same members 1363 * https://issues.dlang.org/show_bug.cgi?id=16709 1364 */ 1365 auto so = s.isOverloadSet(); 1366 if (so && so2) 1367 { 1368 if (so.a.length == so2.a.length) 1369 { 1370 foreach (j; 0 .. so.a.length) 1371 { 1372 if (so.a[j] !is so2.a[j]) 1373 goto L1; 1374 } 1375 continue; // the same 1376 L1: 1377 { } // different 1378 } 1379 } 1380 1381 if (flags & IgnoreAmbiguous) // if return NULL on ambiguity 1382 return null; 1383 if (!(flags & IgnoreErrors)) 1384 ScopeDsymbol.multiplyDefined(loc, s, s2); 1385 break; 1386 } 1387 } 1388 } 1389 } 1390 if (s) 1391 { 1392 /* Build special symbol if we had multiple finds 1393 */ 1394 if (a) 1395 { 1396 if (!s.isOverloadSet()) 1397 a = mergeOverloadSet(ident, a, s); 1398 s = a; 1399 } 1400 //printf("\tfound in imports %s.%s\n", toChars(), s.toChars()); 1401 return s; 1402 } 1403 //printf(" not found in imports\n"); 1404 return null; 1405 } 1406 1407 extern (D) private OverloadSet mergeOverloadSet(Identifier ident, OverloadSet os, Dsymbol s) 1408 { 1409 if (!os) 1410 { 1411 os = new OverloadSet(ident); 1412 os.parent = this; 1413 } 1414 if (OverloadSet os2 = s.isOverloadSet()) 1415 { 1416 // Merge the cross-module overload set 'os2' into 'os' 1417 if (os.a.dim == 0) 1418 { 1419 os.a.setDim(os2.a.dim); 1420 memcpy(os.a.tdata(), os2.a.tdata(), (os.a[0]).sizeof * os2.a.dim); 1421 } 1422 else 1423 { 1424 for (size_t i = 0; i < os2.a.dim; i++) 1425 { 1426 os = mergeOverloadSet(ident, os, os2.a[i]); 1427 } 1428 } 1429 } 1430 else 1431 { 1432 assert(s.isOverloadable()); 1433 /* Don't add to os[] if s is alias of previous sym 1434 */ 1435 for (size_t j = 0; j < os.a.dim; j++) 1436 { 1437 Dsymbol s2 = os.a[j]; 1438 if (s.toAlias() == s2.toAlias()) 1439 { 1440 if (s2.isDeprecated() || (s2.prot().isMoreRestrictiveThan(s.prot()) && s.prot().kind != Prot.Kind.none)) 1441 { 1442 os.a[j] = s; 1443 } 1444 goto Lcontinue; 1445 } 1446 } 1447 os.push(s); 1448 Lcontinue: 1449 } 1450 return os; 1451 } 1452 1453 void importScope(Dsymbol s, Prot protection) 1454 { 1455 //printf("%s.ScopeDsymbol::importScope(%s, %d)\n", toChars(), s.toChars(), protection); 1456 // No circular or redundant import's 1457 if (s != this) 1458 { 1459 if (!importedScopes) 1460 importedScopes = new Dsymbols(); 1461 else 1462 { 1463 for (size_t i = 0; i < importedScopes.dim; i++) 1464 { 1465 Dsymbol ss = (*importedScopes)[i]; 1466 if (ss == s) // if already imported 1467 { 1468 if (protection.kind > prots[i]) 1469 prots[i] = protection.kind; // upgrade access 1470 return; 1471 } 1472 } 1473 } 1474 importedScopes.push(s); 1475 prots = cast(Prot.Kind*)mem.xrealloc(prots, importedScopes.dim * (prots[0]).sizeof); 1476 prots[importedScopes.dim - 1] = protection.kind; 1477 } 1478 } 1479 1480 extern (D) final void addAccessiblePackage(Package p, Prot protection) 1481 { 1482 auto pary = protection.kind == Prot.Kind.private_ ? &privateAccessiblePackages : &accessiblePackages; 1483 if (pary.length <= p.tag) 1484 pary.length = p.tag + 1; 1485 (*pary)[p.tag] = true; 1486 } 1487 1488 bool isPackageAccessible(Package p, Prot protection, int flags = 0) 1489 { 1490 if (p.tag < accessiblePackages.length && accessiblePackages[p.tag] || 1491 protection.kind == Prot.Kind.private_ && p.tag < privateAccessiblePackages.length && privateAccessiblePackages[p.tag]) 1492 return true; 1493 foreach (i, ss; importedScopes ? (*importedScopes)[] : null) 1494 { 1495 // only search visible scopes && imported modules should ignore private imports 1496 if (protection.kind <= prots[i] && 1497 ss.isScopeDsymbol.isPackageAccessible(p, protection, IgnorePrivateImports)) 1498 return true; 1499 } 1500 return false; 1501 } 1502 1503 override final bool isforwardRef() 1504 { 1505 return (members is null); 1506 } 1507 1508 static void multiplyDefined(const ref Loc loc, Dsymbol s1, Dsymbol s2) 1509 { 1510 version (none) 1511 { 1512 printf("ScopeDsymbol::multiplyDefined()\n"); 1513 printf("s1 = %p, '%s' kind = '%s', parent = %s\n", s1, s1.toChars(), s1.kind(), s1.parent ? s1.parent.toChars() : ""); 1514 printf("s2 = %p, '%s' kind = '%s', parent = %s\n", s2, s2.toChars(), s2.kind(), s2.parent ? s2.parent.toChars() : ""); 1515 } 1516 if (loc.isValid()) 1517 { 1518 .error(loc, "%s `%s` at %s conflicts with %s `%s` at %s", 1519 s1.kind(), s1.toPrettyChars(), s1.locToChars(), 1520 s2.kind(), s2.toPrettyChars(), s2.locToChars()); 1521 1522 static if (0) 1523 { 1524 if (auto so = s1.isOverloadSet()) 1525 { 1526 printf("first %p:\n", so); 1527 foreach (s; so.a[]) 1528 { 1529 printf(" %p %s `%s` at %s\n", s, s.kind(), s.toPrettyChars(), s.locToChars()); 1530 } 1531 } 1532 if (auto so = s2.isOverloadSet()) 1533 { 1534 printf("second %p:\n", so); 1535 foreach (s; so.a[]) 1536 { 1537 printf(" %p %s `%s` at %s\n", s, s.kind(), s.toPrettyChars(), s.locToChars()); 1538 } 1539 } 1540 } 1541 } 1542 else 1543 { 1544 s1.error(s1.loc, "conflicts with %s `%s` at %s", s2.kind(), s2.toPrettyChars(), s2.locToChars()); 1545 } 1546 } 1547 1548 override const(char)* kind() const 1549 { 1550 return "ScopeDsymbol"; 1551 } 1552 1553 /******************************************* 1554 * Look for member of the form: 1555 * const(MemberInfo)[] getMembers(string); 1556 * Returns NULL if not found 1557 */ 1558 final FuncDeclaration findGetMembers() 1559 { 1560 Dsymbol s = search_function(this, Id.getmembers); 1561 FuncDeclaration fdx = s ? s.isFuncDeclaration() : null; 1562 version (none) 1563 { 1564 // Finish 1565 __gshared TypeFunction tfgetmembers; 1566 if (!tfgetmembers) 1567 { 1568 Scope sc; 1569 auto parameters = new Parameters(); 1570 Parameters* p = new Parameter(STC.in_, Type.tchar.constOf().arrayOf(), null, null); 1571 parameters.push(p); 1572 Type tret = null; 1573 tfgetmembers = new TypeFunction(parameters, tret, VarArg.none, LINK.d); 1574 tfgetmembers = cast(TypeFunction)tfgetmembers.dsymbolSemantic(Loc.initial, &sc); 1575 } 1576 if (fdx) 1577 fdx = fdx.overloadExactMatch(tfgetmembers); 1578 } 1579 if (fdx && fdx.isVirtual()) 1580 fdx = null; 1581 return fdx; 1582 } 1583 1584 Dsymbol symtabInsert(Dsymbol s) 1585 { 1586 return symtab.insert(s); 1587 } 1588 1589 /**************************************** 1590 * Look up identifier in symbol table. 1591 */ 1592 1593 Dsymbol symtabLookup(Dsymbol s, Identifier id) 1594 { 1595 return symtab.lookup(id); 1596 } 1597 1598 /**************************************** 1599 * Return true if any of the members are static ctors or static dtors, or if 1600 * any members have members that are. 1601 */ 1602 override bool hasStaticCtorOrDtor() 1603 { 1604 if (members) 1605 { 1606 for (size_t i = 0; i < members.dim; i++) 1607 { 1608 Dsymbol member = (*members)[i]; 1609 if (member.hasStaticCtorOrDtor()) 1610 return true; 1611 } 1612 } 1613 return false; 1614 } 1615 1616 extern (D) alias ForeachDg = int delegate(size_t idx, Dsymbol s); 1617 1618 /*************************************** 1619 * Expands attribute declarations in members in depth first 1620 * order. Calls dg(size_t symidx, Dsymbol *sym) for each 1621 * member. 1622 * If dg returns !=0, stops and returns that value else returns 0. 1623 * Use this function to avoid the O(N + N^2/2) complexity of 1624 * calculating dim and calling N times getNth. 1625 * Returns: 1626 * last value returned by dg() 1627 */ 1628 extern (D) static int _foreach(Scope* sc, Dsymbols* members, scope ForeachDg dg, size_t* pn = null) 1629 { 1630 assert(dg); 1631 if (!members) 1632 return 0; 1633 size_t n = pn ? *pn : 0; // take over index 1634 int result = 0; 1635 foreach (size_t i; 0 .. members.dim) 1636 { 1637 Dsymbol s = (*members)[i]; 1638 if (AttribDeclaration a = s.isAttribDeclaration()) 1639 result = _foreach(sc, a.include(sc), dg, &n); 1640 else if (TemplateMixin tm = s.isTemplateMixin()) 1641 result = _foreach(sc, tm.members, dg, &n); 1642 else if (s.isTemplateInstance()) 1643 { 1644 } 1645 else if (s.isUnitTestDeclaration()) 1646 { 1647 } 1648 else 1649 result = dg(n++, s); 1650 if (result) 1651 break; 1652 } 1653 if (pn) 1654 *pn = n; // update index 1655 return result; 1656 } 1657 1658 override final inout(ScopeDsymbol) isScopeDsymbol() inout 1659 { 1660 return this; 1661 } 1662 1663 override void accept(Visitor v) 1664 { 1665 v.visit(this); 1666 } 1667 } 1668 1669 /*********************************************************** 1670 * With statement scope 1671 */ 1672 extern (C++) final class WithScopeSymbol : ScopeDsymbol 1673 { 1674 WithStatement withstate; 1675 1676 extern (D) this(WithStatement withstate) 1677 { 1678 this.withstate = withstate; 1679 } 1680 1681 override Dsymbol search(const ref Loc loc, Identifier ident, int flags = SearchLocalsOnly) 1682 { 1683 //printf("WithScopeSymbol.search(%s)\n", ident.toChars()); 1684 if (flags & SearchImportsOnly) 1685 return null; 1686 // Acts as proxy to the with class declaration 1687 Dsymbol s = null; 1688 Expression eold = null; 1689 for (Expression e = withstate.exp; e != eold; e = resolveAliasThis(_scope, e)) 1690 { 1691 if (e.op == TOK.scope_) 1692 { 1693 s = (cast(ScopeExp)e).sds; 1694 } 1695 else if (e.op == TOK.type) 1696 { 1697 s = e.type.toDsymbol(null); 1698 } 1699 else 1700 { 1701 Type t = e.type.toBasetype(); 1702 s = t.toDsymbol(null); 1703 } 1704 if (s) 1705 { 1706 s = s.search(loc, ident, flags); 1707 if (s) 1708 return s; 1709 } 1710 eold = e; 1711 } 1712 return null; 1713 } 1714 1715 override inout(WithScopeSymbol) isWithScopeSymbol() inout 1716 { 1717 return this; 1718 } 1719 1720 override void accept(Visitor v) 1721 { 1722 v.visit(this); 1723 } 1724 } 1725 1726 /*********************************************************** 1727 * Array Index/Slice scope 1728 */ 1729 extern (C++) final class ArrayScopeSymbol : ScopeDsymbol 1730 { 1731 Expression exp; // IndexExp or SliceExp 1732 TypeTuple type; // for tuple[length] 1733 TupleDeclaration td; // for tuples of objects 1734 Scope* sc; 1735 1736 extern (D) this(Scope* sc, Expression exp) 1737 { 1738 super(exp.loc, null); 1739 assert(exp.op == TOK.index || exp.op == TOK.slice || exp.op == TOK.array); 1740 this.exp = exp; 1741 this.sc = sc; 1742 } 1743 1744 extern (D) this(Scope* sc, TypeTuple type) 1745 { 1746 this.type = type; 1747 this.sc = sc; 1748 } 1749 1750 extern (D) this(Scope* sc, TupleDeclaration td) 1751 { 1752 this.td = td; 1753 this.sc = sc; 1754 } 1755 1756 override Dsymbol search(const ref Loc loc, Identifier ident, int flags = IgnoreNone) 1757 { 1758 //printf("ArrayScopeSymbol::search('%s', flags = %d)\n", ident.toChars(), flags); 1759 if (ident != Id.dollar) 1760 return null; 1761 1762 VarDeclaration* pvar; 1763 Expression ce; 1764 L1: 1765 if (td) 1766 { 1767 /* $ gives the number of elements in the tuple 1768 */ 1769 auto v = new VarDeclaration(loc, Type.tsize_t, Id.dollar, null); 1770 Expression e = new IntegerExp(Loc.initial, td.objects.dim, Type.tsize_t); 1771 v._init = new ExpInitializer(Loc.initial, e); 1772 v.storage_class |= STC.temp | STC.static_ | STC.const_; 1773 v.dsymbolSemantic(sc); 1774 return v; 1775 } 1776 if (type) 1777 { 1778 /* $ gives the number of type entries in the type tuple 1779 */ 1780 auto v = new VarDeclaration(loc, Type.tsize_t, Id.dollar, null); 1781 Expression e = new IntegerExp(Loc.initial, type.arguments.dim, Type.tsize_t); 1782 v._init = new ExpInitializer(Loc.initial, e); 1783 v.storage_class |= STC.temp | STC.static_ | STC.const_; 1784 v.dsymbolSemantic(sc); 1785 return v; 1786 } 1787 if (auto ie = exp.isIndexExp()) 1788 { 1789 /* array[index] where index is some function of $ 1790 */ 1791 pvar = &ie.lengthVar; 1792 ce = ie.e1; 1793 } 1794 else if (auto se = exp.isSliceExp()) 1795 { 1796 /* array[lwr .. upr] where lwr or upr is some function of $ 1797 */ 1798 pvar = &se.lengthVar; 1799 ce = se.e1; 1800 } 1801 else if (auto ae = exp.isArrayExp()) 1802 { 1803 /* array[e0, e1, e2, e3] where e0, e1, e2 are some function of $ 1804 * $ is a opDollar!(dim)() where dim is the dimension(0,1,2,...) 1805 */ 1806 pvar = &ae.lengthVar; 1807 ce = ae.e1; 1808 } 1809 else 1810 { 1811 /* Didn't find $, look in enclosing scope(s). 1812 */ 1813 return null; 1814 } 1815 ce = ce.lastComma(); 1816 /* If we are indexing into an array that is really a type 1817 * tuple, rewrite this as an index into a type tuple and 1818 * try again. 1819 */ 1820 if (auto te = ce.isTypeExp()) 1821 { 1822 if (auto ttp = te.type.isTypeTuple()) 1823 { 1824 type = ttp; 1825 goto L1; 1826 } 1827 } 1828 /* *pvar is lazily initialized, so if we refer to $ 1829 * multiple times, it gets set only once. 1830 */ 1831 if (!*pvar) // if not already initialized 1832 { 1833 /* Create variable v and set it to the value of $ 1834 */ 1835 VarDeclaration v; 1836 Type t; 1837 if (auto tupexp = ce.isTupleExp()) 1838 { 1839 /* It is for an expression tuple, so the 1840 * length will be a const. 1841 */ 1842 Expression e = new IntegerExp(Loc.initial, tupexp.exps.dim, Type.tsize_t); 1843 v = new VarDeclaration(loc, Type.tsize_t, Id.dollar, new ExpInitializer(Loc.initial, e)); 1844 v.storage_class |= STC.temp | STC.static_ | STC.const_; 1845 } 1846 else if (ce.type && (t = ce.type.toBasetype()) !is null && (t.ty == Tstruct || t.ty == Tclass)) 1847 { 1848 // Look for opDollar 1849 assert(exp.op == TOK.array || exp.op == TOK.slice); 1850 AggregateDeclaration ad = isAggregate(t); 1851 assert(ad); 1852 Dsymbol s = ad.search(loc, Id.opDollar); 1853 if (!s) // no dollar exists -- search in higher scope 1854 return null; 1855 s = s.toAlias(); 1856 Expression e = null; 1857 // Check for multi-dimensional opDollar(dim) template. 1858 if (TemplateDeclaration td = s.isTemplateDeclaration()) 1859 { 1860 dinteger_t dim = 0; 1861 if (exp.op == TOK.array) 1862 { 1863 dim = (cast(ArrayExp)exp).currentDimension; 1864 } 1865 else if (exp.op == TOK.slice) 1866 { 1867 dim = 0; // slices are currently always one-dimensional 1868 } 1869 else 1870 { 1871 assert(0); 1872 } 1873 auto tiargs = new Objects(); 1874 Expression edim = new IntegerExp(Loc.initial, dim, Type.tsize_t); 1875 edim = edim.expressionSemantic(sc); 1876 tiargs.push(edim); 1877 e = new DotTemplateInstanceExp(loc, ce, td.ident, tiargs); 1878 } 1879 else 1880 { 1881 /* opDollar exists, but it's not a template. 1882 * This is acceptable ONLY for single-dimension indexing. 1883 * Note that it's impossible to have both template & function opDollar, 1884 * because both take no arguments. 1885 */ 1886 if (exp.op == TOK.array && (cast(ArrayExp)exp).arguments.dim != 1) 1887 { 1888 exp.error("`%s` only defines opDollar for one dimension", ad.toChars()); 1889 return null; 1890 } 1891 Declaration d = s.isDeclaration(); 1892 assert(d); 1893 e = new DotVarExp(loc, ce, d); 1894 } 1895 e = e.expressionSemantic(sc); 1896 if (!e.type) 1897 exp.error("`%s` has no value", e.toChars()); 1898 t = e.type.toBasetype(); 1899 if (t && t.ty == Tfunction) 1900 e = new CallExp(e.loc, e); 1901 v = new VarDeclaration(loc, null, Id.dollar, new ExpInitializer(Loc.initial, e)); 1902 v.storage_class |= STC.temp | STC.ctfe | STC.rvalue; 1903 } 1904 else 1905 { 1906 /* For arrays, $ will either be a compile-time constant 1907 * (in which case its value in set during constant-folding), 1908 * or a variable (in which case an expression is created in 1909 * toir.c). 1910 */ 1911 auto e = new VoidInitializer(Loc.initial); 1912 e.type = Type.tsize_t; 1913 v = new VarDeclaration(loc, Type.tsize_t, Id.dollar, e); 1914 v.storage_class |= STC.temp | STC.ctfe; // it's never a true static variable 1915 } 1916 *pvar = v; 1917 } 1918 (*pvar).dsymbolSemantic(sc); 1919 return (*pvar); 1920 } 1921 1922 override inout(ArrayScopeSymbol) isArrayScopeSymbol() inout 1923 { 1924 return this; 1925 } 1926 1927 override void accept(Visitor v) 1928 { 1929 v.visit(this); 1930 } 1931 } 1932 1933 /*********************************************************** 1934 * Overload Sets 1935 */ 1936 extern (C++) final class OverloadSet : Dsymbol 1937 { 1938 Dsymbols a; // array of Dsymbols 1939 1940 extern (D) this(Identifier ident, OverloadSet os = null) 1941 { 1942 super(ident); 1943 if (os) 1944 { 1945 a.pushSlice(os.a[]); 1946 } 1947 } 1948 1949 void push(Dsymbol s) 1950 { 1951 a.push(s); 1952 } 1953 1954 override inout(OverloadSet) isOverloadSet() inout 1955 { 1956 return this; 1957 } 1958 1959 override const(char)* kind() const 1960 { 1961 return "overloadset"; 1962 } 1963 1964 override void accept(Visitor v) 1965 { 1966 v.visit(this); 1967 } 1968 } 1969 1970 /*********************************************************** 1971 * Forwarding ScopeDsymbol. Used by ForwardingAttribDeclaration and 1972 * ForwardingScopeDeclaration to forward symbol insertions to another 1973 * scope. See `dmd.attrib.ForwardingAttribDeclaration` for more 1974 * details. 1975 */ 1976 extern (C++) final class ForwardingScopeDsymbol : ScopeDsymbol 1977 { 1978 /************************* 1979 * Symbol to forward insertions to. 1980 * Can be `null` before being lazily initialized. 1981 */ 1982 ScopeDsymbol forward; 1983 extern (D) this(ScopeDsymbol forward) 1984 { 1985 super(null); 1986 this.forward = forward; 1987 } 1988 override Dsymbol symtabInsert(Dsymbol s) 1989 { 1990 assert(forward); 1991 if (auto d = s.isDeclaration()) 1992 { 1993 if (d.storage_class & STC.local) 1994 { 1995 // Symbols with storage class STC.local are not 1996 // forwarded, but stored in the local symbol 1997 // table. (Those are the `static foreach` variables.) 1998 if (!symtab) 1999 { 2000 symtab = new DsymbolTable(); 2001 } 2002 return super.symtabInsert(s); // insert locally 2003 } 2004 } 2005 if (!forward.symtab) 2006 { 2007 forward.symtab = new DsymbolTable(); 2008 } 2009 // Non-STC.local symbols are forwarded to `forward`. 2010 return forward.symtabInsert(s); 2011 } 2012 2013 /************************ 2014 * This override handles the following two cases: 2015 * static foreach (i, i; [0]) { ... } 2016 * and 2017 * static foreach (i; [0]) { enum i = 2; } 2018 */ 2019 override Dsymbol symtabLookup(Dsymbol s, Identifier id) 2020 { 2021 assert(forward); 2022 // correctly diagnose clashing foreach loop variables. 2023 if (auto d = s.isDeclaration()) 2024 { 2025 if (d.storage_class & STC.local) 2026 { 2027 if (!symtab) 2028 { 2029 symtab = new DsymbolTable(); 2030 } 2031 return super.symtabLookup(s,id); 2032 } 2033 } 2034 // Declarations within `static foreach` do not clash with 2035 // `static foreach` loop variables. 2036 if (!forward.symtab) 2037 { 2038 forward.symtab = new DsymbolTable(); 2039 } 2040 return forward.symtabLookup(s,id); 2041 } 2042 2043 override void importScope(Dsymbol s, Prot protection) 2044 { 2045 forward.importScope(s, protection); 2046 } 2047 2048 override const(char)* kind()const{ return "local scope"; } 2049 2050 override inout(ForwardingScopeDsymbol) isForwardingScopeDsymbol() inout 2051 { 2052 return this; 2053 } 2054 2055 } 2056 2057 /** 2058 * Class that holds an expression in a Dsymbol wraper. 2059 * This is not an AST node, but a class used to pass 2060 * an expression as a function parameter of type Dsymbol. 2061 */ 2062 extern (C++) final class ExpressionDsymbol : Dsymbol 2063 { 2064 Expression exp; 2065 this(Expression exp) 2066 { 2067 super(); 2068 this.exp = exp; 2069 } 2070 2071 override inout(ExpressionDsymbol) isExpressionDsymbol() inout 2072 { 2073 return this; 2074 } 2075 } 2076 2077 2078 /*********************************************************** 2079 * Table of Dsymbol's 2080 */ 2081 extern (C++) final class DsymbolTable : RootObject 2082 { 2083 AssocArray!(Identifier, Dsymbol) tab; 2084 2085 // Look up Identifier. Return Dsymbol if found, NULL if not. 2086 Dsymbol lookup(const Identifier ident) 2087 { 2088 //printf("DsymbolTable::lookup(%s)\n", ident.toChars()); 2089 return tab[ident]; 2090 } 2091 2092 // Look for Dsymbol in table. If there, return it. If not, insert s and return that. 2093 Dsymbol update(Dsymbol s) 2094 { 2095 const ident = s.ident; 2096 Dsymbol* ps = tab.getLvalue(ident); 2097 *ps = s; 2098 return s; 2099 } 2100 2101 // Insert Dsymbol in table. Return NULL if already there. 2102 Dsymbol insert(Dsymbol s) 2103 { 2104 //printf("DsymbolTable::insert(this = %p, '%s')\n", this, s.ident.toChars()); 2105 return insert(s.ident, s); 2106 } 2107 2108 // when ident and s are not the same 2109 Dsymbol insert(const Identifier ident, Dsymbol s) 2110 { 2111 //printf("DsymbolTable::insert()\n"); 2112 Dsymbol* ps = tab.getLvalue(ident); 2113 if (*ps) 2114 return null; // already in table 2115 *ps = s; 2116 return s; 2117 } 2118 2119 /***** 2120 * Returns: 2121 * number of symbols in symbol table 2122 */ 2123 size_t length() const pure 2124 { 2125 return tab.length; 2126 } 2127 }