Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- Lookup.h - Classes for name lookup -----------------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file defines the LookupResult class, which is integral to

// Sema's name-lookup subsystem.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_SEMA_LOOKUP_H

#define LLVM_CLANG_SEMA_LOOKUP_H

#include "clang/AST/Decl.h"

#include "clang/AST/DeclBase.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/DeclarationName.h"

#include "clang/AST/Type.h"

#include "clang/AST/UnresolvedSet.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/Specifiers.h"

#include "clang/Sema/Sema.h"

#include "llvm/ADT/MapVector.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/Support/Casting.h"

#include <cassert>

#include <optional>

#include <utility>

namespace clang {

class CXXBasePaths;

/// Represents the results of name lookup.

///

/// An instance of the LookupResult class captures the results of a

/// single name lookup, which can return no result (nothing found),

/// a single declaration, a set of overloaded functions, or an

/// ambiguity. Use the getKind() method to determine which of these

/// results occurred for a given lookup.

class LookupResult {

public:

  enum LookupResultKind {

    /// No entity found met the criteria.

    NotFound = 0,

    /// No entity found met the criteria within the current

    /// instantiation,, but there were dependent base classes of the

    /// current instantiation that could not be searched.

    NotFoundInCurrentInstantiation,

    /// Name lookup found a single declaration that met the

    /// criteria.  getFoundDecl() will return this declaration.

    Found,

    /// Name lookup found a set of overloaded functions that

    /// met the criteria.

    FoundOverloaded,

    /// Name lookup found an unresolvable value declaration

    /// and cannot yet complete.  This only happens in C++ dependent

    /// contexts with dependent using declarations.

    FoundUnresolvedValue,

    /// Name lookup results in an ambiguity; use

    /// getAmbiguityKind to figure out what kind of ambiguity

    /// we have.

    Ambiguous

  };

  enum AmbiguityKind {

    /// Name lookup results in an ambiguity because multiple

    /// entities that meet the lookup criteria were found in

    /// subobjects of different types. For example:

    /// @code

    /// struct A { void f(int); }

    /// struct B { void f(double); }

    /// struct C : A, B { };

    /// void test(C c) {

    ///   c.f(0); // error: A::f and B::f come from subobjects of different

    ///           // types. overload resolution is not performed.

    /// }

    /// @endcode

    AmbiguousBaseSubobjectTypes,

    /// Name lookup results in an ambiguity because multiple

    /// nonstatic entities that meet the lookup criteria were found

    /// in different subobjects of the same type. For example:

    /// @code

    /// struct A { int x; };

    /// struct B : A { };

    /// struct C : A { };

    /// struct D : B, C { };

    /// int test(D d) {

    ///   return d.x; // error: 'x' is found in two A subobjects (of B and C)

    /// }

    /// @endcode

    AmbiguousBaseSubobjects,

    /// Name lookup results in an ambiguity because multiple definitions

    /// of entity that meet the lookup criteria were found in different

    /// declaration contexts.

    /// @code

    /// namespace A {

    ///   int i;

    ///   namespace B { int i; }

    ///   int test() {

    ///     using namespace B;

    ///     return i; // error 'i' is found in namespace A and A::B

    ///    }

    /// }

    /// @endcode

    AmbiguousReference,

    /// Name lookup results in an ambiguity because an entity with a

    /// tag name was hidden by an entity with an ordinary name from

    /// a different context.

    /// @code

    /// namespace A { struct Foo {}; }

    /// namespace B { void Foo(); }

    /// namespace C {

    ///   using namespace A;

    ///   using namespace B;

    /// }

    /// void test() {

    ///   C::Foo(); // error: tag 'A::Foo' is hidden by an object in a

    ///             // different namespace

    /// }

    /// @endcode

    AmbiguousTagHiding

  };

  /// A little identifier for flagging temporary lookup results.

  enum TemporaryToken {

    Temporary

  };

