Lookup.h revision 8d267c57afb3af418ed5281b7a9bb4555d701a82
1//===--- Lookup.h - Classes for name lookup ---------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines the LookupResult class, which is integral to 11// Sema's name-lookup subsystem. 12// 13//===----------------------------------------------------------------------===// 14 15#ifndef LLVM_CLANG_SEMA_LOOKUP_H 16#define LLVM_CLANG_SEMA_LOOKUP_H 17 18#include "clang/Sema/Sema.h" 19#include "clang/AST/DeclCXX.h" 20 21namespace clang { 22 23/// @brief Represents the results of name lookup. 24/// 25/// An instance of the LookupResult class captures the results of a 26/// single name lookup, which can return no result (nothing found), 27/// a single declaration, a set of overloaded functions, or an 28/// ambiguity. Use the getKind() method to determine which of these 29/// results occurred for a given lookup. 30class LookupResult { 31public: 32 enum LookupResultKind { 33 /// @brief No entity found met the criteria. 34 NotFound = 0, 35 36 /// @brief No entity found met the criteria within the current 37 /// instantiation,, but there were dependent base classes of the 38 /// current instantiation that could not be searched. 39 NotFoundInCurrentInstantiation, 40 41 /// @brief Name lookup found a single declaration that met the 42 /// criteria. getFoundDecl() will return this declaration. 43 Found, 44 45 /// @brief Name lookup found a set of overloaded functions that 46 /// met the criteria. 47 FoundOverloaded, 48 49 /// @brief Name lookup found an unresolvable value declaration 50 /// and cannot yet complete. This only happens in C++ dependent 51 /// contexts with dependent using declarations. 52 FoundUnresolvedValue, 53 54 /// @brief Name lookup results in an ambiguity; use 55 /// getAmbiguityKind to figure out what kind of ambiguity 56 /// we have. 57 Ambiguous 58 }; 59 60 enum AmbiguityKind { 61 /// Name lookup results in an ambiguity because multiple 62 /// entities that meet the lookup criteria were found in 63 /// subobjects of different types. For example: 64 /// @code 65 /// struct A { void f(int); } 66 /// struct B { void f(double); } 67 /// struct C : A, B { }; 68 /// void test(C c) { 69 /// c.f(0); // error: A::f and B::f come from subobjects of different 70 /// // types. overload resolution is not performed. 71 /// } 72 /// @endcode 73 AmbiguousBaseSubobjectTypes, 74 75 /// Name lookup results in an ambiguity because multiple 76 /// nonstatic entities that meet the lookup criteria were found 77 /// in different subobjects of the same type. For example: 78 /// @code 79 /// struct A { int x; }; 80 /// struct B : A { }; 81 /// struct C : A { }; 82 /// struct D : B, C { }; 83 /// int test(D d) { 84 /// return d.x; // error: 'x' is found in two A subobjects (of B and C) 85 /// } 86 /// @endcode 87 AmbiguousBaseSubobjects, 88 89 /// Name lookup results in an ambiguity because multiple definitions 90 /// of entity that meet the lookup criteria were found in different 91 /// declaration contexts. 92 /// @code 93 /// namespace A { 94 /// int i; 95 /// namespace B { int i; } 96 /// int test() { 97 /// using namespace B; 98 /// return i; // error 'i' is found in namespace A and A::B 99 /// } 100 /// } 101 /// @endcode 102 AmbiguousReference, 103 104 /// Name lookup results in an ambiguity because an entity with a 105 /// tag name was hidden by an entity with an ordinary name from 106 /// a different context. 107 /// @code 108 /// namespace A { struct Foo {}; } 109 /// namespace B { void Foo(); } 110 /// namespace C { 111 /// using namespace A; 112 /// using namespace B; 113 /// } 114 /// void test() { 115 /// C::Foo(); // error: tag 'A::Foo' is hidden by an object in a 116 /// // different namespace 117 /// } 118 /// @endcode 119 AmbiguousTagHiding 120 }; 121 122 /// A little identifier for flagging temporary lookup results. 123 enum TemporaryToken { 124 Temporary 125 }; 126 127 typedef UnresolvedSetImpl::iterator iterator; 128 129 LookupResult(Sema &SemaRef, const DeclarationNameInfo &NameInfo, 130 Sema::LookupNameKind LookupKind, 131 Sema::RedeclarationKind Redecl = Sema::NotForRedeclaration) 132 : ResultKind(NotFound), 133 Paths(0), 134 NamingClass(0), 135 SemaRef(SemaRef), 136 NameInfo(NameInfo), 137 LookupKind(LookupKind), 138 IDNS(0), 139 Redecl(Redecl != Sema::NotForRedeclaration), 140 HideTags(true), 141 Diagnose(Redecl == Sema::NotForRedeclaration) 142 { 143 configure(); 144 } 145 146 // TODO: consider whether this constructor should be restricted to take 147 // as input a const IndentifierInfo* (instead of Name), 148 // forcing other cases towards the constructor taking a DNInfo. 149 LookupResult(Sema &SemaRef, DeclarationName Name, 150 SourceLocation NameLoc, Sema::LookupNameKind LookupKind, 151 Sema::RedeclarationKind Redecl = Sema::NotForRedeclaration) 152 : ResultKind(NotFound), 153 Paths(0), 154 NamingClass(0), 155 SemaRef(SemaRef), 156 NameInfo(Name, NameLoc), 157 LookupKind(LookupKind), 158 IDNS(0), 159 Redecl(Redecl != Sema::NotForRedeclaration), 160 HideTags(true), 161 Diagnose(Redecl == Sema::NotForRedeclaration) 162 { 163 configure(); 164 } 165 166 /// Creates a temporary lookup result, initializing its core data 167 /// using the information from another result. Diagnostics are always 168 /// disabled. 169 LookupResult(TemporaryToken _, const LookupResult &Other) 170 : ResultKind(NotFound), 171 Paths(0), 172 NamingClass(0), 173 SemaRef(Other.SemaRef), 174 NameInfo(Other.NameInfo), 175 LookupKind(Other.LookupKind), 176 IDNS(Other.IDNS), 177 Redecl(Other.Redecl), 178 HideTags(Other.HideTags), 179 Diagnose(false) 180 {} 181 182 ~LookupResult() { 183 if (Diagnose) diagnose(); 184 if (Paths) deletePaths(Paths); 185 } 186 187 /// Gets the name info to look up. 188 const DeclarationNameInfo &getLookupNameInfo() const { 189 return NameInfo; 190 } 191 192 /// \brief Sets the name info to look up. 193 void setLookupNameInfo(const DeclarationNameInfo &NameInfo) { 194 this->NameInfo = NameInfo; 195 } 196 197 /// Gets the name to look up. 198 DeclarationName getLookupName() const { 199 return NameInfo.getName(); 200 } 201 202 /// \brief Sets the name to look up. 203 void setLookupName(DeclarationName Name) { 204 NameInfo.setName(Name); 205 } 206 207 /// Gets the kind of lookup to perform. 208 Sema::LookupNameKind getLookupKind() const { 209 return LookupKind; 210 } 211 212 /// True if this lookup is just looking for an existing declaration. 213 bool isForRedeclaration() const { 214 return Redecl; 215 } 216 217 /// Sets whether tag declarations should be hidden by non-tag 218 /// declarations during resolution. The default is true. 219 void setHideTags(bool Hide) { 220 HideTags = Hide; 221 } 222 223 bool isAmbiguous() const { 224 return getResultKind() == Ambiguous; 225 } 226 227 /// Determines if this names a single result which is not an 228 /// unresolved value using decl. If so, it is safe to call 229 /// getFoundDecl(). 230 bool isSingleResult() const { 231 return getResultKind() == Found; 232 } 233 234 /// Determines if the results are overloaded. 235 bool isOverloadedResult() const { 236 return getResultKind() == FoundOverloaded; 237 } 238 239 bool isUnresolvableResult() const { 240 return getResultKind() == FoundUnresolvedValue; 241 } 242 243 LookupResultKind getResultKind() const { 244 sanity(); 245 return ResultKind; 246 } 247 248 AmbiguityKind getAmbiguityKind() const { 249 assert(isAmbiguous()); 250 return Ambiguity; 251 } 252 253 const UnresolvedSetImpl &asUnresolvedSet() const { 254 return Decls; 255 } 256 257 iterator begin() const { return iterator(Decls.begin()); } 258 iterator end() const { return iterator(Decls.end()); } 259 260 /// \brief Return true if no decls were found 261 bool empty() const { return Decls.empty(); } 262 263 /// \brief Return the base paths structure that's associated with 264 /// these results, or null if none is. 265 CXXBasePaths *getBasePaths() const { 266 return Paths; 267 } 268 269 /// \brief Tests whether the given declaration is acceptable. 270 bool isAcceptableDecl(NamedDecl *D) const { 271 if (!D->isInIdentifierNamespace(IDNS)) 272 return false; 273 274 // So long as this declaration is not module-private or was parsed as 275 // part of this translation unit (i.e., in the module), we're allowed to 276 // find it. 277 if (!D->isModulePrivate() || D->getPCHLevel() == 0) 278 return true; 279 280 // FIXME: We should be allowed to refer to a module-private name from 281 // within the same module, e.g., during template instantiation. 282 // This requires us know which module a particular declaration came from. 283 return false; 284 } 285 286 /// \brief Returns the identifier namespace mask for this lookup. 287 unsigned getIdentifierNamespace() const { 288 return IDNS; 289 } 290 291 /// \brief Returns whether these results arose from performing a 292 /// lookup into a class. 293 bool isClassLookup() const { 294 return NamingClass != 0; 295 } 296 297 /// \brief Set whether the name lookup is triggered by a 298 /// using declaration. 299 void setUsingDeclaration(bool U) { 300 UsingDeclaration = U; 301 } 302 303 /// \brief Returns whether the name lookup is triggered by a 304 /// using declaration. 305 bool isUsingDeclaration() const { 306 return UsingDeclaration; 307 } 308 309 /// \brief Returns the 'naming class' for this lookup, i.e. the 310 /// class which was looked into to find these results. 311 /// 312 /// C++0x [class.access.base]p5: 313 /// The access to a member is affected by the class in which the 314 /// member is named. This naming class is the class in which the 315 /// member name was looked up and found. [Note: this class can be 316 /// explicit, e.g., when a qualified-id is used, or implicit, 317 /// e.g., when a class member access operator (5.2.5) is used 318 /// (including cases where an implicit "this->" is added). If both 319 /// a class member access operator and a qualified-id are used to 320 /// name the member (as in p->T::m), the class naming the member 321 /// is the class named by the nested-name-specifier of the 322 /// qualified-id (that is, T). -- end note ] 323 /// 324 /// This is set by the lookup routines when they find results in a class. 325 CXXRecordDecl *getNamingClass() const { 326 return NamingClass; 327 } 328 329 /// \brief Sets the 'naming class' for this lookup. 330 void setNamingClass(CXXRecordDecl *Record) { 331 NamingClass = Record; 332 } 333 334 /// \brief Returns the base object type associated with this lookup; 335 /// important for [class.protected]. Most lookups do not have an 336 /// associated base object. 337 QualType getBaseObjectType() const { 338 return BaseObjectType; 339 } 340 341 /// \brief Sets the base object type for this lookup. 342 void setBaseObjectType(QualType T) { 343 BaseObjectType = T; 344 } 345 346 /// \brief Add a declaration to these results with its natural access. 347 /// Does not test the acceptance criteria. 348 void addDecl(NamedDecl *D) { 349 addDecl(D, D->getAccess()); 350 } 351 352 /// \brief Add a declaration to these results with the given access. 353 /// Does not test the acceptance criteria. 354 void addDecl(NamedDecl *D, AccessSpecifier AS) { 355 Decls.addDecl(D, AS); 356 ResultKind = Found; 357 } 358 359 /// \brief Add all the declarations from another set of lookup 360 /// results. 361 void addAllDecls(const LookupResult &Other) { 362 Decls.append(Other.Decls.begin(), Other.Decls.end()); 363 ResultKind = Found; 364 } 365 366 /// \brief Determine whether no result was found because we could not 367 /// search into dependent base classes of the current instantiation. 368 bool wasNotFoundInCurrentInstantiation() const { 369 return ResultKind == NotFoundInCurrentInstantiation; 370 } 371 372 /// \brief Note that while no result was found in the current instantiation, 373 /// there were dependent base classes that could not be searched. 374 void setNotFoundInCurrentInstantiation() { 375 assert(ResultKind == NotFound && Decls.empty()); 376 ResultKind = NotFoundInCurrentInstantiation; 377 } 378 379 /// \brief Resolves the result kind of the lookup, possibly hiding 380 /// decls. 381 /// 382 /// This should be called in any environment where lookup might 383 /// generate multiple lookup results. 384 void resolveKind(); 385 386 /// \brief Re-resolves the result kind of the lookup after a set of 387 /// removals has been performed. 388 void resolveKindAfterFilter() { 389 if (Decls.empty()) { 390 if (ResultKind != NotFoundInCurrentInstantiation) 391 ResultKind = NotFound; 392 393 if (Paths) { 394 deletePaths(Paths); 395 Paths = 0; 396 } 397 } else { 398 AmbiguityKind SavedAK = Ambiguity; 399 ResultKind = Found; 400 resolveKind(); 401 402 // If we didn't make the lookup unambiguous, restore the old 403 // ambiguity kind. 404 if (ResultKind == Ambiguous) { 405 Ambiguity = SavedAK; 406 } else if (Paths) { 407 deletePaths(Paths); 408 Paths = 0; 409 } 410 } 411 } 412 413 template <class DeclClass> 414 DeclClass *getAsSingle() const { 415 if (getResultKind() != Found) return 0; 416 return dyn_cast<DeclClass>(getFoundDecl()); 417 } 418 419 /// \brief Fetch the unique decl found by this lookup. Asserts 420 /// that one was found. 421 /// 422 /// This is intended for users who have examined the result kind 423 /// and are certain that there is only one result. 424 NamedDecl *getFoundDecl() const { 425 assert(getResultKind() == Found 426 && "getFoundDecl called on non-unique result"); 427 return (*begin())->getUnderlyingDecl(); 428 } 429 430 /// Fetches a representative decl. Useful for lazy diagnostics. 431 NamedDecl *getRepresentativeDecl() const { 432 assert(!Decls.empty() && "cannot get representative of empty set"); 433 return *begin(); 434 } 435 436 /// \brief Asks if the result is a single tag decl. 437 bool isSingleTagDecl() const { 438 return getResultKind() == Found && isa<TagDecl>(getFoundDecl()); 439 } 440 441 /// \brief Make these results show that the name was found in 442 /// base classes of different types. 443 /// 444 /// The given paths object is copied and invalidated. 445 void setAmbiguousBaseSubobjectTypes(CXXBasePaths &P); 446 447 /// \brief Make these results show that the name was found in 448 /// distinct base classes of the same type. 449 /// 450 /// The given paths object is copied and invalidated. 451 void setAmbiguousBaseSubobjects(CXXBasePaths &P); 452 453 /// \brief Make these results show that the name was found in 454 /// different contexts and a tag decl was hidden by an ordinary 455 /// decl in a different context. 456 void setAmbiguousQualifiedTagHiding() { 457 setAmbiguous(AmbiguousTagHiding); 458 } 459 460 /// \brief Clears out any current state. 461 void clear() { 462 ResultKind = NotFound; 463 Decls.clear(); 464 if (Paths) deletePaths(Paths); 465 Paths = NULL; 466 NamingClass = 0; 467 } 468 469 /// \brief Clears out any current state and re-initializes for a 470 /// different kind of lookup. 471 void clear(Sema::LookupNameKind Kind) { 472 clear(); 473 LookupKind = Kind; 474 configure(); 475 } 476 477 /// \brief Change this lookup's redeclaration kind. 478 void setRedeclarationKind(Sema::RedeclarationKind RK) { 479 Redecl = RK; 480 configure(); 481 } 482 483 void print(raw_ostream &); 484 485 /// Suppress the diagnostics that would normally fire because of this 486 /// lookup. This happens during (e.g.) redeclaration lookups. 487 void suppressDiagnostics() { 488 Diagnose = false; 489 } 490 491 /// Determines whether this lookup is suppressing diagnostics. 492 bool isSuppressingDiagnostics() const { 493 return !Diagnose; 494 } 495 496 /// Sets a 'context' source range. 497 void setContextRange(SourceRange SR) { 498 NameContextRange = SR; 499 } 500 501 /// Gets the source range of the context of this name; for C++ 502 /// qualified lookups, this is the source range of the scope 503 /// specifier. 504 SourceRange getContextRange() const { 505 return NameContextRange; 506 } 507 508 /// Gets the location of the identifier. This isn't always defined: 509 /// sometimes we're doing lookups on synthesized names. 510 SourceLocation getNameLoc() const { 511 return NameInfo.getLoc(); 512 } 513 514 /// \brief Get the Sema object that this lookup result is searching 515 /// with. 516 Sema &getSema() const { return SemaRef; } 517 518 /// A class for iterating through a result set and possibly 519 /// filtering out results. The results returned are possibly 520 /// sugared. 521 class Filter { 522 LookupResult &Results; 523 LookupResult::iterator I; 524 bool Changed; 525 bool CalledDone; 526 527 friend class LookupResult; 528 Filter(LookupResult &Results) 529 : Results(Results), I(Results.begin()), Changed(false), CalledDone(false) 530 {} 531 532 public: 533 ~Filter() { 534 assert(CalledDone && 535 "LookupResult::Filter destroyed without done() call"); 536 } 537 538 bool hasNext() const { 539 return I != Results.end(); 540 } 541 542 NamedDecl *next() { 543 assert(I != Results.end() && "next() called on empty filter"); 544 return *I++; 545 } 546 547 /// Erase the last element returned from this iterator. 548 void erase() { 549 Results.Decls.erase(--I); 550 Changed = true; 551 } 552 553 /// Replaces the current entry with the given one, preserving the 554 /// access bits. 555 void replace(NamedDecl *D) { 556 Results.Decls.replace(I-1, D); 557 Changed = true; 558 } 559 560 /// Replaces the current entry with the given one. 561 void replace(NamedDecl *D, AccessSpecifier AS) { 562 Results.Decls.replace(I-1, D, AS); 563 Changed = true; 564 } 565 566 void done() { 567 assert(!CalledDone && "done() called twice"); 568 CalledDone = true; 569 570 if (Changed) 571 Results.resolveKindAfterFilter(); 572 } 573 }; 574 575 /// Create a filter for this result set. 576 Filter makeFilter() { 577 return Filter(*this); 578 } 579 580private: 581 void diagnose() { 582 if (isAmbiguous()) 583 SemaRef.DiagnoseAmbiguousLookup(*this); 584 else if (isClassLookup() && SemaRef.getLangOptions().AccessControl) 585 SemaRef.CheckLookupAccess(*this); 586 } 587 588 void setAmbiguous(AmbiguityKind AK) { 589 ResultKind = Ambiguous; 590 Ambiguity = AK; 591 } 592 593 void addDeclsFromBasePaths(const CXXBasePaths &P); 594 void configure(); 595 596 // Sanity checks. 597 void sanity() const; 598 599 bool sanityCheckUnresolved() const { 600 for (iterator I = begin(), E = end(); I != E; ++I) 601 if (isa<UnresolvedUsingValueDecl>(*I)) 602 return true; 603 return false; 604 } 605 606 static void deletePaths(CXXBasePaths *); 607 608 // Results. 609 LookupResultKind ResultKind; 610 AmbiguityKind Ambiguity; // ill-defined unless ambiguous 611 UnresolvedSet<8> Decls; 612 CXXBasePaths *Paths; 613 CXXRecordDecl *NamingClass; 614 QualType BaseObjectType; 615 616 // Parameters. 617 Sema &SemaRef; 618 DeclarationNameInfo NameInfo; 619 SourceRange NameContextRange; 620 Sema::LookupNameKind LookupKind; 621 unsigned IDNS; // set by configure() 622 623 bool Redecl; 624 625 /// \brief True if tag declarations should be hidden if non-tags 626 /// are present 627 bool HideTags; 628 629 bool Diagnose; 630 631 /// \brief True if the lookup is triggered by a using declaration. 632 /// Necessary to handle a MSVC bug. 633 bool UsingDeclaration; 634}; 635 636 /// \brief Consumes visible declarations found when searching for 637 /// all visible names within a given scope or context. 638 /// 639 /// This abstract class is meant to be subclassed by clients of \c 640 /// Sema::LookupVisibleDecls(), each of which should override the \c 641 /// FoundDecl() function to process declarations as they are found. 642 class VisibleDeclConsumer { 643 public: 644 /// \brief Destroys the visible declaration consumer. 645 virtual ~VisibleDeclConsumer(); 646 647 /// \brief Invoked each time \p Sema::LookupVisibleDecls() finds a 648 /// declaration visible from the current scope or context. 649 /// 650 /// \param ND the declaration found. 651 /// 652 /// \param Hiding a declaration that hides the declaration \p ND, 653 /// or NULL if no such declaration exists. 654 /// 655 /// \param InBaseClass whether this declaration was found in base 656 /// class of the context we searched. 657 virtual void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, 658 bool InBaseClass) = 0; 659 }; 660 661/// \brief A class for storing results from argument-dependent lookup. 662class ADLResult { 663private: 664 /// A map from canonical decls to the 'most recent' decl. 665 llvm::DenseMap<NamedDecl*, NamedDecl*> Decls; 666 667public: 668 /// Adds a new ADL candidate to this map. 669 void insert(NamedDecl *D); 670 671 /// Removes any data associated with a given decl. 672 void erase(NamedDecl *D) { 673 Decls.erase(cast<NamedDecl>(D->getCanonicalDecl())); 674 } 675 676 class iterator { 677 typedef llvm::DenseMap<NamedDecl*,NamedDecl*>::iterator inner_iterator; 678 inner_iterator iter; 679 680 friend class ADLResult; 681 iterator(const inner_iterator &iter) : iter(iter) {} 682 public: 683 iterator() {} 684 685 iterator &operator++() { ++iter; return *this; } 686 iterator operator++(int) { return iterator(iter++); } 687 688 NamedDecl *operator*() const { return iter->second; } 689 690 bool operator==(const iterator &other) const { return iter == other.iter; } 691 bool operator!=(const iterator &other) const { return iter != other.iter; } 692 }; 693 694 iterator begin() { return iterator(Decls.begin()); } 695 iterator end() { return iterator(Decls.end()); } 696}; 697 698} 699 700#endif 701