include/clang/Sema/Lookup.h

   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
  21 namespace 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.
  30 class LookupResult {
  31 public:
  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     } else {
 369       AmbiguityKind SavedAK = Ambiguity;
 370       ResultKind = Found;
 371       resolveKind();
 372
 373       // If we didn't make the lookup unambiguous, restore the old
 374       // ambiguity kind.
 375       if (ResultKind == Ambiguous) {
 376         Ambiguity = SavedAK;
 377       } else if (Paths) {
 378         deletePaths(Paths);
 379         Paths = 0;
 380       }
 381     }
 382   }
 383
 384   template <class DeclClass>
 385   DeclClass *getAsSingle() const {
 386     if (getResultKind() != Found) return 0;
 387     return dyn_cast<DeclClass>(getFoundDecl());
 388   }
 389
 390   /// \brief Fetch the unique decl found by this lookup.  Asserts
 391   /// that one was found.
 392   ///
 393   /// This is intended for users who have examined the result kind
 394   /// and are certain that there is only one result.
 395   NamedDecl *getFoundDecl() const {
 396     assert(getResultKind() == Found
 397            && "getFoundDecl called on non-unique result");
 398     return (*begin())->getUnderlyingDecl();
 399   }
 400
 401   /// Fetches a representative decl.  Useful for lazy diagnostics.
 402   NamedDecl *getRepresentativeDecl() const {
 403     assert(!Decls.empty() && "cannot get representative of empty set");
 404     return *begin();
 405   }
 406
 407   /// \brief Asks if the result is a single tag decl.
 408   bool isSingleTagDecl() const {
 409     return getResultKind() == Found && isa<TagDecl>(getFoundDecl());
 410   }
 411
 412   /// \brief Make these results show that the name was found in
 413   /// base classes of different types.
 414   ///
 415   /// The given paths object is copied and invalidated.
 416   void setAmbiguousBaseSubobjectTypes(CXXBasePaths &P);
 417
 418   /// \brief Make these results show that the name was found in
 419   /// distinct base classes of the same type.
 420   ///
 421   /// The given paths object is copied and invalidated.
 422   void setAmbiguousBaseSubobjects(CXXBasePaths &P);
 423
 424   /// \brief Make these results show that the name was found in
 425   /// different contexts and a tag decl was hidden by an ordinary
 426   /// decl in a different context.
 427   void setAmbiguousQualifiedTagHiding() {
 428     setAmbiguous(AmbiguousTagHiding);
 429   }
 430
 431   /// \brief Clears out any current state.
 432   void clear() {
 433     ResultKind = NotFound;
 434     Decls.clear();
 435     if (Paths) deletePaths(Paths);
 436     Paths = NULL;
 437   }
 438
 439   /// \brief Clears out any current state and re-initializes for a
 440   /// different kind of lookup.
 441   void clear(Sema::LookupNameKind Kind) {
 442     clear();
 443     LookupKind = Kind;
 444     configure();
 445   }
 446
 447   /// \brief Change this lookup's redeclaration kind.
 448   void setRedeclarationKind(Sema::RedeclarationKind RK) {
 449     Redecl = RK;
 450     configure();
 451   }
 452
 453   void print(llvm::raw_ostream &);
 454
 455   /// Suppress the diagnostics that would normally fire because of this
 456   /// lookup.  This happens during (e.g.) redeclaration lookups.
 457   void suppressDiagnostics() {
 458     Diagnose = false;
 459   }
 460
 461   /// Determines whether this lookup is suppressing diagnostics.
 462   bool isSuppressingDiagnostics() const {
 463     return !Diagnose;
 464   }
 465
 466   /// Sets a 'context' source range.
 467   void setContextRange(SourceRange SR) {
 468     NameContextRange = SR;
 469   }
 470
 471   /// Gets the source range of the context of this name; for C++
 472   /// qualified lookups, this is the source range of the scope
 473   /// specifier.
 474   SourceRange getContextRange() const {
 475     return NameContextRange;
 476   }
 477
 478   /// Gets the location of the identifier.  This isn't always defined:
 479   /// sometimes we're doing lookups on synthesized names.
 480   SourceLocation getNameLoc() const {
 481     return NameInfo.getLoc();
 482   }
 483
 484   /// \brief Get the Sema object that this lookup result is searching
 485   /// with.
 486   Sema &getSema() const { return SemaRef; }
 487
 488   /// A class for iterating through a result set and possibly
 489   /// filtering out results.  The results returned are possibly
 490   /// sugared.
 491   class Filter {
 492     LookupResult &Results;
 493     LookupResult::iterator I;
 494     bool Changed;
 495 #ifndef NDEBUG
 496     bool CalledDone;
 497 #endif
 498
 499     friend class LookupResult;
 500     Filter(LookupResult &Results)
 501       : Results(Results), I(Results.begin()), Changed(false)
 502 #ifndef NDEBUG
 503       , CalledDone(false)
 504 #endif
 505     {}
 506
 507   public:
 508 #ifndef NDEBUG
 509     ~Filter() {
 510       assert(CalledDone &&
 511              "LookupResult::Filter destroyed without done() call");
 512     }
 513 #endif
 514
 515     bool hasNext() const {
 516       return I != Results.end();
 517     }
 518
 519     NamedDecl *next() {
 520       assert(I != Results.end() && "next() called on empty filter");
 521       return *I++;
 522     }
 523
 524     /// Erase the last element returned from this iterator.
 525     void erase() {
 526       Results.Decls.erase(--I);
 527       Changed = true;
 528     }
 529
 530     /// Replaces the current entry with the given one, preserving the
 531     /// access bits.
 532     void replace(NamedDecl *D) {
 533       Results.Decls.replace(I-1, D);
 534       Changed = true;
 535     }
 536
 537     /// Replaces the current entry with the given one.
 538     void replace(NamedDecl *D, AccessSpecifier AS) {
 539       Results.Decls.replace(I-1, D, AS);
 540       Changed = true;
 541     }
 542
 543     void done() {
 544 #ifndef NDEBUG
 545       assert(!CalledDone && "done() called twice");
 546       CalledDone = true;
 547 #endif
 548
 549       if (Changed)
 550         Results.resolveKindAfterFilter();
 551     }
 552   };
 553
 554   /// Create a filter for this result set.
 555   Filter makeFilter() {
 556     return Filter(*this);
 557   }
 558
 559 private:
 560   void diagnose() {
 561     if (isAmbiguous())
 562       SemaRef.DiagnoseAmbiguousLookup(*this);
 563     else if (isClassLookup() && SemaRef.getLangOptions().AccessControl)
 564       SemaRef.CheckLookupAccess(*this);
 565   }
 566
 567   void setAmbiguous(AmbiguityKind AK) {
 568     ResultKind = Ambiguous;
 569     Ambiguity = AK;
 570   }
 571
 572   void addDeclsFromBasePaths(const CXXBasePaths &P);
 573   void configure();
 574
 575   // Sanity checks.
 576 #ifndef NDEBUG
 577   void sanity() const;
 578 #else
 579   void sanity() const {}
 580 #endif
 581
 582   bool sanityCheckUnresolved() const {
 583     for (iterator I = begin(), E = end(); I != E; ++I)
 584       if (isa<UnresolvedUsingValueDecl>(*I))
 585         return true;
 586     return false;
 587   }
 588
 589   static void deletePaths(CXXBasePaths *);
 590
 591   // Results.
 592   LookupResultKind ResultKind;
 593   AmbiguityKind Ambiguity; // ill-defined unless ambiguous
 594   UnresolvedSet<8> Decls;
 595   CXXBasePaths *Paths;
 596   CXXRecordDecl *NamingClass;
 597   QualType BaseObjectType;
 598
 599   // Parameters.
 600   Sema &SemaRef;
 601   DeclarationNameInfo NameInfo;
 602   SourceRange NameContextRange;
 603   Sema::LookupNameKind LookupKind;
 604   unsigned IDNS; // set by configure()
 605
 606   bool Redecl;
 607
 608   /// \brief True if tag declarations should be hidden if non-tags
 609   ///   are present
 610   bool HideTags;
 611
 612   bool Diagnose;
 613 };
 614
 615   /// \brief Consumes visible declarations found when searching for
 616   /// all visible names within a given scope or context.
 617   ///
 618   /// This abstract class is meant to be subclassed by clients of \c
 619   /// Sema::LookupVisibleDecls(), each of which should override the \c
 620   /// FoundDecl() function to process declarations as they are found.
 621   class VisibleDeclConsumer {
 622   public:
 623     /// \brief Destroys the visible declaration consumer.
 624     virtual ~VisibleDeclConsumer();
 625
 626     /// \brief Invoked each time \p Sema::LookupVisibleDecls() finds a
 627     /// declaration visible from the current scope or context.
 628     ///
 629     /// \param ND the declaration found.
 630     ///
 631     /// \param Hiding a declaration that hides the declaration \p ND,
 632     /// or NULL if no such declaration exists.
 633     ///
 634     /// \param InBaseClass whether this declaration was found in base
 635     /// class of the context we searched.
 636     virtual void FoundDecl(NamedDecl *ND, NamedDecl *Hiding,
 637                            bool InBaseClass) = 0;
 638   };
 639
 640 /// \brief A class for storing results from argument-dependent lookup.
 641 class ADLResult {
 642 private:
 643   /// A map from canonical decls to the 'most recent' decl.
 644   llvm::DenseMap<NamedDecl*, NamedDecl*> Decls;
 645
 646 public:
 647   /// Adds a new ADL candidate to this map.
 648   void insert(NamedDecl *D);
 649
 650   /// Removes any data associated with a given decl.
 651   void erase(NamedDecl *D) {
 652     Decls.erase(cast<NamedDecl>(D->getCanonicalDecl()));
 653   }
 654
 655   class iterator {
 656     typedef llvm::DenseMap<NamedDecl*,NamedDecl*>::iterator inner_iterator;
 657     inner_iterator iter;
 658
 659     friend class ADLResult;
 660     iterator(const inner_iterator &iter) : iter(iter) {}
 661   public:
 662     iterator() {}
 663
 664     iterator &operator++() { ++iter; return *this; }
 665     iterator operator++(int) { return iterator(iter++); }
 666
 667     NamedDecl *operator*() const { return iter->second; }
 668
 669     bool operator==(const iterator &other) const { return iter == other.iter; }
 670     bool operator!=(const iterator &other) const { return iter != other.iter; }
 671   };
 672
 673   iterator begin() { return iterator(Decls.begin()); }
 674   iterator end() { return iterator(Decls.end()); }
 675 };
 676
 677 }
 678
 679 #endif