  using iterator = UnresolvedSetImpl::iterator;

  LookupResult(Sema &SemaRef, const DeclarationNameInfo &NameInfo,

               Sema::LookupNameKind LookupKind,

               Sema::RedeclarationKind Redecl = Sema::NotForRedeclaration)

      : SemaPtr(&SemaRef), NameInfo(NameInfo), LookupKind(LookupKind),

        Redecl(Redecl != Sema::NotForRedeclaration),

        ExternalRedecl(Redecl == Sema::ForExternalRedeclaration),

        Diagnose(Redecl == Sema::NotForRedeclaration) {

    configure();

  }

  // TODO: consider whether this constructor should be restricted to take

  // as input a const IdentifierInfo* (instead of Name),

  // forcing other cases towards the constructor taking a DNInfo.

  LookupResult(Sema &SemaRef, DeclarationName Name,

               SourceLocation NameLoc, Sema::LookupNameKind LookupKind,

               Sema::RedeclarationKind Redecl = Sema::NotForRedeclaration)

      : SemaPtr(&SemaRef), NameInfo(Name, NameLoc), LookupKind(LookupKind),

        Redecl(Redecl != Sema::NotForRedeclaration),

        ExternalRedecl(Redecl == Sema::ForExternalRedeclaration),

        Diagnose(Redecl == Sema::NotForRedeclaration) {

    configure();

  }

  /// Creates a temporary lookup result, initializing its core data

  /// using the information from another result.  Diagnostics are always

  /// disabled.

  LookupResult(TemporaryToken _, const LookupResult &Other)

      : SemaPtr(Other.SemaPtr), NameInfo(Other.NameInfo),

        LookupKind(Other.LookupKind), IDNS(Other.IDNS), Redecl(Other.Redecl),

        ExternalRedecl(Other.ExternalRedecl), HideTags(Other.HideTags),

        AllowHidden(Other.AllowHidden),

        TemplateNameLookup(Other.TemplateNameLookup) {}

  // FIXME: Remove these deleted methods once the default build includes

  // -Wdeprecated.

  LookupResult(const LookupResult &) = delete;

  LookupResult &operator=(const LookupResult &) = delete;

  LookupResult(LookupResult &&Other)

      : ResultKind(std::move(Other.ResultKind)),

        Ambiguity(std::move(Other.Ambiguity)), Decls(std::move(Other.Decls)),

        Paths(std::move(Other.Paths)),

        NamingClass(std::move(Other.NamingClass)),

        BaseObjectType(std::move(Other.BaseObjectType)),

        SemaPtr(std::move(Other.SemaPtr)), NameInfo(std::move(Other.NameInfo)),

        NameContextRange(std::move(Other.NameContextRange)),

        LookupKind(std::move(Other.LookupKind)), IDNS(std::move(Other.IDNS)),

        Redecl(std::move(Other.Redecl)),

        ExternalRedecl(std::move(Other.ExternalRedecl)),

        HideTags(std::move(Other.HideTags)),

        Diagnose(std::move(Other.Diagnose)),

        AllowHidden(std::move(Other.AllowHidden)),

        Shadowed(std::move(Other.Shadowed)),

        TemplateNameLookup(std::move(Other.TemplateNameLookup)) {

    Other.Paths = nullptr;

    Other.Diagnose = false;

  }

  LookupResult &operator=(LookupResult &&Other) {

    ResultKind = std::move(Other.ResultKind);

    Ambiguity = std::move(Other.Ambiguity);

    Decls = std::move(Other.Decls);

    Paths = std::move(Other.Paths);

    NamingClass = std::move(Other.NamingClass);

    BaseObjectType = std::move(Other.BaseObjectType);

    SemaPtr = std::move(Other.SemaPtr);

    NameInfo = std::move(Other.NameInfo);

    NameContextRange = std::move(Other.NameContextRange);

    LookupKind = std::move(Other.LookupKind);

    IDNS = std::move(Other.IDNS);

    Redecl = std::move(Other.Redecl);

    ExternalRedecl = std::move(Other.ExternalRedecl);

    HideTags = std::move(Other.HideTags);

    Diagnose = std::move(Other.Diagnose);

    AllowHidden = std::move(Other.AllowHidden);

    Shadowed = std::move(Other.Shadowed);

    TemplateNameLookup = std::move(Other.TemplateNameLookup);

    Other.Paths = nullptr;

    Other.Diagnose = false;

    return *this;

  }

