Lookup.h revision 7ec1873d694cf870264694d2b61219a03492bc30
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 return D->isInIdentifierNamespace(IDNS); 272 } 273 274 /// \brief Returns the identifier namespace mask for this lookup. 275 unsigned getIdentifierNamespace() const { 276 return IDNS; 277 } 278 279 /// \brief Returns whether these results arose from performing a 280 /// lookup into a class. 281 bool isClassLookup() const { 282 return NamingClass != 0; 283 } 284 285 /// \brief Returns the 'naming class' for this lookup, i.e. the 286 /// class which was looked into to find these results. 287 /// 288 /// C++0x [class.access.base]p5: 289 /// The access to a member is affected by the class in which the 290 /// member is named. This naming class is the class in which the 291 /// member name was looked up and found. [Note: this class can be 292 /// explicit, e.g., when a qualified-id is used, or implicit, 293 /// e.g., when a class member access operator (5.2.5) is used 294 /// (including cases where an implicit "this->" is added). If both 295 /// a class member access operator and a qualified-id are used to 296 /// name the member (as in p->T::m), the class naming the member 297 /// is the class named by the nested-name-specifier of the 298 /// qualified-id (that is, T). -- end note ] 299 /// 300 /// This is set by the lookup routines when they find results in a class. 301 CXXRecordDecl *getNamingClass() const { 302 return NamingClass; 303 } 304 305 /// \brief Sets the 'naming class' for this lookup. 306 void setNamingClass(CXXRecordDecl *Record) { 307 NamingClass = Record; 308 } 309 310 /// \brief Returns the base object type associated with this lookup; 311 /// important for [class.protected]. Most lookups do not have an 312 /// associated base object. 313 QualType getBaseObjectType() const { 314 return BaseObjectType; 315 } 316 317 /// \brief Sets the base object type for this lookup. 318 void setBaseObjectType(QualType T) { 319 BaseObjectType = T; 320 } 321 322 /// \brief Add a declaration to these results with its natural access. 323 /// Does not test the acceptance criteria. 324 void addDecl(NamedDecl *D) { 325 addDecl(D, D->getAccess()); 326 } 327 328 /// \brief Add a declaration to these results with the given access. 329 /// Does not test the acceptance criteria. 330 void addDecl(NamedDecl *D, AccessSpecifier AS) { 331 Decls.addDecl(D, AS); 332 ResultKind = Found; 333 } 334 335 /// \brief Add all the declarations from another set of lookup 336 /// results. 337 void addAllDecls(const LookupResult &Other) { 338 Decls.append(Other.Decls.begin(), Other.Decls.end()); 339 ResultKind = Found; 340 } 341 342 /// \brief Determine whether no result was found because we could not 343 /// search into dependent base classes of the current instantiation. 344 bool wasNotFoundInCurrentInstantiation() const { 345 return ResultKind == NotFoundInCurrentInstantiation; 346 } 347 348 /// \brief Note that while no result was found in the current instantiation, 349 /// there were dependent base classes that could not be searched. 350 void setNotFoundInCurrentInstantiation() { 351 assert(ResultKind == NotFound && Decls.empty()); 352 ResultKind = NotFoundInCurrentInstantiation; 353 } 354 355 /// \brief Resolves the result kind of the lookup, possibly hiding 356 /// decls. 357 /// 358 /// This should be called in any environment where lookup might 359 /// generate multiple lookup results. 360 void resolveKind(); 361 362 /// \brief Re-resolves the result kind of the lookup after a set of 363 /// removals has been performed. 364 void resolveKindAfterFilter() { 365 if (Decls.empty()) { 366 if (ResultKind != NotFoundInCurrentInstantiation) 367 ResultKind = NotFound; 368 369 if (Paths) { 370 deletePaths(Paths); 371 Paths = 0; 372 } 373 } else { 374 AmbiguityKind SavedAK = Ambiguity; 375 ResultKind = Found; 376 resolveKind(); 377 378 // If we didn't make the lookup unambiguous, restore the old 379 // ambiguity kind. 380 if (ResultKind == Ambiguous) { 381 Ambiguity = SavedAK; 382 } else if (Paths) { 383 deletePaths(Paths); 384 Paths = 0; 385 } 386 } 387 } 388 389 template <class DeclClass> 390 DeclClass *getAsSingle() const { 391 if (getResultKind() != Found) return 0; 392 return dyn_cast<DeclClass>(getFoundDecl()); 393 } 394 395 /// \brief Fetch the unique decl found by this lookup. Asserts 396 /// that one was found. 397 /// 398 /// This is intended for users who have examined the result kind 399 /// and are certain that there is only one result. 400 NamedDecl *getFoundDecl() const { 401 assert(getResultKind() == Found 402 && "getFoundDecl called on non-unique result"); 403 return (*begin())->getUnderlyingDecl(); 404 } 405 406 /// Fetches a representative decl. Useful for lazy diagnostics. 407 NamedDecl *getRepresentativeDecl() const { 408 assert(!Decls.empty() && "cannot get representative of empty set"); 409 return *begin(); 410 } 411 412 /// \brief Asks if the result is a single tag decl. 413 bool isSingleTagDecl() const { 414 return getResultKind() == Found && isa<TagDecl>(getFoundDecl()); 415 } 416 417 /// \brief Make these results show that the name was found in 418 /// base classes of different types. 419 /// 420 /// The given paths object is copied and invalidated. 421 void setAmbiguousBaseSubobjectTypes(CXXBasePaths &P); 422 423 /// \brief Make these results show that the name was found in 424 /// distinct base classes of the same type. 425 /// 426 /// The given paths object is copied and invalidated. 427 void setAmbiguousBaseSubobjects(CXXBasePaths &P); 428 429 /// \brief Make these results show that the name was found in 430 /// different contexts and a tag decl was hidden by an ordinary 431 /// decl in a different context. 432 void setAmbiguousQualifiedTagHiding() { 433 setAmbiguous(AmbiguousTagHiding); 434 } 435 436 /// \brief Clears out any current state. 437 void clear() { 438 ResultKind = NotFound; 439 Decls.clear(); 440 if (Paths) deletePaths(Paths); 441 Paths = NULL; 442 NamingClass = 0; 443 } 444 445 /// \brief Clears out any current state and re-initializes for a 446 /// different kind of lookup. 447 void clear(Sema::LookupNameKind Kind) { 448 clear(); 449 LookupKind = Kind; 450 configure(); 451 } 452 453 /// \brief Change this lookup's redeclaration kind. 454 void setRedeclarationKind(Sema::RedeclarationKind RK) { 455 Redecl = RK; 456 configure(); 457 } 458 459 void print(llvm::raw_ostream &); 460 461 /// Suppress the diagnostics that would normally fire because of this 462 /// lookup. This happens during (e.g.) redeclaration lookups. 463 void suppressDiagnostics() { 464 Diagnose = false; 465 } 466 467 /// Determines whether this lookup is suppressing diagnostics. 468 bool isSuppressingDiagnostics() const { 469 return !Diagnose; 470 } 471 472 /// Sets a 'context' source range. 473 void setContextRange(SourceRange SR) { 474 NameContextRange = SR; 475 } 476 477 /// Gets the source range of the context of this name; for C++ 478 /// qualified lookups, this is the source range of the scope 479 /// specifier. 480 SourceRange getContextRange() const { 481 return NameContextRange; 482 } 483 484 /// Gets the location of the identifier. This isn't always defined: 485 /// sometimes we're doing lookups on synthesized names. 486 SourceLocation getNameLoc() const { 487 return NameInfo.getLoc(); 488 } 489 490 /// \brief Get the Sema object that this lookup result is searching 491 /// with. 492 Sema &getSema() const { return SemaRef; } 493 494 /// A class for iterating through a result set and possibly 495 /// filtering out results. The results returned are possibly 496 /// sugared. 497 class Filter { 498 LookupResult &Results; 499 LookupResult::iterator I; 500 bool Changed; 501 bool CalledDone; 502 503 friend class LookupResult; 504 Filter(LookupResult &Results) 505 : Results(Results), I(Results.begin()), Changed(false), CalledDone(false) 506 {} 507 508 public: 509 ~Filter() { 510 assert(CalledDone && 511 "LookupResult::Filter destroyed without done() call"); 512 } 513 514 bool hasNext() const { 515 return I != Results.end(); 516 } 517 518 NamedDecl *next() { 519 assert(I != Results.end() && "next() called on empty filter"); 520 return *I++; 521 } 522 523 /// Erase the last element returned from this iterator. 524 void erase() { 525 Results.Decls.erase(--I); 526 Changed = true; 527 } 528 529 /// Replaces the current entry with the given one, preserving the 530 /// access bits. 531 void replace(NamedDecl *D) { 532 Results.Decls.replace(I-1, D); 533 Changed = true; 534 } 535 536 /// Replaces the current entry with the given one. 537 void replace(NamedDecl *D, AccessSpecifier AS) { 538 Results.Decls.replace(I-1, D, AS); 539 Changed = true; 540 } 541 542 void done() { 543 assert(!CalledDone && "done() called twice"); 544 CalledDone = true; 545 546 if (Changed) 547 Results.resolveKindAfterFilter(); 548 } 549 }; 550 551 /// Create a filter for this result set. 552 Filter makeFilter() { 553 return Filter(*this); 554 } 555 556private: 557 void diagnose() { 558 if (isAmbiguous()) 559 SemaRef.DiagnoseAmbiguousLookup(*this); 560 else if (isClassLookup() && SemaRef.getLangOptions().AccessControl) 561 SemaRef.CheckLookupAccess(*this); 562 } 563 564 void setAmbiguous(AmbiguityKind AK) { 565 ResultKind = Ambiguous; 566 Ambiguity = AK; 567 } 568 569 void addDeclsFromBasePaths(const CXXBasePaths &P); 570 void configure(); 571 572 // Sanity checks. 573 void sanity() const; 574 575 bool sanityCheckUnresolved() const { 576 for (iterator I = begin(), E = end(); I != E; ++I) 577 if (isa<UnresolvedUsingValueDecl>(*I)) 578 return true; 579 return false; 580 } 581 582 static void deletePaths(CXXBasePaths *); 583 584 // Results. 585 LookupResultKind ResultKind; 586 AmbiguityKind Ambiguity; // ill-defined unless ambiguous 587 UnresolvedSet<8> Decls; 588 CXXBasePaths *Paths; 589 CXXRecordDecl *NamingClass; 590 QualType BaseObjectType; 591 592 // Parameters. 593 Sema &SemaRef; 594 DeclarationNameInfo NameInfo; 595 SourceRange NameContextRange; 596 Sema::LookupNameKind LookupKind; 597 unsigned IDNS; // set by configure() 598 599 bool Redecl; 600 601 /// \brief True if tag declarations should be hidden if non-tags 602 /// are present 603 bool HideTags; 604 605 bool Diagnose; 606}; 607 608 /// \brief Consumes visible declarations found when searching for 609 /// all visible names within a given scope or context. 610 /// 611 /// This abstract class is meant to be subclassed by clients of \c 612 /// Sema::LookupVisibleDecls(), each of which should override the \c 613 /// FoundDecl() function to process declarations as they are found. 614 class VisibleDeclConsumer { 615 public: 616 /// \brief Destroys the visible declaration consumer. 617 virtual ~VisibleDeclConsumer(); 618 619 /// \brief Invoked each time \p Sema::LookupVisibleDecls() finds a 620 /// declaration visible from the current scope or context. 621 /// 622 /// \param ND the declaration found. 623 /// 624 /// \param Hiding a declaration that hides the declaration \p ND, 625 /// or NULL if no such declaration exists. 626 /// 627 /// \param InBaseClass whether this declaration was found in base 628 /// class of the context we searched. 629 virtual void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, 630 bool InBaseClass) = 0; 631 }; 632 633/// \brief A class for storing results from argument-dependent lookup. 634class ADLResult { 635private: 636 /// A map from canonical decls to the 'most recent' decl. 637 llvm::DenseMap<NamedDecl*, NamedDecl*> Decls; 638 639public: 640 /// Adds a new ADL candidate to this map. 641 void insert(NamedDecl *D); 642 643 /// Removes any data associated with a given decl. 644 void erase(NamedDecl *D) { 645 Decls.erase(cast<NamedDecl>(D->getCanonicalDecl())); 646 } 647 648 class iterator { 649 typedef llvm::DenseMap<NamedDecl*,NamedDecl*>::iterator inner_iterator; 650 inner_iterator iter; 651 652 friend class ADLResult; 653 iterator(const inner_iterator &iter) : iter(iter) {} 654 public: 655 iterator() {} 656 657 iterator &operator++() { ++iter; return *this; } 658 iterator operator++(int) { return iterator(iter++); } 659 660 NamedDecl *operator*() const { return iter->second; } 661 662 bool operator==(const iterator &other) const { return iter == other.iter; } 663 bool operator!=(const iterator &other) const { return iter != other.iter; } 664 }; 665 666 iterator begin() { return iterator(Decls.begin()); } 667 iterator end() { return iterator(Decls.end()); } 668}; 669 670} 671 672#endif 673