contrib/llvm-project/clang/include/clang/Sema/Lookup.h

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