  ~LookupResult() {

    if (Diagnose) diagnose();

    if (Paths) deletePaths(Paths);

  }

  /// Gets the name info to look up.

  const DeclarationNameInfo &getLookupNameInfo() const {

    return NameInfo;

  }

  /// Sets the name info to look up.

  void setLookupNameInfo(const DeclarationNameInfo &NameInfo) {

    this->NameInfo = NameInfo;

  }

  /// Gets the name to look up.

  DeclarationName getLookupName() const {

    return NameInfo.getName();

  }

  /// Sets the name to look up.

  void setLookupName(DeclarationName Name) {

    NameInfo.setName(Name);

  }

  /// Gets the kind of lookup to perform.

  Sema::LookupNameKind getLookupKind() const {

    return LookupKind;

  }

  /// True if this lookup is just looking for an existing declaration.

  bool isForRedeclaration() const {

    return Redecl;

  }

  /// True if this lookup is just looking for an existing declaration to link

  /// against a declaration with external linkage.

  bool isForExternalRedeclaration() const {

    return ExternalRedecl;

  }

  Sema::RedeclarationKind redeclarationKind() const {

    return ExternalRedecl ? Sema::ForExternalRedeclaration :

           Redecl ? Sema::ForVisibleRedeclaration : Sema::NotForRedeclaration;

  }

  /// Specify whether hidden declarations are visible, e.g.,

  /// for recovery reasons.

  void setAllowHidden(bool AH) {

    AllowHidden = AH;

  }

  /// Determine whether this lookup is permitted to see hidden

  /// declarations, such as those in modules that have not yet been imported.

  bool isHiddenDeclarationVisible(NamedDecl *ND) const {

    return AllowHidden ||

           (isForExternalRedeclaration() && ND->isExternallyDeclarable());

  }

  /// Sets whether tag declarations should be hidden by non-tag

  /// declarations during resolution.  The default is true.

  void setHideTags(bool Hide) {

    HideTags = Hide;

  }

  /// Sets whether this is a template-name lookup. For template-name lookups,

  /// injected-class-names are treated as naming a template rather than a

  /// template specialization.

  void setTemplateNameLookup(bool TemplateName) {

    TemplateNameLookup = TemplateName;

  }

  bool isTemplateNameLookup() const { return TemplateNameLookup; }

  bool isAmbiguous() const {

    return getResultKind() == Ambiguous;

  }

  /// Determines if this names a single result which is not an

  /// unresolved value using decl.  If so, it is safe to call

  /// getFoundDecl().

  bool isSingleResult() const {

    return getResultKind() == Found;

  }

  /// Determines if the results are overloaded.

  bool isOverloadedResult() const {

    return getResultKind() == FoundOverloaded;

  }

  bool isUnresolvableResult() const {

    return getResultKind() == FoundUnresolvedValue;

  }

  LookupResultKind getResultKind() const {

    assert(checkDebugAssumptions());

    return ResultKind;

  }

  AmbiguityKind getAmbiguityKind() const {

    assert(isAmbiguous());

    return Ambiguity;

  }

  const UnresolvedSetImpl &asUnresolvedSet() const {

    return Decls;

  }

  iterator begin() const { return iterator(Decls.begin()); }

  iterator end() const { return iterator(Decls.end()); }

  /// Return true if no decls were found

  bool empty() const { return Decls.empty(); }

  /// Return the base paths structure that's associated with

  /// these results, or null if none is.

  CXXBasePaths *getBasePaths() const {

    return Paths;

  }

  /// Determine whether the given declaration is visible to the

  /// program.

  static bool isVisible(Sema &SemaRef, NamedDecl *D);

  static bool isReachable(Sema &SemaRef, NamedDecl *D);

  static bool isAcceptable(Sema &SemaRef, NamedDecl *D,

                           Sema::AcceptableKind Kind) {

    return Kind == Sema::AcceptableKind::Visible ? isVisible(SemaRef, D)

                                                 : isReachable(SemaRef, D);

  }

  /// Determine whether this lookup is permitted to see the declaration.

  /// Note that a reachable but not visible declaration inhabiting a namespace

  /// is not allowed to be seen during name lookup.

  ///

  /// For example:

  /// ```

  /// // m.cppm

  /// export module m;

  /// struct reachable { int v; }

  /// export auto func() { return reachable{43}; }

  /// // Use.cpp

  /// import m;

  /// auto Use() {

  ///   // Not valid. We couldn't see reachable here.

  ///   // So isAvailableForLookup would return false when we look

  ///   up 'reachable' here.

  ///   // return reachable(43).v;

  ///   // Valid. The field name 'v' is allowed during name lookup.

  ///   // So isAvailableForLookup would return true when we look up 'v' here.

  ///   return func().v;

  /// }

  /// ```

  static bool isAvailableForLookup(Sema &SemaRef, NamedDecl *ND);

  /// Retrieve the accepted (re)declaration of the given declaration,

  /// if there is one.

  NamedDecl *getAcceptableDecl(NamedDecl *D) const {

    if (!D->isInIdentifierNamespace(IDNS))

      return nullptr;

    if (isAvailableForLookup(getSema(), D) || isHiddenDeclarationVisible(D))

      return D;

    return getAcceptableDeclSlow(D);

  }

private:

  static bool isAcceptableSlow(Sema &SemaRef, NamedDecl *D,

                               Sema::AcceptableKind Kind);

  static bool isReachableSlow(Sema &SemaRef, NamedDecl *D);

  NamedDecl *getAcceptableDeclSlow(NamedDecl *D) const;

public:

  /// Returns the identifier namespace mask for this lookup.

  unsigned getIdentifierNamespace() const {

    return IDNS;

  }

  /// Returns whether these results arose from performing a

  /// lookup into a class.

  bool isClassLookup() const {

    return NamingClass != nullptr;

  }

  /// Returns the 'naming class' for this lookup, i.e. the

  /// class which was looked into to find these results.

  ///

  /// C++0x [class.access.base]p5:

  ///   The access to a member is affected by the class in which the

  ///   member is named. This naming class is the class in which the

  ///   member name was looked up and found. [Note: this class can be

  ///   explicit, e.g., when a qualified-id is used, or implicit,

  ///   e.g., when a class member access operator (5.2.5) is used

  ///   (including cases where an implicit "this->" is added). If both

  ///   a class member access operator and a qualified-id are used to

  ///   name the member (as in p->T::m), the class naming the member

  ///   is the class named by the nested-name-specifier of the

  ///   qualified-id (that is, T). -- end note ]

  ///

  /// This is set by the lookup routines when they find results in a class.

  CXXRecordDecl *getNamingClass() const {

    return NamingClass;

  }

  /// Sets the 'naming class' for this lookup.

  void setNamingClass(CXXRecordDecl *Record) {

    NamingClass = Record;

  }

  /// Returns the base object type associated with this lookup;

  /// important for [class.protected].  Most lookups do not have an

  /// associated base object.

  QualType getBaseObjectType() const {

    return BaseObjectType;

  }

  /// Sets the base object type for this lookup.

  void setBaseObjectType(QualType T) {

    BaseObjectType = T;

  }

  /// Add a declaration to these results with its natural access.

  /// Does not test the acceptance criteria.

  void addDecl(NamedDecl *D) {

    addDecl(D, D->getAccess());

  }

  /// Add a declaration to these results with the given access.

  /// Does not test the acceptance criteria.

  void addDecl(NamedDecl *D, AccessSpecifier AS) {

    Decls.addDecl(D, AS);

    ResultKind = Found;

  }

  /// Add all the declarations from another set of lookup

  /// results.

  void addAllDecls(const LookupResult &Other) {

    Decls.append(Other.Decls.begin(), Other.Decls.end());

    ResultKind = Found;

  }

  /// Determine whether no result was found because we could not

  /// search into dependent base classes of the current instantiation.

  bool wasNotFoundInCurrentInstantiation() const {

    return ResultKind == NotFoundInCurrentInstantiation;

  }

  /// Note that while no result was found in the current instantiation,

  /// there were dependent base classes that could not be searched.

  void setNotFoundInCurrentInstantiation() {

    assert(ResultKind == NotFound && Decls.empty());

    ResultKind = NotFoundInCurrentInstantiation;

  }

  /// Determine whether the lookup result was shadowed by some other

  /// declaration that lookup ignored.

  bool isShadowed() const { return Shadowed; }

  /// Note that we found and ignored a declaration while performing

  /// lookup.

  void setShadowed() { Shadowed = true; }

  /// Resolves the result kind of the lookup, possibly hiding

  /// decls.

  ///

  /// This should be called in any environment where lookup might

  /// generate multiple lookup results.

  void resolveKind();

  /// Re-resolves the result kind of the lookup after a set of

  /// removals has been performed.

  void resolveKindAfterFilter() {

    if (Decls.empty()) {

      if (ResultKind != NotFoundInCurrentInstantiation)

        ResultKind = NotFound;

      if (Paths) {

        deletePaths(Paths);

        Paths = nullptr;

      }

    } else {

      std::optional<AmbiguityKind> SavedAK;

      bool WasAmbiguous = false;

      if (ResultKind == Ambiguous) {

        SavedAK = Ambiguity;

        WasAmbiguous = true;

      }

      ResultKind = Found;

      resolveKind();

      // If we didn't make the lookup unambiguous, restore the old

      // ambiguity kind.

      if (ResultKind == Ambiguous) {

        (void)WasAmbiguous;

        assert(WasAmbiguous);

        Ambiguity = *SavedAK;

      } else if (Paths) {

        deletePaths(Paths);

        Paths = nullptr;

      }

    }

  }

  template <class DeclClass>

  DeclClass *getAsSingle() const {

    if (getResultKind() != Found) return nullptr;

    return dyn_cast<DeclClass>(getFoundDecl());

  }

  /// Fetch the unique decl found by this lookup.  Asserts

  /// that one was found.

  ///

  /// This is intended for users who have examined the result kind

  /// and are certain that there is only one result.

  NamedDecl *getFoundDecl() const {

    assert(getResultKind() == Found

           && "getFoundDecl called on non-unique result");

    return (*begin())->getUnderlyingDecl();

  }

  /// Fetches a representative decl.  Useful for lazy diagnostics.

  NamedDecl *getRepresentativeDecl() const {

    assert(!Decls.empty() && "cannot get representative of empty set");

    return *begin();

  }

  /// Asks if the result is a single tag decl.

  bool isSingleTagDecl() const {

    return getResultKind() == Found && isa<TagDecl>(getFoundDecl());

  }

  /// Make these results show that the name was found in

  /// base classes of different types.

  ///

  /// The given paths object is copied and invalidated.

  void setAmbiguousBaseSubobjectTypes(CXXBasePaths &P);

  /// Make these results show that the name was found in

  /// distinct base classes of the same type.

  ///

  /// The given paths object is copied and invalidated.

  void setAmbiguousBaseSubobjects(CXXBasePaths &P);

  /// Make these results show that the name was found in

  /// different contexts and a tag decl was hidden by an ordinary

  /// decl in a different context.

  void setAmbiguousQualifiedTagHiding() {

    setAmbiguous(AmbiguousTagHiding);

  }

  /// Clears out any current state.

  LLVM_ATTRIBUTE_REINITIALIZES void clear() {

    ResultKind = NotFound;

    Decls.clear();

    if (Paths) deletePaths(Paths);

    Paths = nullptr;

    NamingClass = nullptr;

    Shadowed = false;

  }

  /// Clears out any current state and re-initializes for a

  /// different kind of lookup.

  void clear(Sema::LookupNameKind Kind) {

    clear();

    LookupKind = Kind;

    configure();

  }

  /// Change this lookup's redeclaration kind.

  void setRedeclarationKind(Sema::RedeclarationKind RK) {

    Redecl = (RK != Sema::NotForRedeclaration);

    ExternalRedecl = (RK == Sema::ForExternalRedeclaration);

    configure();

  }

  void dump();

  void print(raw_ostream &);

  /// Suppress the diagnostics that would normally fire because of this

  /// lookup.  This happens during (e.g.) redeclaration lookups.

  void suppressDiagnostics() {

    Diagnose = false;

  }

  /// Determines whether this lookup is suppressing diagnostics.

  bool isSuppressingDiagnostics() const {

    return !Diagnose;

  }

  /// Sets a 'context' source range.

  void setContextRange(SourceRange SR) {

    NameContextRange = SR;

  }

  /// Gets the source range of the context of this name; for C++

  /// qualified lookups, this is the source range of the scope

  /// specifier.

  SourceRange getContextRange() const {

    return NameContextRange;

  }

  /// Gets the location of the identifier.  This isn't always defined:

  /// sometimes we're doing lookups on synthesized names.

  SourceLocation getNameLoc() const {

    return NameInfo.getLoc();

  }

  /// Get the Sema object that this lookup result is searching

  /// with.

  Sema &getSema() const { return *SemaPtr; }

  /// A class for iterating through a result set and possibly

  /// filtering out results.  The results returned are possibly

  /// sugared.

  class Filter {

    friend class LookupResult;

    LookupResult &Results;

    LookupResult::iterator I;

    bool Changed = false;

    bool CalledDone = false;

    Filter(LookupResult &Results) : Results(Results), I(Results.begin()) {}

  public:

    Filter(Filter &&F)

        : Results(F.Results), I(F.I), Changed(F.Changed),

          CalledDone(F.CalledDone) {

      F.CalledDone = true;

    }

    ~Filter() {

      assert(CalledDone &&

             "LookupResult::Filter destroyed without done() call");

    }

    bool hasNext() const {

      return I != Results.end();

    }

    NamedDecl *next() {

      assert(I != Results.end() && "next() called on empty filter");

      return *I++;

    }

    /// Restart the iteration.

    void restart() {

      I = Results.begin();

    }

    /// Erase the last element returned from this iterator.

    void erase() {

      Results.Decls.erase(--I);

      Changed = true;

    }

    /// Replaces the current entry with the given one, preserving the

    /// access bits.

    void replace(NamedDecl *D) {

      Results.Decls.replace(I-1, D);

      Changed = true;

    }

    /// Replaces the current entry with the given one.

    void replace(NamedDecl *D, AccessSpecifier AS) {

      Results.Decls.replace(I-1, D, AS);

      Changed = true;

    }

    void done() {

      assert(!CalledDone && "done() called twice");

      CalledDone = true;

      if (Changed)

        Results.resolveKindAfterFilter();

    }

  };

  /// Create a filter for this result set.

  Filter makeFilter() {

    return Filter(*this);

  }

  void setFindLocalExtern(bool FindLocalExtern) {

    if (FindLocalExtern)

      IDNS |= Decl::IDNS_LocalExtern;

    else

      IDNS &= ~Decl::IDNS_LocalExtern;

  }

private:

  void diagnose() {

    if (isAmbiguous())

      getSema().DiagnoseAmbiguousLookup(*this);

    else if (isClassLookup() && getSema().getLangOpts().AccessControl)

      getSema().CheckLookupAccess(*this);

  }

  void setAmbiguous(AmbiguityKind AK) {

    ResultKind = Ambiguous;

    Ambiguity = AK;

  }

  void addDeclsFromBasePaths(const CXXBasePaths &P);

  void configure();

  bool checkDebugAssumptions() const;

  bool checkUnresolved() const {

    for (iterator I = begin(), E = end(); I != E; ++I)

      if (isa<UnresolvedUsingValueDecl>((*I)->getUnderlyingDecl()))

        return true;

    return false;

  }

  static void deletePaths(CXXBasePaths *);

  // Results.

  LookupResultKind ResultKind = NotFound;

  // ill-defined unless ambiguous. Still need to be initialized it will be

  // copied/moved.

  AmbiguityKind Ambiguity = {};

  UnresolvedSet<8> Decls;

  CXXBasePaths *Paths = nullptr;

  CXXRecordDecl *NamingClass = nullptr;

  QualType BaseObjectType;

  // Parameters.

  Sema *SemaPtr;

  DeclarationNameInfo NameInfo;

  SourceRange NameContextRange;

  Sema::LookupNameKind LookupKind;

  unsigned IDNS = 0; // set by configure()

  bool Redecl;

  bool ExternalRedecl;

  /// True if tag declarations should be hidden if non-tags

  ///   are present

  bool HideTags = true;

  bool Diagnose = false;

  /// True if we should allow hidden declarations to be 'visible'.

  bool AllowHidden = false;

  /// True if the found declarations were shadowed by some other

  /// declaration that we skipped. This only happens when \c LookupKind

  /// is \c LookupRedeclarationWithLinkage.

  bool Shadowed = false;

  /// True if we're looking up a template-name.

  bool TemplateNameLookup = false;

};

/// Consumes visible declarations found when searching for

/// all visible names within a given scope or context.

///

/// This abstract class is meant to be subclassed by clients of \c

/// Sema::LookupVisibleDecls(), each of which should override the \c

/// FoundDecl() function to process declarations as they are found.

class VisibleDeclConsumer {

public:

  /// Destroys the visible declaration consumer.

  virtual ~VisibleDeclConsumer();

  /// Determine whether hidden declarations (from unimported

  /// modules) should be given to this consumer. By default, they

  /// are not included.

  virtual bool includeHiddenDecls() const;

  /// Invoked each time \p Sema::LookupVisibleDecls() finds a

  /// declaration visible from the current scope or context.

  ///

  /// \param ND the declaration found.

  ///

  /// \param Hiding a declaration that hides the declaration \p ND,

  /// or NULL if no such declaration exists.

  ///

  /// \param Ctx the original context from which the lookup started.

  ///

  /// \param InBaseClass whether this declaration was found in base

  /// class of the context we searched.

  virtual void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,

                         bool InBaseClass) = 0;

  /// Callback to inform the client that Sema entered into a new context

  /// to find a visible declaration.

  //

  /// \param Ctx the context which Sema entered.

  virtual void EnteredContext(DeclContext *Ctx) {}

};

/// A class for storing results from argument-dependent lookup.

class ADLResult {

private:

  /// A map from canonical decls to the 'most recent' decl.

  llvm::MapVector<NamedDecl*, NamedDecl*> Decls;

  struct select_second {

    NamedDecl *operator()(std::pair<NamedDecl*, NamedDecl*> P) const {

      return P.second;

    }

  };

public:

  /// Adds a new ADL candidate to this map.

  void insert(NamedDecl *D);

  /// Removes any data associated with a given decl.

  void erase(NamedDecl *D) {

    Decls.erase(cast<NamedDecl>(D->getCanonicalDecl()));