| //===--------------------- SemaLookup.cpp - Name Lookup ------------------===// |
| // |
| // 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 implements name lookup for C, C++, Objective-C, and |
| // Objective-C++. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "clang/AST/ASTContext.h" |
| #include "clang/AST/CXXInheritance.h" |
| #include "clang/AST/Decl.h" |
| #include "clang/AST/DeclCXX.h" |
| #include "clang/AST/DeclLookups.h" |
| #include "clang/AST/DeclObjC.h" |
| #include "clang/AST/DeclTemplate.h" |
| #include "clang/AST/Expr.h" |
| #include "clang/AST/ExprCXX.h" |
| #include "clang/Basic/Builtins.h" |
| #include "clang/Basic/FileManager.h" |
| #include "clang/Basic/LangOptions.h" |
| #include "clang/Lex/HeaderSearch.h" |
| #include "clang/Lex/ModuleLoader.h" |
| #include "clang/Lex/Preprocessor.h" |
| #include "clang/Sema/DeclSpec.h" |
| #include "clang/Sema/Lookup.h" |
| #include "clang/Sema/Overload.h" |
| #include "clang/Sema/Scope.h" |
| #include "clang/Sema/ScopeInfo.h" |
| #include "clang/Sema/Sema.h" |
| #include "clang/Sema/SemaInternal.h" |
| #include "clang/Sema/TemplateDeduction.h" |
| #include "clang/Sema/TypoCorrection.h" |
| #include "llvm/ADT/STLExtras.h" |
| #include "llvm/ADT/SmallPtrSet.h" |
| #include "llvm/ADT/TinyPtrVector.h" |
| #include "llvm/ADT/edit_distance.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include <algorithm> |
| #include <iterator> |
| #include <list> |
| #include <set> |
| #include <utility> |
| #include <vector> |
| |
| #include "OpenCLBuiltins.inc" |
| |
| using namespace clang; |
| using namespace sema; |
| |
| namespace { |
| class UnqualUsingEntry { |
| const DeclContext *Nominated; |
| const DeclContext *CommonAncestor; |
| |
| public: |
| UnqualUsingEntry(const DeclContext *Nominated, |
| const DeclContext *CommonAncestor) |
| : Nominated(Nominated), CommonAncestor(CommonAncestor) { |
| } |
| |
| const DeclContext *getCommonAncestor() const { |
| return CommonAncestor; |
| } |
| |
| const DeclContext *getNominatedNamespace() const { |
| return Nominated; |
| } |
| |
| // Sort by the pointer value of the common ancestor. |
| struct Comparator { |
| bool operator()(const UnqualUsingEntry &L, const UnqualUsingEntry &R) { |
| return L.getCommonAncestor() < R.getCommonAncestor(); |
| } |
| |
| bool operator()(const UnqualUsingEntry &E, const DeclContext *DC) { |
| return E.getCommonAncestor() < DC; |
| } |
| |
| bool operator()(const DeclContext *DC, const UnqualUsingEntry &E) { |
| return DC < E.getCommonAncestor(); |
| } |
| }; |
| }; |
| |
| /// A collection of using directives, as used by C++ unqualified |
| /// lookup. |
| class UnqualUsingDirectiveSet { |
| Sema &SemaRef; |
| |
| typedef SmallVector<UnqualUsingEntry, 8> ListTy; |
| |
| ListTy list; |
| llvm::SmallPtrSet<DeclContext*, 8> visited; |
| |
| public: |
| UnqualUsingDirectiveSet(Sema &SemaRef) : SemaRef(SemaRef) {} |
| |
| void visitScopeChain(Scope *S, Scope *InnermostFileScope) { |
| // C++ [namespace.udir]p1: |
| // During unqualified name lookup, the names appear as if they |
| // were declared in the nearest enclosing namespace which contains |
| // both the using-directive and the nominated namespace. |
| DeclContext *InnermostFileDC = InnermostFileScope->getEntity(); |
| assert(InnermostFileDC && InnermostFileDC->isFileContext()); |
| |
| for (; S; S = S->getParent()) { |
| // C++ [namespace.udir]p1: |
| // A using-directive shall not appear in class scope, but may |
| // appear in namespace scope or in block scope. |
| DeclContext *Ctx = S->getEntity(); |
| if (Ctx && Ctx->isFileContext()) { |
| visit(Ctx, Ctx); |
| } else if (!Ctx || Ctx->isFunctionOrMethod()) { |
| for (auto *I : S->using_directives()) |
| if (SemaRef.isVisible(I)) |
| visit(I, InnermostFileDC); |
| } |
| } |
| } |
| |
| // Visits a context and collect all of its using directives |
| // recursively. Treats all using directives as if they were |
| // declared in the context. |
| // |
| // A given context is only every visited once, so it is important |
| // that contexts be visited from the inside out in order to get |
| // the effective DCs right. |
| void visit(DeclContext *DC, DeclContext *EffectiveDC) { |
| if (!visited.insert(DC).second) |
| return; |
| |
| addUsingDirectives(DC, EffectiveDC); |
| } |
| |
| // Visits a using directive and collects all of its using |
| // directives recursively. Treats all using directives as if they |
| // were declared in the effective DC. |
| void visit(UsingDirectiveDecl *UD, DeclContext *EffectiveDC) { |
| DeclContext *NS = UD->getNominatedNamespace(); |
| if (!visited.insert(NS).second) |
| return; |
| |
| addUsingDirective(UD, EffectiveDC); |
| addUsingDirectives(NS, EffectiveDC); |
| } |
| |
| // Adds all the using directives in a context (and those nominated |
| // by its using directives, transitively) as if they appeared in |
| // the given effective context. |
| void addUsingDirectives(DeclContext *DC, DeclContext *EffectiveDC) { |
| SmallVector<DeclContext*, 4> queue; |
| while (true) { |
| for (auto UD : DC->using_directives()) { |
| DeclContext *NS = UD->getNominatedNamespace(); |
| if (SemaRef.isVisible(UD) && visited.insert(NS).second) { |
| addUsingDirective(UD, EffectiveDC); |
| queue.push_back(NS); |
| } |
| } |
| |
| if (queue.empty()) |
| return; |
| |
| DC = queue.pop_back_val(); |
| } |
| } |
| |
| // Add a using directive as if it had been declared in the given |
| // context. This helps implement C++ [namespace.udir]p3: |
| // The using-directive is transitive: if a scope contains a |
| // using-directive that nominates a second namespace that itself |
| // contains using-directives, the effect is as if the |
| // using-directives from the second namespace also appeared in |
| // the first. |
| void addUsingDirective(UsingDirectiveDecl *UD, DeclContext *EffectiveDC) { |
| // Find the common ancestor between the effective context and |
| // the nominated namespace. |
| DeclContext *Common = UD->getNominatedNamespace(); |
| while (!Common->Encloses(EffectiveDC)) |
| Common = Common->getParent(); |
| Common = Common->getPrimaryContext(); |
| |
| list.push_back(UnqualUsingEntry(UD->getNominatedNamespace(), Common)); |
| } |
| |
| void done() { llvm::sort(list, UnqualUsingEntry::Comparator()); } |
| |
| typedef ListTy::const_iterator const_iterator; |
| |
| const_iterator begin() const { return list.begin(); } |
| const_iterator end() const { return list.end(); } |
| |
| llvm::iterator_range<const_iterator> |
| getNamespacesFor(DeclContext *DC) const { |
| return llvm::make_range(std::equal_range(begin(), end(), |
| DC->getPrimaryContext(), |
| UnqualUsingEntry::Comparator())); |
| } |
| }; |
| } // end anonymous namespace |
| |
| // Retrieve the set of identifier namespaces that correspond to a |
| // specific kind of name lookup. |
| static inline unsigned getIDNS(Sema::LookupNameKind NameKind, |
| bool CPlusPlus, |
| bool Redeclaration) { |
| unsigned IDNS = 0; |
| switch (NameKind) { |
| case Sema::LookupObjCImplicitSelfParam: |
| case Sema::LookupOrdinaryName: |
| case Sema::LookupRedeclarationWithLinkage: |
| case Sema::LookupLocalFriendName: |
| IDNS = Decl::IDNS_Ordinary; |
| if (CPlusPlus) { |
| IDNS |= Decl::IDNS_Tag | Decl::IDNS_Member | Decl::IDNS_Namespace; |
| if (Redeclaration) |
| IDNS |= Decl::IDNS_TagFriend | Decl::IDNS_OrdinaryFriend; |
| } |
| if (Redeclaration) |
| IDNS |= Decl::IDNS_LocalExtern; |
| break; |
| |
| case Sema::LookupOperatorName: |
| // Operator lookup is its own crazy thing; it is not the same |
| // as (e.g.) looking up an operator name for redeclaration. |
| assert(!Redeclaration && "cannot do redeclaration operator lookup"); |
| IDNS = Decl::IDNS_NonMemberOperator; |
| break; |
| |
| case Sema::LookupTagName: |
| if (CPlusPlus) { |
| IDNS = Decl::IDNS_Type; |
| |
| // When looking for a redeclaration of a tag name, we add: |
| // 1) TagFriend to find undeclared friend decls |
| // 2) Namespace because they can't "overload" with tag decls. |
| // 3) Tag because it includes class templates, which can't |
| // "overload" with tag decls. |
| if (Redeclaration) |
| IDNS |= Decl::IDNS_Tag | Decl::IDNS_TagFriend | Decl::IDNS_Namespace; |
| } else { |
| IDNS = Decl::IDNS_Tag; |
| } |
| break; |
| |
| case Sema::LookupLabel: |
| IDNS = Decl::IDNS_Label; |
| break; |
| |
| case Sema::LookupMemberName: |
| IDNS = Decl::IDNS_Member; |
| if (CPlusPlus) |
| IDNS |= Decl::IDNS_Tag | Decl::IDNS_Ordinary; |
| break; |
| |
| case Sema::LookupNestedNameSpecifierName: |
| IDNS = Decl::IDNS_Type | Decl::IDNS_Namespace; |
| break; |
| |
| case Sema::LookupNamespaceName: |
| IDNS = Decl::IDNS_Namespace; |
| break; |
| |
| case Sema::LookupUsingDeclName: |
| assert(Redeclaration && "should only be used for redecl lookup"); |
| IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Member | |
| Decl::IDNS_Using | Decl::IDNS_TagFriend | Decl::IDNS_OrdinaryFriend | |
| Decl::IDNS_LocalExtern; |
| break; |
| |
| case Sema::LookupObjCProtocolName: |
| IDNS = Decl::IDNS_ObjCProtocol; |
| break; |
| |
| case Sema::LookupOMPReductionName: |
| IDNS = Decl::IDNS_OMPReduction; |
| break; |
| |
| case Sema::LookupOMPMapperName: |
| IDNS = Decl::IDNS_OMPMapper; |
| break; |
| |
| case Sema::LookupAnyName: |
| IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Member |
| | Decl::IDNS_Using | Decl::IDNS_Namespace | Decl::IDNS_ObjCProtocol |
| | Decl::IDNS_Type; |
| break; |
| } |
| return IDNS; |
| } |
| |
| void LookupResult::configure() { |
| IDNS = getIDNS(LookupKind, getSema().getLangOpts().CPlusPlus, |
| isForRedeclaration()); |
| |
| // If we're looking for one of the allocation or deallocation |
| // operators, make sure that the implicitly-declared new and delete |
| // operators can be found. |
| switch (NameInfo.getName().getCXXOverloadedOperator()) { |
| case OO_New: |
| case OO_Delete: |
| case OO_Array_New: |
| case OO_Array_Delete: |
| getSema().DeclareGlobalNewDelete(); |
| break; |
| |
| default: |
| break; |
| } |
| |
| // Compiler builtins are always visible, regardless of where they end |
| // up being declared. |
| if (IdentifierInfo *Id = NameInfo.getName().getAsIdentifierInfo()) { |
| if (unsigned BuiltinID = Id->getBuiltinID()) { |
| if (!getSema().Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) |
| AllowHidden = true; |
| } |
| } |
| } |
| |
| bool LookupResult::sanity() const { |
| // This function is never called by NDEBUG builds. |
| assert(ResultKind != NotFound || Decls.size() == 0); |
| assert(ResultKind != Found || Decls.size() == 1); |
| assert(ResultKind != FoundOverloaded || Decls.size() > 1 || |
| (Decls.size() == 1 && |
| isa<FunctionTemplateDecl>((*begin())->getUnderlyingDecl()))); |
| assert(ResultKind != FoundUnresolvedValue || sanityCheckUnresolved()); |
| assert(ResultKind != Ambiguous || Decls.size() > 1 || |
| (Decls.size() == 1 && (Ambiguity == AmbiguousBaseSubobjects || |
| Ambiguity == AmbiguousBaseSubobjectTypes))); |
| assert((Paths != nullptr) == (ResultKind == Ambiguous && |
| (Ambiguity == AmbiguousBaseSubobjectTypes || |
| Ambiguity == AmbiguousBaseSubobjects))); |
| return true; |
| } |
| |
| // Necessary because CXXBasePaths is not complete in Sema.h |
| void LookupResult::deletePaths(CXXBasePaths *Paths) { |
| delete Paths; |
| } |
| |
| /// Get a representative context for a declaration such that two declarations |
| /// will have the same context if they were found within the same scope. |
| static DeclContext *getContextForScopeMatching(Decl *D) { |
| // For function-local declarations, use that function as the context. This |
| // doesn't account for scopes within the function; the caller must deal with |
| // those. |
| DeclContext *DC = D->getLexicalDeclContext(); |
| if (DC->isFunctionOrMethod()) |
| return DC; |
| |
| // Otherwise, look at the semantic context of the declaration. The |
| // declaration must have been found there. |
| return D->getDeclContext()->getRedeclContext(); |
| } |
| |
| /// Determine whether \p D is a better lookup result than \p Existing, |
| /// given that they declare the same entity. |
| static bool isPreferredLookupResult(Sema &S, Sema::LookupNameKind Kind, |
| NamedDecl *D, NamedDecl *Existing) { |
| // When looking up redeclarations of a using declaration, prefer a using |
| // shadow declaration over any other declaration of the same entity. |
| if (Kind == Sema::LookupUsingDeclName && isa<UsingShadowDecl>(D) && |
| !isa<UsingShadowDecl>(Existing)) |
| return true; |
| |
| auto *DUnderlying = D->getUnderlyingDecl(); |
| auto *EUnderlying = Existing->getUnderlyingDecl(); |
| |
| // If they have different underlying declarations, prefer a typedef over the |
| // original type (this happens when two type declarations denote the same |
| // type), per a generous reading of C++ [dcl.typedef]p3 and p4. The typedef |
| // might carry additional semantic information, such as an alignment override. |
| // However, per C++ [dcl.typedef]p5, when looking up a tag name, prefer a tag |
| // declaration over a typedef. |
| if (DUnderlying->getCanonicalDecl() != EUnderlying->getCanonicalDecl()) { |
| assert(isa<TypeDecl>(DUnderlying) && isa<TypeDecl>(EUnderlying)); |
| bool HaveTag = isa<TagDecl>(EUnderlying); |
| bool WantTag = Kind == Sema::LookupTagName; |
| return HaveTag != WantTag; |
| } |
| |
| // Pick the function with more default arguments. |
| // FIXME: In the presence of ambiguous default arguments, we should keep both, |
| // so we can diagnose the ambiguity if the default argument is needed. |
| // See C++ [over.match.best]p3. |
| if (auto *DFD = dyn_cast<FunctionDecl>(DUnderlying)) { |
| auto *EFD = cast<FunctionDecl>(EUnderlying); |
| unsigned DMin = DFD->getMinRequiredArguments(); |
| unsigned EMin = EFD->getMinRequiredArguments(); |
| // If D has more default arguments, it is preferred. |
| if (DMin != EMin) |
| return DMin < EMin; |
| // FIXME: When we track visibility for default function arguments, check |
| // that we pick the declaration with more visible default arguments. |
| } |
| |
| // Pick the template with more default template arguments. |
| if (auto *DTD = dyn_cast<TemplateDecl>(DUnderlying)) { |
| auto *ETD = cast<TemplateDecl>(EUnderlying); |
| unsigned DMin = DTD->getTemplateParameters()->getMinRequiredArguments(); |
| unsigned EMin = ETD->getTemplateParameters()->getMinRequiredArguments(); |
| // If D has more default arguments, it is preferred. Note that default |
| // arguments (and their visibility) is monotonically increasing across the |
| // redeclaration chain, so this is a quick proxy for "is more recent". |
| if (DMin != EMin) |
| return DMin < EMin; |
| // If D has more *visible* default arguments, it is preferred. Note, an |
| // earlier default argument being visible does not imply that a later |
| // default argument is visible, so we can't just check the first one. |
| for (unsigned I = DMin, N = DTD->getTemplateParameters()->size(); |
| I != N; ++I) { |
| if (!S.hasVisibleDefaultArgument( |
| ETD->getTemplateParameters()->getParam(I)) && |
| S.hasVisibleDefaultArgument( |
| DTD->getTemplateParameters()->getParam(I))) |
| return true; |
| } |
| } |
| |
| // VarDecl can have incomplete array types, prefer the one with more complete |
| // array type. |
| if (VarDecl *DVD = dyn_cast<VarDecl>(DUnderlying)) { |
| VarDecl *EVD = cast<VarDecl>(EUnderlying); |
| if (EVD->getType()->isIncompleteType() && |
| !DVD->getType()->isIncompleteType()) { |
| // Prefer the decl with a more complete type if visible. |
| return S.isVisible(DVD); |
| } |
| return false; // Avoid picking up a newer decl, just because it was newer. |
| } |
| |
| // For most kinds of declaration, it doesn't really matter which one we pick. |
| if (!isa<FunctionDecl>(DUnderlying) && !isa<VarDecl>(DUnderlying)) { |
| // If the existing declaration is hidden, prefer the new one. Otherwise, |
| // keep what we've got. |
| return !S.isVisible(Existing); |
| } |
| |
| // Pick the newer declaration; it might have a more precise type. |
| for (Decl *Prev = DUnderlying->getPreviousDecl(); Prev; |
| Prev = Prev->getPreviousDecl()) |
| if (Prev == EUnderlying) |
| return true; |
| return false; |
| } |
| |
| /// Determine whether \p D can hide a tag declaration. |
| static bool canHideTag(NamedDecl *D) { |
| // C++ [basic.scope.declarative]p4: |
| // Given a set of declarations in a single declarative region [...] |
| // exactly one declaration shall declare a class name or enumeration name |
| // that is not a typedef name and the other declarations shall all refer to |
| // the same variable, non-static data member, or enumerator, or all refer |
| // to functions and function templates; in this case the class name or |
| // enumeration name is hidden. |
| // C++ [basic.scope.hiding]p2: |
| // A class name or enumeration name can be hidden by the name of a |
| // variable, data member, function, or enumerator declared in the same |
| // scope. |
| // An UnresolvedUsingValueDecl always instantiates to one of these. |
| D = D->getUnderlyingDecl(); |
| return isa<VarDecl>(D) || isa<EnumConstantDecl>(D) || isa<FunctionDecl>(D) || |
| isa<FunctionTemplateDecl>(D) || isa<FieldDecl>(D) || |
| isa<UnresolvedUsingValueDecl>(D); |
| } |
| |
| /// Resolves the result kind of this lookup. |
| void LookupResult::resolveKind() { |
| unsigned N = Decls.size(); |
| |
| // Fast case: no possible ambiguity. |
| if (N == 0) { |
| assert(ResultKind == NotFound || |
| ResultKind == NotFoundInCurrentInstantiation); |
| return; |
| } |
| |
| // If there's a single decl, we need to examine it to decide what |
| // kind of lookup this is. |
| if (N == 1) { |
| NamedDecl *D = (*Decls.begin())->getUnderlyingDecl(); |
| if (isa<FunctionTemplateDecl>(D)) |
| ResultKind = FoundOverloaded; |
| else if (isa<UnresolvedUsingValueDecl>(D)) |
| ResultKind = FoundUnresolvedValue; |
| return; |
| } |
| |
| // Don't do any extra resolution if we've already resolved as ambiguous. |
| if (ResultKind == Ambiguous) return; |
| |
| llvm::SmallDenseMap<NamedDecl*, unsigned, 16> Unique; |
| llvm::SmallDenseMap<QualType, unsigned, 16> UniqueTypes; |
| |
| bool Ambiguous = false; |
| bool HasTag = false, HasFunction = false; |
| bool HasFunctionTemplate = false, HasUnresolved = false; |
| NamedDecl *HasNonFunction = nullptr; |
| |
| llvm::SmallVector<NamedDecl*, 4> EquivalentNonFunctions; |
| |
| unsigned UniqueTagIndex = 0; |
| |
| unsigned I = 0; |
| while (I < N) { |
| NamedDecl *D = Decls[I]->getUnderlyingDecl(); |
| D = cast<NamedDecl>(D->getCanonicalDecl()); |
| |
| // Ignore an invalid declaration unless it's the only one left. |
| if (D->isInvalidDecl() && !(I == 0 && N == 1)) { |
| Decls[I] = Decls[--N]; |
| continue; |
| } |
| |
| llvm::Optional<unsigned> ExistingI; |
| |
| // Redeclarations of types via typedef can occur both within a scope |
| // and, through using declarations and directives, across scopes. There is |
| // no ambiguity if they all refer to the same type, so unique based on the |
| // canonical type. |
| if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) { |
| QualType T = getSema().Context.getTypeDeclType(TD); |
| auto UniqueResult = UniqueTypes.insert( |
| std::make_pair(getSema().Context.getCanonicalType(T), I)); |
| if (!UniqueResult.second) { |
| // The type is not unique. |
| ExistingI = UniqueResult.first->second; |
| } |
| } |
| |
| // For non-type declarations, check for a prior lookup result naming this |
| // canonical declaration. |
| if (!ExistingI) { |
| auto UniqueResult = Unique.insert(std::make_pair(D, I)); |
| if (!UniqueResult.second) { |
| // We've seen this entity before. |
| ExistingI = UniqueResult.first->second; |
| } |
| } |
| |
| if (ExistingI) { |
| // This is not a unique lookup result. Pick one of the results and |
| // discard the other. |
| if (isPreferredLookupResult(getSema(), getLookupKind(), Decls[I], |
| Decls[*ExistingI])) |
| Decls[*ExistingI] = Decls[I]; |
| Decls[I] = Decls[--N]; |
| continue; |
| } |
| |
| // Otherwise, do some decl type analysis and then continue. |
| |
| if (isa<UnresolvedUsingValueDecl>(D)) { |
| HasUnresolved = true; |
| } else if (isa<TagDecl>(D)) { |
| if (HasTag) |
| Ambiguous = true; |
| UniqueTagIndex = I; |
| HasTag = true; |
| } else if (isa<FunctionTemplateDecl>(D)) { |
| HasFunction = true; |
| HasFunctionTemplate = true; |
| } else if (isa<FunctionDecl>(D)) { |
| HasFunction = true; |
| } else { |
| if (HasNonFunction) { |
| // If we're about to create an ambiguity between two declarations that |
| // are equivalent, but one is an internal linkage declaration from one |
| // module and the other is an internal linkage declaration from another |
| // module, just skip it. |
| if (getSema().isEquivalentInternalLinkageDeclaration(HasNonFunction, |
| D)) { |
| EquivalentNonFunctions.push_back(D); |
| Decls[I] = Decls[--N]; |
| continue; |
| } |
| |
| Ambiguous = true; |
| } |
| HasNonFunction = D; |
| } |
| I++; |
| } |
| |
| // C++ [basic.scope.hiding]p2: |
| // A class name or enumeration name can be hidden by the name of |
| // an object, function, or enumerator declared in the same |
| // scope. If a class or enumeration name and an object, function, |
| // or enumerator are declared in the same scope (in any order) |
| // with the same name, the class or enumeration name is hidden |
| // wherever the object, function, or enumerator name is visible. |
| // But it's still an error if there are distinct tag types found, |
| // even if they're not visible. (ref?) |
| if (N > 1 && HideTags && HasTag && !Ambiguous && |
| (HasFunction || HasNonFunction || HasUnresolved)) { |
| NamedDecl *OtherDecl = Decls[UniqueTagIndex ? 0 : N - 1]; |
| if (isa<TagDecl>(Decls[UniqueTagIndex]->getUnderlyingDecl()) && |
| getContextForScopeMatching(Decls[UniqueTagIndex])->Equals( |
| getContextForScopeMatching(OtherDecl)) && |
| canHideTag(OtherDecl)) |
| Decls[UniqueTagIndex] = Decls[--N]; |
| else |
| Ambiguous = true; |
| } |
| |
| // FIXME: This diagnostic should really be delayed until we're done with |
| // the lookup result, in case the ambiguity is resolved by the caller. |
| if (!EquivalentNonFunctions.empty() && !Ambiguous) |
| getSema().diagnoseEquivalentInternalLinkageDeclarations( |
| getNameLoc(), HasNonFunction, EquivalentNonFunctions); |
| |
| Decls.set_size(N); |
| |
| if (HasNonFunction && (HasFunction || HasUnresolved)) |
| Ambiguous = true; |
| |
| if (Ambiguous) |
| setAmbiguous(LookupResult::AmbiguousReference); |
| else if (HasUnresolved) |
| ResultKind = LookupResult::FoundUnresolvedValue; |
| else if (N > 1 || HasFunctionTemplate) |
| ResultKind = LookupResult::FoundOverloaded; |
| else |
| ResultKind = LookupResult::Found; |
| } |
| |
| void LookupResult::addDeclsFromBasePaths(const CXXBasePaths &P) { |
| CXXBasePaths::const_paths_iterator I, E; |
| for (I = P.begin(), E = P.end(); I != E; ++I) |
| for (DeclContext::lookup_iterator DI = I->Decls.begin(), |
| DE = I->Decls.end(); DI != DE; ++DI) |
| addDecl(*DI); |
| } |
| |
| void LookupResult::setAmbiguousBaseSubobjects(CXXBasePaths &P) { |
| Paths = new CXXBasePaths; |
| Paths->swap(P); |
| addDeclsFromBasePaths(*Paths); |
| resolveKind(); |
| setAmbiguous(AmbiguousBaseSubobjects); |
| } |
| |
| void LookupResult::setAmbiguousBaseSubobjectTypes(CXXBasePaths &P) { |
| Paths = new CXXBasePaths; |
| Paths->swap(P); |
| addDeclsFromBasePaths(*Paths); |
| resolveKind(); |
| setAmbiguous(AmbiguousBaseSubobjectTypes); |
| } |
| |
| void LookupResult::print(raw_ostream &Out) { |
| Out << Decls.size() << " result(s)"; |
| if (isAmbiguous()) Out << ", ambiguous"; |
| if (Paths) Out << ", base paths present"; |
| |
| for (iterator I = begin(), E = end(); I != E; ++I) { |
| Out << "\n"; |
| (*I)->print(Out, 2); |
| } |
| } |
| |
| LLVM_DUMP_METHOD void LookupResult::dump() { |
| llvm::errs() << "lookup results for " << getLookupName().getAsString() |
| << ":\n"; |
| for (NamedDecl *D : *this) |
| D->dump(); |
| } |
| |
| /// Get the QualType instances of the return type and arguments for an OpenCL |
| /// builtin function signature. |
| /// \param Context (in) The Context instance. |
| /// \param OpenCLBuiltin (in) The signature currently handled. |
| /// \param GenTypeMaxCnt (out) Maximum number of types contained in a generic |
| /// type used as return type or as argument. |
| /// Only meaningful for generic types, otherwise equals 1. |
| /// \param RetTypes (out) List of the possible return types. |
| /// \param ArgTypes (out) List of the possible argument types. For each |
| /// argument, ArgTypes contains QualTypes for the Cartesian product |
| /// of (vector sizes) x (types) . |
| static void GetQualTypesForOpenCLBuiltin( |
| ASTContext &Context, const OpenCLBuiltinStruct &OpenCLBuiltin, |
| unsigned &GenTypeMaxCnt, SmallVector<QualType, 1> &RetTypes, |
| SmallVector<SmallVector<QualType, 1>, 5> &ArgTypes) { |
| // Get the QualType instances of the return types. |
| unsigned Sig = SignatureTable[OpenCLBuiltin.SigTableIndex]; |
| OCL2Qual(Context, TypeTable[Sig], RetTypes); |
| GenTypeMaxCnt = RetTypes.size(); |
| |
| // Get the QualType instances of the arguments. |
| // First type is the return type, skip it. |
| for (unsigned Index = 1; Index < OpenCLBuiltin.NumTypes; Index++) { |
| SmallVector<QualType, 1> Ty; |
| OCL2Qual(Context, |
| TypeTable[SignatureTable[OpenCLBuiltin.SigTableIndex + Index]], Ty); |
| GenTypeMaxCnt = (Ty.size() > GenTypeMaxCnt) ? Ty.size() : GenTypeMaxCnt; |
| ArgTypes.push_back(std::move(Ty)); |
| } |
| } |
| |
| /// Create a list of the candidate function overloads for an OpenCL builtin |
| /// function. |
| /// \param Context (in) The ASTContext instance. |
| /// \param GenTypeMaxCnt (in) Maximum number of types contained in a generic |
| /// type used as return type or as argument. |
| /// Only meaningful for generic types, otherwise equals 1. |
| /// \param FunctionList (out) List of FunctionTypes. |
| /// \param RetTypes (in) List of the possible return types. |
| /// \param ArgTypes (in) List of the possible types for the arguments. |
| static void GetOpenCLBuiltinFctOverloads( |
| ASTContext &Context, unsigned GenTypeMaxCnt, |
| std::vector<QualType> &FunctionList, SmallVector<QualType, 1> &RetTypes, |
| SmallVector<SmallVector<QualType, 1>, 5> &ArgTypes) { |
| FunctionProtoType::ExtProtoInfo PI; |
| PI.Variadic = false; |
| |
| // Create FunctionTypes for each (gen)type. |
| for (unsigned IGenType = 0; IGenType < GenTypeMaxCnt; IGenType++) { |
| SmallVector<QualType, 5> ArgList; |
| |
| for (unsigned A = 0; A < ArgTypes.size(); A++) { |
| // Builtins such as "max" have an "sgentype" argument that represents |
| // the corresponding scalar type of a gentype. The number of gentypes |
| // must be a multiple of the number of sgentypes. |
| assert(GenTypeMaxCnt % ArgTypes[A].size() == 0 && |
| "argument type count not compatible with gentype type count"); |
| unsigned Idx = IGenType % ArgTypes[A].size(); |
| ArgList.push_back(ArgTypes[A][Idx]); |
| } |
| |
| FunctionList.push_back(Context.getFunctionType( |
| RetTypes[(RetTypes.size() != 1) ? IGenType : 0], ArgList, PI)); |
| } |
| } |
| |
| /// When trying to resolve a function name, if isOpenCLBuiltin() returns a |
| /// non-null <Index, Len> pair, then the name is referencing an OpenCL |
| /// builtin function. Add all candidate signatures to the LookUpResult. |
| /// |
| /// \param S (in) The Sema instance. |
| /// \param LR (inout) The LookupResult instance. |
| /// \param II (in) The identifier being resolved. |
| /// \param FctIndex (in) Starting index in the BuiltinTable. |
| /// \param Len (in) The signature list has Len elements. |
| static void InsertOCLBuiltinDeclarationsFromTable(Sema &S, LookupResult &LR, |
| IdentifierInfo *II, |
| const unsigned FctIndex, |
| const unsigned Len) { |
| // The builtin function declaration uses generic types (gentype). |
| bool HasGenType = false; |
| |
| // Maximum number of types contained in a generic type used as return type or |
| // as argument. Only meaningful for generic types, otherwise equals 1. |
| unsigned GenTypeMaxCnt; |
| |
| for (unsigned SignatureIndex = 0; SignatureIndex < Len; SignatureIndex++) { |
| const OpenCLBuiltinStruct &OpenCLBuiltin = |
| BuiltinTable[FctIndex + SignatureIndex]; |
| ASTContext &Context = S.Context; |
| |
| // Ignore this BIF if its version does not match the language options. |
| if (Context.getLangOpts().OpenCLVersion < OpenCLBuiltin.MinVersion) |
| continue; |
| if ((OpenCLBuiltin.MaxVersion != 0) && |
| (Context.getLangOpts().OpenCLVersion >= OpenCLBuiltin.MaxVersion)) |
| continue; |
| |
| SmallVector<QualType, 1> RetTypes; |
| SmallVector<SmallVector<QualType, 1>, 5> ArgTypes; |
| |
| // Obtain QualType lists for the function signature. |
| GetQualTypesForOpenCLBuiltin(Context, OpenCLBuiltin, GenTypeMaxCnt, |
| RetTypes, ArgTypes); |
| if (GenTypeMaxCnt > 1) { |
| HasGenType = true; |
| } |
| |
| // Create function overload for each type combination. |
| std::vector<QualType> FunctionList; |
| GetOpenCLBuiltinFctOverloads(Context, GenTypeMaxCnt, FunctionList, RetTypes, |
| ArgTypes); |
| |
| SourceLocation Loc = LR.getNameLoc(); |
| DeclContext *Parent = Context.getTranslationUnitDecl(); |
| FunctionDecl *NewOpenCLBuiltin; |
| |
| for (unsigned Index = 0; Index < GenTypeMaxCnt; Index++) { |
| NewOpenCLBuiltin = FunctionDecl::Create( |
| Context, Parent, Loc, Loc, II, FunctionList[Index], |
| /*TInfo=*/nullptr, SC_Extern, false, |
| FunctionList[Index]->isFunctionProtoType()); |
| NewOpenCLBuiltin->setImplicit(); |
| |
| // Create Decl objects for each parameter, adding them to the |
| // FunctionDecl. |
| if (const FunctionProtoType *FP = |
| dyn_cast<FunctionProtoType>(FunctionList[Index])) { |
| SmallVector<ParmVarDecl *, 16> ParmList; |
| for (unsigned IParm = 0, e = FP->getNumParams(); IParm != e; ++IParm) { |
| ParmVarDecl *Parm = ParmVarDecl::Create( |
| Context, NewOpenCLBuiltin, SourceLocation(), SourceLocation(), |
| nullptr, FP->getParamType(IParm), |
| /*TInfo=*/nullptr, SC_None, nullptr); |
| Parm->setScopeInfo(0, IParm); |
| ParmList.push_back(Parm); |
| } |
| NewOpenCLBuiltin->setParams(ParmList); |
| } |
| if (!S.getLangOpts().OpenCLCPlusPlus) { |
| NewOpenCLBuiltin->addAttr(OverloadableAttr::CreateImplicit(Context)); |
| } |
| LR.addDecl(NewOpenCLBuiltin); |
| } |
| } |
| |
| // If we added overloads, need to resolve the lookup result. |
| if (Len > 1 || HasGenType) |
| LR.resolveKind(); |
| } |
| |
| /// Lookup a builtin function, when name lookup would otherwise |
| /// fail. |
| bool Sema::LookupBuiltin(LookupResult &R) { |
| Sema::LookupNameKind NameKind = R.getLookupKind(); |
| |
| // If we didn't find a use of this identifier, and if the identifier |
| // corresponds to a compiler builtin, create the decl object for the builtin |
| // now, injecting it into translation unit scope, and return it. |
| if (NameKind == Sema::LookupOrdinaryName || |
| NameKind == Sema::LookupRedeclarationWithLinkage) { |
| IdentifierInfo *II = R.getLookupName().getAsIdentifierInfo(); |
| if (II) { |
| if (getLangOpts().CPlusPlus && NameKind == Sema::LookupOrdinaryName) { |
| if (II == getASTContext().getMakeIntegerSeqName()) { |
| R.addDecl(getASTContext().getMakeIntegerSeqDecl()); |
| return true; |
| } else if (II == getASTContext().getTypePackElementName()) { |
| R.addDecl(getASTContext().getTypePackElementDecl()); |
| return true; |
| } |
| } |
| |
| // Check if this is an OpenCL Builtin, and if so, insert its overloads. |
| if (getLangOpts().OpenCL && getLangOpts().DeclareOpenCLBuiltins) { |
| auto Index = isOpenCLBuiltin(II->getName()); |
| if (Index.first) { |
| InsertOCLBuiltinDeclarationsFromTable(*this, R, II, Index.first - 1, |
| Index.second); |
| return true; |
| } |
| } |
| |
| // If this is a builtin on this (or all) targets, create the decl. |
| if (unsigned BuiltinID = II->getBuiltinID()) { |
| // In C++ and OpenCL (spec v1.2 s6.9.f), we don't have any predefined |
| // library functions like 'malloc'. Instead, we'll just error. |
| if ((getLangOpts().CPlusPlus || getLangOpts().OpenCL) && |
| Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) |
| return false; |
| |
| if (NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, |
| BuiltinID, TUScope, |
| R.isForRedeclaration(), |
| R.getNameLoc())) { |
| R.addDecl(D); |
| return true; |
| } |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| /// Determine whether we can declare a special member function within |
| /// the class at this point. |
| static bool CanDeclareSpecialMemberFunction(const CXXRecordDecl *Class) { |
| // We need to have a definition for the class. |
| if (!Class->getDefinition() || Class->isDependentContext()) |
| return false; |
| |
| // We can't be in the middle of defining the class. |
| return !Class->isBeingDefined(); |
| } |
| |
| void Sema::ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class) { |
| if (!CanDeclareSpecialMemberFunction(Class)) |
| return; |
| |
| // If the default constructor has not yet been declared, do so now. |
| if (Class->needsImplicitDefaultConstructor()) |
| DeclareImplicitDefaultConstructor(Class); |
| |
| // If the copy constructor has not yet been declared, do so now. |
| if (Class->needsImplicitCopyConstructor()) |
| DeclareImplicitCopyConstructor(Class); |
| |
| // If the copy assignment operator has not yet been declared, do so now. |
| if (Class->needsImplicitCopyAssignment()) |
| DeclareImplicitCopyAssignment(Class); |
| |
| if (getLangOpts().CPlusPlus11) { |
| // If the move constructor has not yet been declared, do so now. |
| if (Class->needsImplicitMoveConstructor()) |
| DeclareImplicitMoveConstructor(Class); |
| |
| // If the move assignment operator has not yet been declared, do so now. |
| if (Class->needsImplicitMoveAssignment()) |
| DeclareImplicitMoveAssignment(Class); |
| } |
| |
| // If the destructor has not yet been declared, do so now. |
| if (Class->needsImplicitDestructor()) |
| DeclareImplicitDestructor(Class); |
| } |
| |
| /// Determine whether this is the name of an implicitly-declared |
| /// special member function. |
| static bool isImplicitlyDeclaredMemberFunctionName(DeclarationName Name) { |
| switch (Name.getNameKind()) { |
| case DeclarationName::CXXConstructorName: |
| case DeclarationName::CXXDestructorName: |
| return true; |
| |
| case DeclarationName::CXXOperatorName: |
| return Name.getCXXOverloadedOperator() == OO_Equal; |
| |
| default: |
| break; |
| } |
| |
| return false; |
| } |
| |
| /// If there are any implicit member functions with the given name |
| /// that need to be declared in the given declaration context, do so. |
| static void DeclareImplicitMemberFunctionsWithName(Sema &S, |
| DeclarationName Name, |
| SourceLocation Loc, |
| const DeclContext *DC) { |
| if (!DC) |
| return; |
| |
| switch (Name.getNameKind()) { |
| case DeclarationName::CXXConstructorName: |
| if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) |
| if (Record->getDefinition() && CanDeclareSpecialMemberFunction(Record)) { |
| CXXRecordDecl *Class = const_cast<CXXRecordDecl *>(Record); |
| if (Record->needsImplicitDefaultConstructor()) |
| S.DeclareImplicitDefaultConstructor(Class); |
| if (Record->needsImplicitCopyConstructor()) |
| S.DeclareImplicitCopyConstructor(Class); |
| if (S.getLangOpts().CPlusPlus11 && |
| Record->needsImplicitMoveConstructor()) |
| S.DeclareImplicitMoveConstructor(Class); |
| } |
| break; |
| |
| case DeclarationName::CXXDestructorName: |
| if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) |
| if (Record->getDefinition() && Record->needsImplicitDestructor() && |
| CanDeclareSpecialMemberFunction(Record)) |
| S.DeclareImplicitDestructor(const_cast<CXXRecordDecl *>(Record)); |
| break; |
| |
| case DeclarationName::CXXOperatorName: |
| if (Name.getCXXOverloadedOperator() != OO_Equal) |
| break; |
| |
| if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) { |
| if (Record->getDefinition() && CanDeclareSpecialMemberFunction(Record)) { |
| CXXRecordDecl *Class = const_cast<CXXRecordDecl *>(Record); |
| if (Record->needsImplicitCopyAssignment()) |
| S.DeclareImplicitCopyAssignment(Class); |
| if (S.getLangOpts().CPlusPlus11 && |
| Record->needsImplicitMoveAssignment()) |
| S.DeclareImplicitMoveAssignment(Class); |
| } |
| } |
| break; |
| |
| case DeclarationName::CXXDeductionGuideName: |
| S.DeclareImplicitDeductionGuides(Name.getCXXDeductionGuideTemplate(), Loc); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| // Adds all qualifying matches for a name within a decl context to the |
| // given lookup result. Returns true if any matches were found. |
| static bool LookupDirect(Sema &S, LookupResult &R, const DeclContext *DC) { |
| bool Found = false; |
| |
| // Lazily declare C++ special member functions. |
| if (S.getLangOpts().CPlusPlus) |
| DeclareImplicitMemberFunctionsWithName(S, R.getLookupName(), R.getNameLoc(), |
| DC); |
| |
| // Perform lookup into this declaration context. |
| DeclContext::lookup_result DR = DC->lookup(R.getLookupName()); |
| for (NamedDecl *D : DR) { |
| if ((D = R.getAcceptableDecl(D))) { |
| R.addDecl(D); |
| Found = true; |
| } |
| } |
| |
| if (!Found && DC->isTranslationUnit() && S.LookupBuiltin(R)) |
| return true; |
| |
| if (R.getLookupName().getNameKind() |
| != DeclarationName::CXXConversionFunctionName || |
| R.getLookupName().getCXXNameType()->isDependentType() || |
| !isa<CXXRecordDecl>(DC)) |
| return Found; |
| |
| // C++ [temp.mem]p6: |
| // A specialization of a conversion function template is not found by |
| // name lookup. Instead, any conversion function templates visible in the |
| // context of the use are considered. [...] |
| const CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); |
| if (!Record->isCompleteDefinition()) |
| return Found; |
| |
| // For conversion operators, 'operator auto' should only match |
| // 'operator auto'. Since 'auto' is not a type, it shouldn't be considered |
| // as a candidate for template substitution. |
| auto *ContainedDeducedType = |
| R.getLookupName().getCXXNameType()->getContainedDeducedType(); |
| if (R.getLookupName().getNameKind() == |
| DeclarationName::CXXConversionFunctionName && |
| ContainedDeducedType && ContainedDeducedType->isUndeducedType()) |
| return Found; |
| |
| for (CXXRecordDecl::conversion_iterator U = Record->conversion_begin(), |
| UEnd = Record->conversion_end(); U != UEnd; ++U) { |
| FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(*U); |
| if (!ConvTemplate) |
| continue; |
| |
| // When we're performing lookup for the purposes of redeclaration, just |
| // add the conversion function template. When we deduce template |
| // arguments for specializations, we'll end up unifying the return |
| // type of the new declaration with the type of the function template. |
| if (R.isForRedeclaration()) { |
| R.addDecl(ConvTemplate); |
| Found = true; |
| continue; |
| } |
| |
| // C++ [temp.mem]p6: |
| // [...] For each such operator, if argument deduction succeeds |
| // (14.9.2.3), the resulting specialization is used as if found by |
| // name lookup. |
| // |
| // When referencing a conversion function for any purpose other than |
| // a redeclaration (such that we'll be building an expression with the |
| // result), perform template argument deduction and place the |
| // specialization into the result set. We do this to avoid forcing all |
| // callers to perform special deduction for conversion functions. |
| TemplateDeductionInfo Info(R.getNameLoc()); |
| FunctionDecl *Specialization = nullptr; |
| |
| const FunctionProtoType *ConvProto |
| = ConvTemplate->getTemplatedDecl()->getType()->getAs<FunctionProtoType>(); |
| assert(ConvProto && "Nonsensical conversion function template type"); |
| |
| // Compute the type of the function that we would expect the conversion |
| // function to have, if it were to match the name given. |
| // FIXME: Calling convention! |
| FunctionProtoType::ExtProtoInfo EPI = ConvProto->getExtProtoInfo(); |
| EPI.ExtInfo = EPI.ExtInfo.withCallingConv(CC_C); |
| EPI.ExceptionSpec = EST_None; |
| QualType ExpectedType |
| = R.getSema().Context.getFunctionType(R.getLookupName().getCXXNameType(), |
| None, EPI); |
| |
| // Perform template argument deduction against the type that we would |
| // expect the function to have. |
| if (R.getSema().DeduceTemplateArguments(ConvTemplate, nullptr, ExpectedType, |
| Specialization, Info) |
| == Sema::TDK_Success) { |
| R.addDecl(Specialization); |
| Found = true; |
| } |
| } |
| |
| return Found; |
| } |
| |
| // Performs C++ unqualified lookup into the given file context. |
| static bool |
| CppNamespaceLookup(Sema &S, LookupResult &R, ASTContext &Context, |
| DeclContext *NS, UnqualUsingDirectiveSet &UDirs) { |
| |
| assert(NS && NS->isFileContext() && "CppNamespaceLookup() requires namespace!"); |
| |
| // Perform direct name lookup into the LookupCtx. |
| bool Found = LookupDirect(S, R, NS); |
| |
| // Perform direct name lookup into the namespaces nominated by the |
| // using directives whose common ancestor is this namespace. |
| for (const UnqualUsingEntry &UUE : UDirs.getNamespacesFor(NS)) |
| if (LookupDirect(S, R, UUE.getNominatedNamespace())) |
| Found = true; |
| |
| R.resolveKind(); |
| |
| return Found; |
| } |
| |
| static bool isNamespaceOrTranslationUnitScope(Scope *S) { |
| if (DeclContext *Ctx = S->getEntity()) |
| return Ctx->isFileContext(); |
| return false; |
| } |
| |
| // Find the next outer declaration context from this scope. This |
| // routine actually returns the semantic outer context, which may |
| // differ from the lexical context (encoded directly in the Scope |
| // stack) when we are parsing a member of a class template. In this |
| // case, the second element of the pair will be true, to indicate that |
| // name lookup should continue searching in this semantic context when |
| // it leaves the current template parameter scope. |
| static std::pair<DeclContext *, bool> findOuterContext(Scope *S) { |
| DeclContext *DC = S->getEntity(); |
| DeclContext *Lexical = nullptr; |
| for (Scope *OuterS = S->getParent(); OuterS; |
| OuterS = OuterS->getParent()) { |
| if (OuterS->getEntity()) { |
| Lexical = OuterS->getEntity(); |
| break; |
| } |
| } |
| |
| // C++ [temp.local]p8: |
| // In the definition of a member of a class template that appears |
| // outside of the namespace containing the class template |
| // definition, the name of a template-parameter hides the name of |
| // a member of this namespace. |
| // |
| // Example: |
| // |
| // namespace N { |
| // class C { }; |
| // |
| // template<class T> class B { |
| // void f(T); |
| // }; |
| // } |
| // |
| // template<class C> void N::B<C>::f(C) { |
| // C b; // C is the template parameter, not N::C |
| // } |
| // |
| // In this example, the lexical context we return is the |
| // TranslationUnit, while the semantic context is the namespace N. |
| if (!Lexical || !DC || !S->getParent() || |
| !S->getParent()->isTemplateParamScope()) |
| return std::make_pair(Lexical, false); |
| |
| // Find the outermost template parameter scope. |
| // For the example, this is the scope for the template parameters of |
| // template<class C>. |
| Scope *OutermostTemplateScope = S->getParent(); |
| while (OutermostTemplateScope->getParent() && |
| OutermostTemplateScope->getParent()->isTemplateParamScope()) |
| OutermostTemplateScope = OutermostTemplateScope->getParent(); |
| |
| // Find the namespace context in which the original scope occurs. In |
| // the example, this is namespace N. |
| DeclContext *Semantic = DC; |
| while (!Semantic->isFileContext()) |
| Semantic = Semantic->getParent(); |
| |
| // Find the declaration context just outside of the template |
| // parameter scope. This is the context in which the template is |
| // being lexically declaration (a namespace context). In the |
| // example, this is the global scope. |
| if (Lexical->isFileContext() && !Lexical->Equals(Semantic) && |
| Lexical->Encloses(Semantic)) |
| return std::make_pair(Semantic, true); |
| |
| return std::make_pair(Lexical, false); |
| } |
| |
| namespace { |
| /// An RAII object to specify that we want to find block scope extern |
| /// declarations. |
| struct FindLocalExternScope { |
| FindLocalExternScope(LookupResult &R) |
| : R(R), OldFindLocalExtern(R.getIdentifierNamespace() & |
| Decl::IDNS_LocalExtern) { |
| R.setFindLocalExtern(R.getIdentifierNamespace() & |
| (Decl::IDNS_Ordinary | Decl::IDNS_NonMemberOperator)); |
| } |
| void restore() { |
| R.setFindLocalExtern(OldFindLocalExtern); |
| } |
| ~FindLocalExternScope() { |
| restore(); |
| } |
| LookupResult &R; |
| bool OldFindLocalExtern; |
| }; |
| } // end anonymous namespace |
| |
| bool Sema::CppLookupName(LookupResult &R, Scope *S) { |
| assert(getLangOpts().CPlusPlus && "Can perform only C++ lookup"); |
| |
| DeclarationName Name = R.getLookupName(); |
| Sema::LookupNameKind NameKind = R.getLookupKind(); |
| |
| // If this is the name of an implicitly-declared special member function, |
| // go through the scope stack to implicitly declare |
| if (isImplicitlyDeclaredMemberFunctionName(Name)) { |
| for (Scope *PreS = S; PreS; PreS = PreS->getParent()) |
| if (DeclContext *DC = PreS->getEntity()) |
| DeclareImplicitMemberFunctionsWithName(*this, Name, R.getNameLoc(), DC); |
| } |
| |
| // Implicitly declare member functions with the name we're looking for, if in |
| // fact we are in a scope where it matters. |
| |
| Scope *Initial = S; |
| IdentifierResolver::iterator |
| I = IdResolver.begin(Name), |
| IEnd = IdResolver.end(); |
| |
| // First we lookup local scope. |
| // We don't consider using-directives, as per 7.3.4.p1 [namespace.udir] |
| // ...During unqualified name lookup (3.4.1), the names appear as if |
| // they were declared in the nearest enclosing namespace which contains |
| // both the using-directive and the nominated namespace. |
| // [Note: in this context, "contains" means "contains directly or |
| // indirectly". |
| // |
| // For example: |
| // namespace A { int i; } |
| // void foo() { |
| // int i; |
| // { |
| // using namespace A; |
| // ++i; // finds local 'i', A::i appears at global scope |
| // } |
| // } |
| // |
| UnqualUsingDirectiveSet UDirs(*this); |
| bool VisitedUsingDirectives = false; |
| bool LeftStartingScope = false; |
| DeclContext *OutsideOfTemplateParamDC = nullptr; |
| |
| // When performing a scope lookup, we want to find local extern decls. |
| FindLocalExternScope FindLocals(R); |
| |
| for (; S && !isNamespaceOrTranslationUnitScope(S); S = S->getParent()) { |
| DeclContext *Ctx = S->getEntity(); |
| bool SearchNamespaceScope = true; |
| // Check whether the IdResolver has anything in this scope. |
| for (; I != IEnd && S->isDeclScope(*I); ++I) { |
| if (NamedDecl *ND = R.getAcceptableDecl(*I)) { |
| if (NameKind == LookupRedeclarationWithLinkage && |
| !(*I)->isTemplateParameter()) { |
| // If it's a template parameter, we still find it, so we can diagnose |
| // the invalid redeclaration. |
| |
| // Determine whether this (or a previous) declaration is |
| // out-of-scope. |
| if (!LeftStartingScope && !Initial->isDeclScope(*I)) |
| LeftStartingScope = true; |
| |
| // If we found something outside of our starting scope that |
| // does not have linkage, skip it. |
| if (LeftStartingScope && !((*I)->hasLinkage())) { |
| R.setShadowed(); |
| continue; |
| } |
| } else { |
| // We found something in this scope, we should not look at the |
| // namespace scope |
| SearchNamespaceScope = false; |
| } |
| R.addDecl(ND); |
| } |
| } |
| if (!SearchNamespaceScope) { |
| R.resolveKind(); |
| if (S->isClassScope()) |
| if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(Ctx)) |
| R.setNamingClass(Record); |
| return true; |
| } |
| |
| if (NameKind == LookupLocalFriendName && !S->isClassScope()) { |
| // C++11 [class.friend]p11: |
| // If a friend declaration appears in a local class and the name |
| // specified is an unqualified name, a prior declaration is |
| // looked up without considering scopes that are outside the |
| // innermost enclosing non-class scope. |
| return false; |
| } |
| |
| if (!Ctx && S->isTemplateParamScope() && OutsideOfTemplateParamDC && |
| S->getParent() && !S->getParent()->isTemplateParamScope()) { |
| // We've just searched the last template parameter scope and |
| // found nothing, so look into the contexts between the |
| // lexical and semantic declaration contexts returned by |
| // findOuterContext(). This implements the name lookup behavior |
| // of C++ [temp.local]p8. |
| Ctx = OutsideOfTemplateParamDC; |
| OutsideOfTemplateParamDC = nullptr; |
| } |
| |
| if (Ctx) { |
| DeclContext *OuterCtx; |
| bool SearchAfterTemplateScope; |
| std::tie(OuterCtx, SearchAfterTemplateScope) = findOuterContext(S); |
| if (SearchAfterTemplateScope) |
| OutsideOfTemplateParamDC = OuterCtx; |
| |
| for (; Ctx && !Ctx->Equals(OuterCtx); Ctx = Ctx->getLookupParent()) { |
| // We do not directly look into transparent contexts, since |
| // those entities will be found in the nearest enclosing |
| // non-transparent context. |
| if (Ctx->isTransparentContext()) |
| continue; |
| |
| // We do not look directly into function or method contexts, |
| // since all of the local variables and parameters of the |
| // function/method are present within the Scope. |
| if (Ctx->isFunctionOrMethod()) { |
| // If we have an Objective-C instance method, look for ivars |
| // in the corresponding interface. |
| if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(Ctx)) { |
| if (Method->isInstanceMethod() && Name.getAsIdentifierInfo()) |
| if (ObjCInterfaceDecl *Class = Method->getClassInterface()) { |
| ObjCInterfaceDecl *ClassDeclared; |
| if (ObjCIvarDecl *Ivar = Class->lookupInstanceVariable( |
| Name.getAsIdentifierInfo(), |
| ClassDeclared)) { |
| if (NamedDecl *ND = R.getAcceptableDecl(Ivar)) { |
| R.addDecl(ND); |
| R.resolveKind(); |
| return true; |
| } |
| } |
| } |
| } |
| |
| continue; |
| } |
| |
| // If this is a file context, we need to perform unqualified name |
| // lookup considering using directives. |
| if (Ctx->isFileContext()) { |
| // If we haven't handled using directives yet, do so now. |
| if (!VisitedUsingDirectives) { |
| // Add using directives from this context up to the top level. |
| for (DeclContext *UCtx = Ctx; UCtx; UCtx = UCtx->getParent()) { |
| if (UCtx->isTransparentContext()) |
| continue; |
| |
| UDirs.visit(UCtx, UCtx); |
| } |
| |
| // Find the innermost file scope, so we can add using directives |
| // from local scopes. |
| Scope *InnermostFileScope = S; |
| while (InnermostFileScope && |
| !isNamespaceOrTranslationUnitScope(InnermostFileScope)) |
| InnermostFileScope = InnermostFileScope->getParent(); |
| UDirs.visitScopeChain(Initial, InnermostFileScope); |
| |
| UDirs.done(); |
| |
| VisitedUsingDirectives = true; |
| } |
| |
| if (CppNamespaceLookup(*this, R, Context, Ctx, UDirs)) { |
| R.resolveKind(); |
| return true; |
| } |
| |
| continue; |
| } |
| |
| // Perform qualified name lookup into this context. |
| // FIXME: In some cases, we know that every name that could be found by |
| // this qualified name lookup will also be on the identifier chain. For |
| // example, inside a class without any base classes, we never need to |
| // perform qualified lookup because all of the members are on top of the |
| // identifier chain. |
| if (LookupQualifiedName(R, Ctx, /*InUnqualifiedLookup=*/true)) |
| return true; |
| } |
| } |
| } |
| |
| // Stop if we ran out of scopes. |
| // FIXME: This really, really shouldn't be happening. |
| if (!S) return false; |
| |
| // If we are looking for members, no need to look into global/namespace scope. |
| if (NameKind == LookupMemberName) |
| return false; |
| |
| // Collect UsingDirectiveDecls in all scopes, and recursively all |
| // nominated namespaces by those using-directives. |
| // |
| // FIXME: Cache this sorted list in Scope structure, and DeclContext, so we |
| // don't build it for each lookup! |
| if (!VisitedUsingDirectives) { |
| UDirs.visitScopeChain(Initial, S); |
| UDirs.done(); |
| } |
| |
| // If we're not performing redeclaration lookup, do not look for local |
| // extern declarations outside of a function scope. |
| if (!R.isForRedeclaration()) |
| FindLocals.restore(); |
| |
| // Lookup namespace scope, and global scope. |
| // Unqualified name lookup in C++ requires looking into scopes |
| // that aren't strictly lexical, and therefore we walk through the |
| // context as well as walking through the scopes. |
| for (; S; S = S->getParent()) { |
| // Check whether the IdResolver has anything in this scope. |
| bool Found = false; |
| for (; I != IEnd && S->isDeclScope(*I); ++I) { |
| if (NamedDecl *ND = R.getAcceptableDecl(*I)) { |
| // We found something. Look for anything else in our scope |
| // with this same name and in an acceptable identifier |
| // namespace, so that we can construct an overload set if we |
| // need to. |
| Found = true; |
| R.addDecl(ND); |
| } |
| } |
| |
| if (Found && S->isTemplateParamScope()) { |
| R.resolveKind(); |
| return true; |
| } |
| |
| DeclContext *Ctx = S->getEntity(); |
| if (!Ctx && S->isTemplateParamScope() && OutsideOfTemplateParamDC && |
| S->getParent() && !S->getParent()->isTemplateParamScope()) { |
| // We've just searched the last template parameter scope and |
| // found nothing, so look into the contexts between the |
| // lexical and semantic declaration contexts returned by |
| // findOuterContext(). This implements the name lookup behavior |
| // of C++ [temp.local]p8. |
| Ctx = OutsideOfTemplateParamDC; |
| OutsideOfTemplateParamDC = nullptr; |
| } |
| |
| if (Ctx) { |
| DeclContext *OuterCtx; |
| bool SearchAfterTemplateScope; |
| std::tie(OuterCtx, SearchAfterTemplateScope) = findOuterContext(S); |
| if (SearchAfterTemplateScope) |
| OutsideOfTemplateParamDC = OuterCtx; |
| |
| for (; Ctx && !Ctx->Equals(OuterCtx); Ctx = Ctx->getLookupParent()) { |
| // We do not directly look into transparent contexts, since |
| // those entities will be found in the nearest enclosing |
| // non-transparent context. |
| if (Ctx->isTransparentContext()) |
| continue; |
| |
| // If we have a context, and it's not a context stashed in the |
| // template parameter scope for an out-of-line definition, also |
| // look into that context. |
| if (!(Found && S->isTemplateParamScope())) { |
| assert(Ctx->isFileContext() && |
| "We should have been looking only at file context here already."); |
| |
| // Look into context considering using-directives. |
| if (CppNamespaceLookup(*this, R, Context, Ctx, UDirs)) |
| Found = true; |
| } |
| |
| if (Found) { |
| R.resolveKind(); |
| return true; |
| } |
| |
| if (R.isForRedeclaration() && !Ctx->isTransparentContext()) |
| return false; |
| } |
| } |
| |
| if (R.isForRedeclaration() && Ctx && !Ctx->isTransparentContext()) |
| return false; |
| } |
| |
| return !R.empty(); |
| } |
| |
| void Sema::makeMergedDefinitionVisible(NamedDecl *ND) { |
| if (auto *M = getCurrentModule()) |
| Context.mergeDefinitionIntoModule(ND, M); |
| else |
| // We're not building a module; just make the definition visible. |
| ND->setVisibleDespiteOwningModule(); |
| |
| // If ND is a template declaration, make the template parameters |
| // visible too. They're not (necessarily) within a mergeable DeclContext. |
| if (auto *TD = dyn_cast<TemplateDecl>(ND)) |
| for (auto *Param : *TD->getTemplateParameters()) |
| makeMergedDefinitionVisible(Param); |
| } |
| |
| /// Find the module in which the given declaration was defined. |
| static Module *getDefiningModule(Sema &S, Decl *Entity) { |
| if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Entity)) { |
| // If this function was instantiated from a template, the defining module is |
| // the module containing the pattern. |
| if (FunctionDecl *Pattern = FD->getTemplateInstantiationPattern()) |
| Entity = Pattern; |
| } else if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Entity)) { |
| if (CXXRecordDecl *Pattern = RD->getTemplateInstantiationPattern()) |
| Entity = Pattern; |
| } else if (EnumDecl *ED = dyn_cast<EnumDecl>(Entity)) { |
| if (auto *Pattern = ED->getTemplateInstantiationPattern()) |
| Entity = Pattern; |
| } else if (VarDecl *VD = dyn_cast<VarDecl>(Entity)) { |
| if (VarDecl *Pattern = VD->getTemplateInstantiationPattern()) |
| Entity = Pattern; |
| } |
| |
| // Walk up to the containing context. That might also have been instantiated |
| // from a template. |
| DeclContext *Context = Entity->getLexicalDeclContext(); |
| if (Context->isFileContext()) |
| return S.getOwningModule(Entity); |
| return getDefiningModule(S, cast<Decl>(Context)); |
| } |
| |
| llvm::DenseSet<Module*> &Sema::getLookupModules() { |
| unsigned N = CodeSynthesisContexts.size(); |
| for (unsigned I = CodeSynthesisContextLookupModules.size(); |
| I != N; ++I) { |
| Module *M = getDefiningModule(*this, CodeSynthesisContexts[I].Entity); |
| if (M && !LookupModulesCache.insert(M).second) |
| M = nullptr; |
| CodeSynthesisContextLookupModules.push_back(M); |
| } |
| return LookupModulesCache; |
| } |
| |
| /// Determine whether the module M is part of the current module from the |
| /// perspective of a module-private visibility check. |
| static bool isInCurrentModule(const Module *M, const LangOptions &LangOpts) { |
| // If M is the global module fragment of a module that we've not yet finished |
| // parsing, then it must be part of the current module. |
| return M->getTopLevelModuleName() == LangOpts.CurrentModule || |
| (M->Kind == Module::GlobalModuleFragment && !M->Parent); |
| } |
| |
| bool Sema::hasVisibleMergedDefinition(NamedDecl *Def) { |
| for (const Module *Merged : Context.getModulesWithMergedDefinition(Def)) |
| if (isModuleVisible(Merged)) |
| return true; |
| return false; |
| } |
| |
| bool Sema::hasMergedDefinitionInCurrentModule(NamedDecl *Def) { |
| for (const Module *Merged : Context.getModulesWithMergedDefinition(Def)) |
| if (isInCurrentModule(Merged, getLangOpts())) |
| return true; |
| return false; |
| } |
| |
| template<typename ParmDecl> |
| static bool |
| hasVisibleDefaultArgument(Sema &S, const ParmDecl *D, |
| llvm::SmallVectorImpl<Module *> *Modules) { |
| if (!D->hasDefaultArgument()) |
| return false; |
| |
| while (D) { |
| auto &DefaultArg = D->getDefaultArgStorage(); |
| if (!DefaultArg.isInherited() && S.isVisible(D)) |
| return true; |
| |
| if (!DefaultArg.isInherited() && Modules) { |
| auto *NonConstD = const_cast<ParmDecl*>(D); |
| Modules->push_back(S.getOwningModule(NonConstD)); |
| } |
| |
| // If there was a previous default argument, maybe its parameter is visible. |
| D = DefaultArg.getInheritedFrom(); |
| } |
| return false; |
| } |
| |
| bool Sema::hasVisibleDefaultArgument(const NamedDecl *D, |
| llvm::SmallVectorImpl<Module *> *Modules) { |
| if (auto *P = dyn_cast<TemplateTypeParmDecl>(D)) |
| return ::hasVisibleDefaultArgument(*this, P, Modules); |
| if (auto *P = dyn_cast<NonTypeTemplateParmDecl>(D)) |
| return ::hasVisibleDefaultArgument(*this, P, Modules); |
| return ::hasVisibleDefaultArgument(*this, cast<TemplateTemplateParmDecl>(D), |
| Modules); |
| } |
| |
| template<typename Filter> |
| static bool hasVisibleDeclarationImpl(Sema &S, const NamedDecl *D, |
| llvm::SmallVectorImpl<Module *> *Modules, |
| Filter F) { |
| bool HasFilteredRedecls = false; |
| |
| for (auto *Redecl : D->redecls()) { |
| auto *R = cast<NamedDecl>(Redecl); |
| if (!F(R)) |
| continue; |
| |
| if (S.isVisible(R)) |
| return true; |
| |
| HasFilteredRedecls = true; |
| |
| if (Modules) |
| Modules->push_back(R->getOwningModule()); |
| } |
| |
| // Only return false if there is at least one redecl that is not filtered out. |
| if (HasFilteredRedecls) |
| return false; |
| |
| return true; |
| } |
| |
| bool Sema::hasVisibleExplicitSpecialization( |
| const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) { |
| return hasVisibleDeclarationImpl(*this, D, Modules, [](const NamedDecl *D) { |
| if (auto *RD = dyn_cast<CXXRecordDecl>(D)) |
| return RD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization; |
| if (auto *FD = dyn_cast<FunctionDecl>(D)) |
| return FD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization; |
| if (auto *VD = dyn_cast<VarDecl>(D)) |
| return VD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization; |
| llvm_unreachable("unknown explicit specialization kind"); |
| }); |
| } |
| |
| bool Sema::hasVisibleMemberSpecialization( |
| const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) { |
| assert(isa<CXXRecordDecl>(D->getDeclContext()) && |
| "not a member specialization"); |
| return hasVisibleDeclarationImpl(*this, D, Modules, [](const NamedDecl *D) { |
| // If the specialization is declared at namespace scope, then it's a member |
| // specialization declaration. If it's lexically inside the class |
| // definition then it was instantiated. |
| // |
| // FIXME: This is a hack. There should be a better way to determine this. |
| // FIXME: What about MS-style explicit specializations declared within a |
| // class definition? |
| return D->getLexicalDeclContext()->isFileContext(); |
| }); |
| } |
| |
| /// Determine whether a declaration is visible to name lookup. |
| /// |
| /// This routine determines whether the declaration D is visible in the current |
| /// lookup context, taking into account the current template instantiation |
| /// stack. During template instantiation, a declaration is visible if it is |
| /// visible from a module containing any entity on the template instantiation |
| /// path (by instantiating a template, you allow it to see the declarations that |
| /// your module can see, including those later on in your module). |
| bool LookupResult::isVisibleSlow(Sema &SemaRef, NamedDecl *D) { |
| assert(D->isHidden() && "should not call this: not in slow case"); |
| |
| Module *DeclModule = SemaRef.getOwningModule(D); |
| assert(DeclModule && "hidden decl has no owning module"); |
| |
| // If the owning module is visible, the decl is visible. |
| if (SemaRef.isModuleVisible(DeclModule, D->isModulePrivate())) |
| return true; |
| |
| // Determine whether a decl context is a file context for the purpose of |
| // visibility. This looks through some (export and linkage spec) transparent |
| // contexts, but not others (enums). |
| auto IsEffectivelyFileContext = [](const DeclContext *DC) { |
| return DC->isFileContext() || isa<LinkageSpecDecl>(DC) || |
| isa<ExportDecl>(DC); |
| }; |
| |
| // If this declaration is not at namespace scope |
| // then it is visible if its lexical parent has a visible definition. |
| DeclContext *DC = D->getLexicalDeclContext(); |
| if (DC && !IsEffectivelyFileContext(DC)) { |
| // For a parameter, check whether our current template declaration's |
| // lexical context is visible, not whether there's some other visible |
| // definition of it, because parameters aren't "within" the definition. |
| // |
| // In C++ we need to check for a visible definition due to ODR merging, |
| // and in C we must not because each declaration of a function gets its own |
| // set of declarations for tags in prototype scope. |
| bool VisibleWithinParent; |
| if (D->isTemplateParameter()) { |
| bool SearchDefinitions = true; |
| if (const auto *DCD = dyn_cast<Decl>(DC)) { |
| if (const auto *TD = DCD->getDescribedTemplate()) { |
| TemplateParameterList *TPL = TD->getTemplateParameters(); |
| auto Index = getDepthAndIndex(D).second; |
| SearchDefinitions = Index >= TPL->size() || TPL->getParam(Index) != D; |
| } |
| } |
| if (SearchDefinitions) |
| VisibleWithinParent = SemaRef.hasVisibleDefinition(cast<NamedDecl>(DC)); |
| else |
| VisibleWithinParent = isVisible(SemaRef, cast<NamedDecl>(DC)); |
| } else if (isa<ParmVarDecl>(D) || |
| (isa<FunctionDecl>(DC) && !SemaRef.getLangOpts().CPlusPlus)) |
| VisibleWithinParent = isVisible(SemaRef, cast<NamedDecl>(DC)); |
| else if (D->isModulePrivate()) { |
| // A module-private declaration is only visible if an enclosing lexical |
| // parent was merged with another definition in the current module. |
| VisibleWithinParent = false; |
| do { |
| if (SemaRef.hasMergedDefinitionInCurrentModule(cast<NamedDecl>(DC))) { |
| VisibleWithinParent = true; |
| break; |
| } |
| DC = DC->getLexicalParent(); |
| } while (!IsEffectivelyFileContext(DC)); |
| } else { |
| VisibleWithinParent = SemaRef.hasVisibleDefinition(cast<NamedDecl>(DC)); |
| } |
| |
| if (VisibleWithinParent && SemaRef.CodeSynthesisContexts.empty() && |
| // FIXME: Do something better in this case. |
| !SemaRef.getLangOpts().ModulesLocalVisibility) { |
| // Cache the fact that this declaration is implicitly visible because |
| // its parent has a visible definition. |
| D->setVisibleDespiteOwningModule(); |
| } |
| return VisibleWithinParent; |
| } |
| |
| return false; |
| } |
| |
| bool Sema::isModuleVisible(const Module *M, bool ModulePrivate) { |
| // The module might be ordinarily visible. For a module-private query, that |
| // means it is part of the current module. For any other query, that means it |
| // is in our visible module set. |
| if (ModulePrivate) { |
| if (isInCurrentModule(M, getLangOpts())) |
| return true; |
| } else { |
| if (VisibleModules.isVisible(M)) |
| return true; |
| } |
| |
| // Otherwise, it might be visible by virtue of the query being within a |
| // template instantiation or similar that is permitted to look inside M. |
| |
| // Find the extra places where we need to look. |
| const auto &LookupModules = getLookupModules(); |
| if (LookupModules.empty()) |
| return false; |
| |
| // If our lookup set contains the module, it's visible. |
| if (LookupModules.count(M)) |
| return true; |
| |
| // For a module-private query, that's everywhere we get to look. |
| if (ModulePrivate) |
| return false; |
| |
| // Check whether M is transitively exported to an import of the lookup set. |
| return llvm::any_of(LookupModules, [&](const Module *LookupM) { |
| return LookupM->isModuleVisible(M); |
| }); |
| } |
| |
| bool Sema::isVisibleSlow(const NamedDecl *D) { |
| return LookupResult::isVisible(*this, const_cast<NamedDecl*>(D)); |
| } |
| |
| bool Sema::shouldLinkPossiblyHiddenDecl(LookupResult &R, const NamedDecl *New) { |
| // FIXME: If there are both visible and hidden declarations, we need to take |
| // into account whether redeclaration is possible. Example: |
| // |
| // Non-imported module: |
| // int f(T); // #1 |
| // Some TU: |
| // static int f(U); // #2, not a redeclaration of #1 |
| // int f(T); // #3, finds both, should link with #1 if T != U, but |
| // // with #2 if T == U; neither should be ambiguous. |
| for (auto *D : R) { |
| if (isVisible(D)) |
| return true; |
| assert(D->isExternallyDeclarable() && |
| "should not have hidden, non-externally-declarable result here"); |
| } |
| |
| // This function is called once "New" is essentially complete, but before a |
| // previous declaration is attached. We can't query the linkage of "New" in |
| // general, because attaching the previous declaration can change the |
| // linkage of New to match the previous declaration. |
| // |
| // However, because we've just determined that there is no *visible* prior |
| // declaration, we can compute the linkage here. There are two possibilities: |
| // |
| // * This is not a redeclaration; it's safe to compute the linkage now. |
| // |
| // * This is a redeclaration of a prior declaration that is externally |
| // redeclarable. In that case, the linkage of the declaration is not |
| // changed by attaching the prior declaration, because both are externally |
| // declarable (and thus ExternalLinkage or VisibleNoLinkage). |
| // |
| // FIXME: This is subtle and fragile. |
| return New->isExternallyDeclarable(); |
| } |
| |
| /// Retrieve the visible declaration corresponding to D, if any. |
| /// |
| /// This routine determines whether the declaration D is visible in the current |
| /// module, with the current imports. If not, it checks whether any |
| /// redeclaration of D is visible, and if so, returns that declaration. |
| /// |
| /// \returns D, or a visible previous declaration of D, whichever is more recent |
| /// and visible. If no declaration of D is visible, returns null. |
| static NamedDecl *findAcceptableDecl(Sema &SemaRef, NamedDecl *D, |
| unsigned IDNS) { |
| assert(!LookupResult::isVisible(SemaRef, D) && "not in slow case"); |
| |
| for (auto RD : D->redecls()) { |
| // Don't bother with extra checks if we already know this one isn't visible. |
| if (RD == D) |
| continue; |
| |
| auto ND = cast<NamedDecl>(RD); |
| // FIXME: This is wrong in the case where the previous declaration is not |
| // visible in the same scope as D. This needs to be done much more |
| // carefully. |
| if (ND->isInIdentifierNamespace(IDNS) && |
| LookupResult::isVisible(SemaRef, ND)) |
| return ND; |
| } |
| |
| return nullptr; |
| } |
| |
| bool Sema::hasVisibleDeclarationSlow(const NamedDecl *D, |
| llvm::SmallVectorImpl<Module *> *Modules) { |
| assert(!isVisible(D) && "not in slow case"); |
| return hasVisibleDeclarationImpl(*this, D, Modules, |
| [](const NamedDecl *) { return true; }); |
| } |
| |
| NamedDecl *LookupResult::getAcceptableDeclSlow(NamedDecl *D) const { |
| if (auto *ND = dyn_cast<NamespaceDecl>(D)) { |
| // Namespaces are a bit of a special case: we expect there to be a lot of |
| // redeclarations of some namespaces, all declarations of a namespace are |
| // essentially interchangeable, all declarations are found by name lookup |
| // if any is, and namespaces are never looked up during template |
| // instantiation. So we benefit from caching the check in this case, and |
| // it is correct to do so. |
| auto *Key = ND->getCanonicalDecl(); |
| if (auto *Acceptable = getSema().VisibleNamespaceCache.lookup(Key)) |
| return Acceptable; |
| auto *Acceptable = isVisible(getSema(), Key) |
| ? Key |
| : findAcceptableDecl(getSema(), Key, IDNS); |
| if (Acceptable) |
| getSema().VisibleNamespaceCache.insert(std::make_pair(Key, Acceptable)); |
| return Acceptable; |
| } |
| |
| return findAcceptableDecl(getSema(), D, IDNS); |
| } |
| |
| /// Perform unqualified name lookup starting from a given |
| /// scope. |
| /// |
| /// Unqualified name lookup (C++ [basic.lookup.unqual], C99 6.2.1) is |
| /// used to find names within the current scope. For example, 'x' in |
| /// @code |
| /// int x; |
| /// int f() { |
| /// return x; // unqualified name look finds 'x' in the global scope |
| /// } |
| /// @endcode |
| /// |
| /// Different lookup criteria can find different names. For example, a |
| /// particular scope can have both a struct and a function of the same |
| /// name, and each can be found by certain lookup criteria. For more |
| /// information about lookup criteria, see the documentation for the |
| /// class LookupCriteria. |
| /// |
| /// @param S The scope from which unqualified name lookup will |
| /// begin. If the lookup criteria permits, name lookup may also search |
| /// in the parent scopes. |
| /// |
| /// @param [in,out] R Specifies the lookup to perform (e.g., the name to |
| /// look up and the lookup kind), and is updated with the results of lookup |
| /// including zero or more declarations and possibly additional information |
| /// used to diagnose ambiguities. |
| /// |
| /// @returns \c true if lookup succeeded and false otherwise. |
| bool Sema::LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation) { |
| DeclarationName Name = R.getLookupName(); |
| if (!Name) return false; |
| |
| LookupNameKind NameKind = R.getLookupKind(); |
| |
| if (!getLangOpts().CPlusPlus) { |
| // Unqualified name lookup in C/Objective-C is purely lexical, so |
| // search in the declarations attached to the name. |
| if (NameKind == Sema::LookupRedeclarationWithLinkage) { |
| // Find the nearest non-transparent declaration scope. |
| while (!(S->getFlags() & Scope::DeclScope) || |
| (S->getEntity() && S->getEntity()->isTransparentContext())) |
| S = S->getParent(); |
| } |
| |
| // When performing a scope lookup, we want to find local extern decls. |
| FindLocalExternScope FindLocals(R); |
| |
| // Scan up the scope chain looking for a decl that matches this |
| // identifier that is in the appropriate namespace. This search |
| // should not take long, as shadowing of names is uncommon, and |
| // deep shadowing is extremely uncommon. |
| bool LeftStartingScope = false; |
| |
| for (IdentifierResolver::iterator I = IdResolver.begin(Name), |
| IEnd = IdResolver.end(); |
| I != IEnd; ++I) |
| if (NamedDecl *D = R.getAcceptableDecl(*I)) { |
| if (NameKind == LookupRedeclarationWithLinkage) { |
| // Determine whether this (or a previous) declaration is |
| // out-of-scope. |
| if (!LeftStartingScope && !S->isDeclScope(*I)) |
| LeftStartingScope = true; |
| |
| // If we found something outside of our starting scope that |
| // does not have linkage, skip it. |
| if (LeftStartingScope && !((*I)->hasLinkage())) { |
| R.setShadowed(); |
| continue; |
| } |
| } |
| else if (NameKind == LookupObjCImplicitSelfParam && |
| !isa<ImplicitParamDecl>(*I)) |
| continue; |
| |
| R.addDecl(D); |
| |
| // Check whether there are any other declarations with the same name |
| // and in the same scope. |
| if (I != IEnd) { |
| // Find the scope in which this declaration was declared (if it |
| // actually exists in a Scope). |
| while (S && !S->isDeclScope(D)) |
| S = S->getParent(); |
| |
| // If the scope containing the declaration is the translation unit, |
| // then we'll need to perform our checks based on the matching |
| // DeclContexts rather than matching scopes. |
| if (S && isNamespaceOrTranslationUnitScope(S)) |
| S = nullptr; |
| |
| // Compute the DeclContext, if we need it. |
| DeclContext *DC = nullptr; |
| if (!S) |
| DC = (*I)->getDeclContext()->getRedeclContext(); |
| |
| IdentifierResolver::iterator LastI = I; |
| for (++LastI; LastI != IEnd; ++LastI) { |
| if (S) { |
| // Match based on scope. |
| if (!S->isDeclScope(*LastI)) |
| break; |
| } else { |
| // Match based on DeclContext. |
| DeclContext *LastDC |
| = (*LastI)->getDeclContext()->getRedeclContext(); |
| if (!LastDC->Equals(DC)) |
| break; |
| } |
| |
| // If the declaration is in the right namespace and visible, add it. |
| if (NamedDecl *LastD = R.getAcceptableDecl(*LastI)) |
| R.addDecl(LastD); |
| } |
| |
| R.resolveKind(); |
| } |
| |
| return true; |
| } |
| } else { |
| // Perform C++ unqualified name lookup. |
| if (CppLookupName(R, S)) |
| return true; |
| } |
| |
| // If we didn't find a use of this identifier, and if the identifier |
| // corresponds to a compiler builtin, create the decl object for the builtin |
| // now, injecting it into translation unit scope, and return it. |
| if (AllowBuiltinCreation && LookupBuiltin(R)) |
| return true; |
| |
| // If we didn't find a use of this identifier, the ExternalSource |
| // may be able to handle the situation. |
| // Note: some lookup failures are expected! |
| // See e.g. R.isForRedeclaration(). |
| return (ExternalSource && ExternalSource->LookupUnqualified(R, S)); |
| } |
| |
| /// Perform qualified name lookup in the namespaces nominated by |
| /// using directives by the given context. |
| /// |
| /// C++98 [namespace.qual]p2: |
| /// Given X::m (where X is a user-declared namespace), or given \::m |
| /// (where X is the global namespace), let S be the set of all |
| /// declarations of m in X and in the transitive closure of all |
| /// namespaces nominated by using-directives in X and its used |
| /// namespaces, except that using-directives are ignored in any |
| /// namespace, including X, directly containing one or more |
| /// declarations of m. No namespace is searched more than once in |
| /// the lookup of a name. If S is the empty set, the program is |
| /// ill-formed. Otherwise, if S has exactly one member, or if the |
| /// context of the reference is a using-declaration |
| /// (namespace.udecl), S is the required set of declarations of |
| /// m. Otherwise if the use of m is not one that allows a unique |
| /// declaration to be chosen from S, the program is ill-formed. |
| /// |
| /// C++98 [namespace.qual]p5: |
| /// During the lookup of a qualified namespace member name, if the |
| /// lookup finds more than one declaration of the member, and if one |
| /// declaration introduces a class name or enumeration name and the |
| /// other declarations either introduce the same object, the same |
| /// enumerator or a set of functions, the non-type name hides the |
| /// class or enumeration name if and only if the declarations are |
| /// from the same namespace; otherwise (the declarations are from |
| /// different namespaces), the program is ill-formed. |
| static bool LookupQualifiedNameInUsingDirectives(Sema &S, LookupResult &R, |
| DeclContext *StartDC) { |
| assert(StartDC->isFileContext() && "start context is not a file context"); |
| |
| // We have not yet looked into these namespaces, much less added |
| // their "using-children" to the queue. |
| SmallVector<NamespaceDecl*, 8> Queue; |
| |
| // We have at least added all these contexts to the queue. |
| llvm::SmallPtrSet<DeclContext*, 8> Visited; |
| Visited.insert(StartDC); |
| |
| // We have already looked into the initial namespace; seed the queue |
| // with its using-children. |
| for (auto *I : StartDC->using_directives()) { |
| NamespaceDecl *ND = I->getNominatedNamespace()->getOriginalNamespace(); |
| if (S.isVisible(I) && Visited.insert(ND).second) |
| Queue.push_back(ND); |
| } |
| |
| // The easiest way to implement the restriction in [namespace.qual]p5 |
| // is to check whether any of the individual results found a tag |
| // and, if so, to declare an ambiguity if the final result is not |
| // a tag. |
| bool FoundTag = false; |
| bool FoundNonTag = false; |
| |
| LookupResult LocalR(LookupResult::Temporary, R); |
| |
| bool Found = false; |
| while (!Queue.empty()) { |
| NamespaceDecl *ND = Queue.pop_back_val(); |
| |
| // We go through some convolutions here to avoid copying results |
| // between LookupResults. |
| bool UseLocal = !R.empty(); |
| LookupResult &DirectR = UseLocal ? LocalR : R; |
| bool FoundDirect = LookupDirect(S, DirectR, ND); |
| |
| if (FoundDirect) { |
| // First do any local hiding. |
| DirectR.resolveKind(); |
| |
| // If the local result is a tag, remember that. |
| if (DirectR.isSingleTagDecl()) |
| FoundTag = true; |
| else |
| FoundNonTag = true; |
| |
| // Append the local results to the total results if necessary. |
| if (UseLocal) { |
| R.addAllDecls(LocalR); |
| LocalR.clear(); |
| } |
| } |
| |
| // If we find names in this namespace, ignore its using directives. |
| if (FoundDirect) { |
| Found = true; |
| continue; |
| } |
| |
| for (auto I : ND->using_directives()) { |
| NamespaceDecl *Nom = I->getNominatedNamespace(); |
| if (S.isVisible(I) && Visited.insert(Nom).second) |
| Queue.push_back(Nom); |
| } |
| } |
| |
| if (Found) { |
| if (FoundTag && FoundNonTag) |
| R.setAmbiguousQualifiedTagHiding(); |
| else |
| R.resolveKind(); |
| } |
| |
| return Found; |
| } |
| |
| /// Callback that looks for any member of a class with the given name. |
| static bool LookupAnyMember(const CXXBaseSpecifier *Specifier, |
| CXXBasePath &Path, DeclarationName Name) { |
| RecordDecl *BaseRecord = Specifier->getType()->castAs<RecordType>()->getDecl(); |
| |
| Path.Decls = BaseRecord->lookup(Name); |
| return !Path.Decls.empty(); |
| } |
| |
| /// Determine whether the given set of member declarations contains only |
| /// static members, nested types, and enumerators. |
| template<typename InputIterator> |
| static bool HasOnlyStaticMembers(InputIterator First, InputIterator Last) { |
| Decl *D = (*First)->getUnderlyingDecl(); |
| if (isa<VarDecl>(D) || isa<TypeDecl>(D) || isa<EnumConstantDecl>(D)) |
| return true; |
| |
| if (isa<CXXMethodDecl>(D)) { |
| // Determine whether all of the methods are static. |
| bool AllMethodsAreStatic = true; |
| for(; First != Last; ++First) { |
| D = (*First)->getUnderlyingDecl(); |
| |
| if (!isa<CXXMethodDecl>(D)) { |
| assert(isa<TagDecl>(D) && "Non-function must be a tag decl"); |
| break; |
| } |
| |
| if (!cast<CXXMethodDecl>(D)->isStatic()) { |
| AllMethodsAreStatic = false; |
| break; |
| } |
| } |
| |
| if (AllMethodsAreStatic) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /// Perform qualified name lookup into a given context. |
| /// |
| /// Qualified name lookup (C++ [basic.lookup.qual]) is used to find |
| /// names when the context of those names is explicit specified, e.g., |
| /// "std::vector" or "x->member", or as part of unqualified name lookup. |
| /// |
| /// Different lookup criteria can find different names. For example, a |
| /// particular scope can have both a struct and a function of the same |
| /// name, and each can be found by certain lookup criteria. For more |
| /// information about lookup criteria, see the documentation for the |
| /// class LookupCriteria. |
| /// |
| /// \param R captures both the lookup criteria and any lookup results found. |
| /// |
| /// \param LookupCtx The context in which qualified name lookup will |
| /// search. If the lookup criteria permits, name lookup may also search |
| /// in the parent contexts or (for C++ classes) base classes. |
| /// |
| /// \param InUnqualifiedLookup true if this is qualified name lookup that |
| /// occurs as part of unqualified name lookup. |
| /// |
| /// \returns true if lookup succeeded, false if it failed. |
| bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, |
| bool InUnqualifiedLookup) { |
| assert(LookupCtx && "Sema::LookupQualifiedName requires a lookup context"); |
| |
| if (!R.getLookupName()) |
| return false; |
| |
| // Make sure that the declaration context is complete. |
| assert((!isa<TagDecl>(LookupCtx) || |
| LookupCtx->isDependentContext() || |
| cast<TagDecl>(LookupCtx)->isCompleteDefinition() || |
| cast<TagDecl>(LookupCtx)->isBeingDefined()) && |
| "Declaration context must already be complete!"); |
| |
| struct QualifiedLookupInScope { |
| bool oldVal; |
| DeclContext *Context; |
| // Set flag in DeclContext informing debugger that we're looking for qualified name |
| QualifiedLookupInScope(DeclContext *ctx) : Context(ctx) { |
| oldVal = ctx->setUseQualifiedLookup(); |
| } |
| ~QualifiedLookupInScope() { |
| Context->setUseQualifiedLookup(oldVal); |
| } |
| } QL(LookupCtx); |
| |
| if (LookupDirect(*this, R, LookupCtx)) { |
| R.resolveKind(); |
| if (isa<CXXRecordDecl>(LookupCtx)) |
| R.setNamingClass(cast<CXXRecordDecl>(LookupCtx)); |
| return true; |
| } |
| |
| // Don't descend into implied contexts for redeclarations. |
| // C++98 [namespace.qual]p6: |
| // In a declaration for a namespace member in which the |
| // declarator-id is a qualified-id, given that the qualified-id |
| // for the namespace member has the form |
| // nested-name-specifier unqualified-id |
| // the unqualified-id shall name a member of the namespace |
| // designated by the nested-name-specifier. |
| // See also [class.mfct]p5 and [class.static.data]p2. |
| if (R.isForRedeclaration()) |
| return false; |
| |
| // If this is a namespace, look it up in the implied namespaces. |
| if (LookupCtx->isFileContext()) |
| return LookupQualifiedNameInUsingDirectives(*this, R, LookupCtx); |
| |
| // If this isn't a C++ class, we aren't allowed to look into base |
| // classes, we're done. |
| CXXRecordDecl *LookupRec = dyn_cast<CXXRecordDecl>(LookupCtx); |
| if (!LookupRec || !LookupRec->getDefinition()) |
| return false; |
| |
| // If we're performing qualified name lookup into a dependent class, |
| // then we are actually looking into a current instantiation. If we have any |
| // dependent base classes, then we either have to delay lookup until |
| // template instantiation time (at which point all bases will be available) |
| // or we have to fail. |
| if (!InUnqualifiedLookup && LookupRec->isDependentContext() && |
| LookupRec->hasAnyDependentBases()) { |
| R.setNotFoundInCurrentInstantiation(); |
| return false; |
| } |
| |
| // Perform lookup into our base classes. |
| CXXBasePaths Paths; |
| Paths.setOrigin(LookupRec); |
| |
| // Look for this member in our base classes |
| bool (*BaseCallback)(const CXXBaseSpecifier *Specifier, CXXBasePath &Path, |
| DeclarationName Name) = nullptr; |
| switch (R.getLookupKind()) { |
| case LookupObjCImplicitSelfParam: |
| case LookupOrdinaryName: |
| case LookupMemberName: |
| case LookupRedeclarationWithLinkage: |
| case LookupLocalFriendName: |
| BaseCallback = &CXXRecordDecl::FindOrdinaryMember; |
| break; |
| |
| case LookupTagName: |
| BaseCallback = &CXXRecordDecl::FindTagMember; |
| break; |
| |
| case LookupAnyName: |
| BaseCallback = &LookupAnyMember; |
| break; |
| |
| case LookupOMPReductionName: |
| BaseCallback = &CXXRecordDecl::FindOMPReductionMember; |
| break; |
| |
| case LookupOMPMapperName: |
| BaseCallback = &CXXRecordDecl::FindOMPMapperMember; |
| break; |
| |
| case LookupUsingDeclName: |
| // This lookup is for redeclarations only. |
| |
| case LookupOperatorName: |
| case LookupNamespaceName: |
| case LookupObjCProtocolName: |
| case LookupLabel: |
| // These lookups will never find a member in a C++ class (or base class). |
| return false; |
| |
| case LookupNestedNameSpecifierName: |
| BaseCallback = &CXXRecordDecl::FindNestedNameSpecifierMember; |
| break; |
| } |
| |
| DeclarationName Name = R.getLookupName(); |
| if (!LookupRec->lookupInBases( |
| [=](const CXXBaseSpecifier *Specifier, CXXBasePath &Path) { |
| return BaseCallback(Specifier, Path, Name); |
| }, |
| Paths)) |
| return false; |
| |
| R.setNamingClass(LookupRec); |
| |
| // C++ [class.member.lookup]p2: |
| // [...] If the resulting set of declarations are not all from |
| // sub-objects of the same type, or the set has a nonstatic member |
| // and includes members from distinct sub-objects, there is an |
| // ambiguity and the program is ill-formed. Otherwise that set is |
| // the result of the lookup. |
| QualType SubobjectType; |
| int SubobjectNumber = 0; |
| AccessSpecifier SubobjectAccess = AS_none; |
| |
| for (CXXBasePaths::paths_iterator Path = Paths.begin(), PathEnd = Paths.end(); |
| Path != PathEnd; ++Path) { |
| const CXXBasePathElement &PathElement = Path->back(); |
| |
| // Pick the best (i.e. most permissive i.e. numerically lowest) access |
| // across all paths. |
| SubobjectAccess = std::min(SubobjectAccess, Path->Access); |
| |
| // Determine whether we're looking at a distinct sub-object or not. |
| if (SubobjectType.isNull()) { |
| // This is the first subobject we've looked at. Record its type. |
| SubobjectType = Context.getCanonicalType(PathElement.Base->getType()); |
| SubobjectNumber = PathElement.SubobjectNumber; |
| continue; |
| } |
| |
| if (SubobjectType |
| != Context.getCanonicalType(PathElement.Base->getType())) { |
| // We found members of the given name in two subobjects of |
| // different types. If the declaration sets aren't the same, this |
| // lookup is ambiguous. |
| if (HasOnlyStaticMembers(Path->Decls.begin(), Path->Decls.end())) { |
| CXXBasePaths::paths_iterator FirstPath = Paths.begin(); |
| DeclContext::lookup_iterator FirstD = FirstPath->Decls.begin(); |
| DeclContext::lookup_iterator CurrentD = Path->Decls.begin(); |
| |
| // Get the decl that we should use for deduplicating this lookup. |
| auto GetRepresentativeDecl = [&](NamedDecl *D) -> Decl * { |
| // C++ [temp.local]p3: |
| // A lookup that finds an injected-class-name (10.2) can result in |
| // an ambiguity in certain cases (for example, if it is found in |
| // more than one base class). If all of the injected-class-names |
| // that are found refer to specializations of the same class |
| // template, and if the name is used as a template-name, the |
| // reference refers to the class template itself and not a |
| // specialization thereof, and is not ambiguous. |
| if (R.isTemplateNameLookup()) |
| if (auto *TD = getAsTemplateNameDecl(D)) |
| D = TD; |
| return D->getUnderlyingDecl()->getCanonicalDecl(); |
| }; |
| |
| while (FirstD != FirstPath->Decls.end() && |
| CurrentD != Path->Decls.end()) { |
| if (GetRepresentativeDecl(*FirstD) != |
| GetRepresentativeDecl(*CurrentD)) |
| break; |
| |
| ++FirstD; |
| ++CurrentD; |
| } |
| |
| if (FirstD == FirstPath->Decls.end() && |
| CurrentD == Path->Decls.end()) |
| continue; |
| } |
| |
| R.setAmbiguousBaseSubobjectTypes(Paths); |
| return true; |
| } |
| |
| if (SubobjectNumber != PathElement.SubobjectNumber) { |
| // We have a different subobject of the same type. |
| |
| // C++ [class.member.lookup]p5: |
| // A static member, a nested type or an enumerator defined in |
| // a base class T can unambiguously be found even if an object |
| // has more than one base class subobject of type T. |
| if (HasOnlyStaticMembers(Path->Decls.begin(), Path->Decls.end())) |
| continue; |
| |
| // We have found a nonstatic member name in multiple, distinct |
| // subobjects. Name lookup is ambiguous. |
| R.setAmbiguousBaseSubobjects(Paths); |
| return true; |
| } |
| } |
| |
| // Lookup in a base class succeeded; return these results. |
| |
| for (auto *D : Paths.front().Decls) { |
| AccessSpecifier AS = CXXRecordDecl::MergeAccess(SubobjectAccess, |
| D->getAccess()); |
| R.addDecl(D, AS); |
| } |
| R.resolveKind(); |
| return true; |
| } |
| |
| /// Performs qualified name lookup or special type of lookup for |
| /// "__super::" scope specifier. |
| /// |
| /// This routine is a convenience overload meant to be called from contexts |
| /// that need to perform a qualified name lookup with an optional C++ scope |
| /// specifier that might require special kind of lookup. |
| /// |
| /// \param R captures both the lookup criteria and any lookup results found. |
| /// |
| /// \param LookupCtx The context in which qualified name lookup will |
| /// search. |
| /// |
| /// \param SS An optional C++ scope-specifier. |
| /// |
| /// \returns true if lookup succeeded, false if it failed. |
| bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, |
| CXXScopeSpec &SS) { |
| auto *NNS = SS.getScopeRep(); |
| if (NNS && NNS->getKind() == NestedNameSpecifier::Super) |
| return LookupInSuper(R, NNS->getAsRecordDecl()); |
| else |
| |
| return LookupQualifiedName(R, LookupCtx); |
| } |
| |
| /// Performs name lookup for a name that was parsed in the |
| /// source code, and may contain a C++ scope specifier. |
| /// |
| /// This routine is a convenience routine meant to be called from |
| /// contexts that receive a name and an optional C++ scope specifier |
| /// (e.g., "N::M::x"). It will then perform either qualified or |
| /// unqualified name lookup (with LookupQualifiedName or LookupName, |
| /// respectively) on the given name and return those results. It will |
| /// perform a special type of lookup for "__super::" scope specifier. |
| /// |
| /// @param S The scope from which unqualified name lookup will |
| /// begin. |
| /// |
| /// @param SS An optional C++ scope-specifier, e.g., "::N::M". |
| /// |
| /// @param EnteringContext Indicates whether we are going to enter the |
| /// context of the scope-specifier SS (if present). |
| /// |
| /// @returns True if any decls were found (but possibly ambiguous) |
| bool Sema::LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, |
| bool AllowBuiltinCreation, bool EnteringContext) { |
| if (SS && SS->isInvalid()) { |
| // When the scope specifier is invalid, don't even look for |
| // anything. |
| return false; |
| } |
| |
| if (SS && SS->isSet()) { |
| NestedNameSpecifier *NNS = SS->getScopeRep(); |
| if (NNS->getKind() == NestedNameSpecifier::Super) |
| return LookupInSuper(R, NNS->getAsRecordDecl()); |
| |
| if (DeclContext *DC = computeDeclContext(*SS, EnteringContext)) { |
| // We have resolved the scope specifier to a particular declaration |
| // contex, and will perform name lookup in that context. |
| if (!DC->isDependentContext() && RequireCompleteDeclContext(*SS, DC)) |
| return false; |
| |
| R.setContextRange(SS->getRange()); |
| return LookupQualifiedName(R, DC); |
| } |
| |
| // We could not resolve the scope specified to a specific declaration |
| // context, which means that SS refers to an unknown specialization. |
| // Name lookup can't find anything in this case. |
| R.setNotFoundInCurrentInstantiation(); |
| R.setContextRange(SS->getRange()); |
| return false; |
| } |
| |
| // Perform unqualified name lookup starting in the given scope. |
| return LookupName(R, S, AllowBuiltinCreation); |
| } |
| |
| /// Perform qualified name lookup into all base classes of the given |
| /// class. |
| /// |
| /// \param R captures both the lookup criteria and any lookup results found. |
| /// |
| /// \param Class The context in which qualified name lookup will |
| /// search. Name lookup will search in all base classes merging the results. |
| /// |
| /// @returns True if any decls were found (but possibly ambiguous) |
| bool Sema::LookupInSuper(LookupResult &R, CXXRecordDecl *Class) { |
| // The access-control rules we use here are essentially the rules for |
| // doing a lookup in Class that just magically skipped the direct |
| // members of Class itself. That is, the naming class is Class, and the |
| // access includes the access of the base. |
| for (const auto &BaseSpec : Class->bases()) { |
| CXXRecordDecl *RD = cast<CXXRecordDecl>( |
| BaseSpec.getType()->castAs<RecordType>()->getDecl()); |
| LookupResult Result(*this, R.getLookupNameInfo(), R.getLookupKind()); |
| Result.setBaseObjectType(Context.getRecordType(Class)); |
| LookupQualifiedName(Result, RD); |
| |
| // Copy the lookup results into the target, merging the base's access into |
| // the path access. |
| for (auto I = Result.begin(), E = Result.end(); I != E; ++I) { |
| R.addDecl(I.getDecl(), |
| CXXRecordDecl::MergeAccess(BaseSpec.getAccessSpecifier(), |
| I.getAccess())); |
| } |
| |
| Result.suppressDiagnostics(); |
| } |
| |
| R.resolveKind(); |
| R.setNamingClass(Class); |
| |
| return !R.empty(); |
| } |
| |
| /// Produce a diagnostic describing the ambiguity that resulted |
| /// from name lookup. |
| /// |
| /// \param Result The result of the ambiguous lookup to be diagnosed. |
| void Sema::DiagnoseAmbiguousLookup(LookupResult &Result) { |
| assert(Result.isAmbiguous() && "Lookup result must be ambiguous"); |
| |
| DeclarationName Name = Result.getLookupName(); |
| SourceLocation NameLoc = Result.getNameLoc(); |
| SourceRange LookupRange = Result.getContextRange(); |
| |
| switch (Result.getAmbiguityKind()) { |
| case LookupResult::AmbiguousBaseSubobjects: { |
| CXXBasePaths *Paths = Result.getBasePaths(); |
| QualType SubobjectType = Paths->front().back().Base->getType(); |
| Diag(NameLoc, diag::err_ambiguous_member_multiple_subobjects) |
| << Name << SubobjectType << getAmbiguousPathsDisplayString(*Paths) |
| << LookupRange; |
| |
| DeclContext::lookup_iterator Found = Paths->front().Decls.begin(); |
| while (isa<CXXMethodDecl>(*Found) && |
| cast<CXXMethodDecl>(*Found)->isStatic()) |
| ++Found; |
| |
| Diag((*Found)->getLocation(), diag::note_ambiguous_member_found); |
| break; |
| } |
| |
| case LookupResult::AmbiguousBaseSubobjectTypes: { |
| Diag(NameLoc, diag::err_ambiguous_member_multiple_subobject_types) |
| << Name << LookupRange; |
| |
| CXXBasePaths *Paths = Result.getBasePaths(); |
| std::set<Decl *> DeclsPrinted; |
| for (CXXBasePaths::paths_iterator Path = Paths->begin(), |
| PathEnd = Paths->end(); |
| Path != PathEnd; ++Path) { |
| Decl *D = Path->Decls.front(); |
| if (DeclsPrinted.insert(D).second) |
| Diag(D->getLocation(), diag::note_ambiguous_member_found); |
| } |
| break; |
| } |
| |
| case LookupResult::AmbiguousTagHiding: { |
| Diag(NameLoc, diag::err_ambiguous_tag_hiding) << Name << LookupRange; |
| |
| llvm::SmallPtrSet<NamedDecl*, 8> TagDecls; |
| |
| for (auto *D : Result) |
| if (TagDecl *TD = dyn_cast<TagDecl>(D)) { |
| TagDecls.insert(TD); |
| Diag(TD->getLocation(), diag::note_hidden_tag); |
| } |
| |
| for (auto *D : Result) |
| if (!isa<TagDecl>(D)) |
| Diag(D->getLocation(), diag::note_hiding_object); |
| |
| // For recovery purposes, go ahead and implement the hiding. |
| LookupResult::Filter F = Result.makeFilter(); |
| while (F.hasNext()) { |
| if (TagDecls.count(F.next())) |
| F.erase(); |
| } |
| F.done(); |
| break; |
| } |
| |
| case LookupResult::AmbiguousReference: { |
| Diag(NameLoc, diag::err_ambiguous_reference) << Name << LookupRange; |
| |
| for (auto *D : Result) |
| Diag(D->getLocation(), diag::note_ambiguous_candidate) << D; |
| break; |
| } |
| } |
| } |
| |
| namespace { |
| struct AssociatedLookup { |
| AssociatedLookup(Sema &S, SourceLocation InstantiationLoc, |
| Sema::AssociatedNamespaceSet &Namespaces, |
| Sema::AssociatedClassSet &Classes) |
| : S(S), Namespaces(Namespaces), Classes(Classes), |
| InstantiationLoc(InstantiationLoc) { |
| } |
| |
| bool addClassTransitive(CXXRecordDecl *RD) { |
| Classes.insert(RD); |
| return ClassesTransitive.insert(RD); |
| } |
| |
| Sema &S; |
| Sema::AssociatedNamespaceSet &Namespaces; |
| Sema::AssociatedClassSet &Classes; |
| SourceLocation InstantiationLoc; |
| |
| private: |
| Sema::AssociatedClassSet ClassesTransitive; |
| }; |
| } // end anonymous namespace |
| |
| static void |
| addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType T); |
| |
| // Given the declaration context \param Ctx of a class, class template or |
| // enumeration, add the associated namespaces to \param Namespaces as described |
| // in [basic.lookup.argdep]p2. |
| static void CollectEnclosingNamespace(Sema::AssociatedNamespaceSet &Namespaces, |
| DeclContext *Ctx) { |
| // The exact wording has been changed in C++14 as a result of |
| // CWG 1691 (see also CWG 1690 and CWG 1692). We apply it unconditionally |
| // to all language versions since it is possible to return a local type |
| // from a lambda in C++11. |
| // |
| // C++14 [basic.lookup.argdep]p2: |
| // If T is a class type [...]. Its associated namespaces are the innermost |
| // enclosing namespaces of its associated classes. [...] |
| // |
| // If T is an enumeration type, its associated namespace is the innermost |
| // enclosing namespace of its declaration. [...] |
| |
| // We additionally skip inline namespaces. The innermost non-inline namespace |
| // contains all names of all its nested inline namespaces anyway, so we can |
| // replace the entire inline namespace tree with its root. |
| while (!Ctx->isFileContext() || Ctx->isInlineNamespace()) |
| Ctx = Ctx->getParent(); |
| |
| Namespaces.insert(Ctx->getPrimaryContext()); |
| } |
| |
| // Add the associated classes and namespaces for argument-dependent |
| // lookup that involves a template argument (C++ [basic.lookup.argdep]p2). |
| static void |
| addAssociatedClassesAndNamespaces(AssociatedLookup &Result, |
| const TemplateArgument &Arg) { |
| // C++ [basic.lookup.argdep]p2, last bullet: |
| // -- [...] ; |
| switch (Arg.getKind()) { |
| case TemplateArgument::Null: |
| break; |
| |
| case TemplateArgument::Type: |
| // [...] the namespaces and classes associated with the types of the |
| // template arguments provided for template type parameters (excluding |
| // template template parameters) |
| addAssociatedClassesAndNamespaces(Result, Arg.getAsType()); |
| break; |
| |
| case TemplateArgument::Template: |
| case TemplateArgument::TemplateExpansion: { |
| // [...] the namespaces in which any template template arguments are |
| // defined; and the classes in which any member templates used as |
| // template template arguments are defined. |
| TemplateName Template = Arg.getAsTemplateOrTemplatePattern(); |
| if (ClassTemplateDecl *ClassTemplate |
| = dyn_cast<ClassTemplateDecl>(Template.getAsTemplateDecl())) { |
| DeclContext *Ctx = ClassTemplate->getDeclContext(); |
| if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx)) |
| Result.Classes.insert(EnclosingClass); |
| // Add the associated namespace for this class. |
| CollectEnclosingNamespace(Result.Namespaces, Ctx); |
| } |
| break; |
| } |
| |
| case TemplateArgument::Declaration: |
| case TemplateArgument::Integral: |
| case TemplateArgument::Expression: |
| case TemplateArgument::NullPtr: |
| // [Note: non-type template arguments do not contribute to the set of |
| // associated namespaces. ] |
| break; |
| |
| case TemplateArgument::Pack: |
| for (const auto &P : Arg.pack_elements()) |
| addAssociatedClassesAndNamespaces(Result, P); |
| break; |
| } |
| } |
| |
| // Add the associated classes and namespaces for argument-dependent lookup |
| // with an argument of class type (C++ [basic.lookup.argdep]p2). |
| static void |
| addAssociatedClassesAndNamespaces(AssociatedLookup &Result, |
| CXXRecordDecl *Class) { |
| |
| // Just silently ignore anything whose name is __va_list_tag. |
| if (Class->getDeclName() == Result.S.VAListTagName) |
| return; |
| |
| // C++ [basic.lookup.argdep]p2: |
| // [...] |
| // -- If T is a class type (including unions), its associated |
| // classes are: the class itself; the class of which it is a |
| // member, if any; and its direct and indirect base classes. |
| // Its associated namespaces are the innermost enclosing |
| // namespaces of its associated classes. |
| |
| // Add the class of which it is a member, if any. |
| DeclContext *Ctx = Class->getDeclContext(); |
| if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx)) |
| Result.Classes.insert(EnclosingClass); |
| |
| // Add the associated namespace for this class. |
| CollectEnclosingNamespace(Result.Namespaces, Ctx); |
| |
| // -- If T is a template-id, its associated namespaces and classes are |
| // the namespace in which the template is defined; for member |
| // templates, the member template's class; the namespaces and classes |
| // associated with the types of the template arguments provided for |
| // template type parameters (excluding template template parameters); the |
| // namespaces in which any template template arguments are defined; and |
| // the classes in which any member templates used as template template |
| // arguments are defined. [Note: non-type template arguments do not |
| // contribute to the set of associated namespaces. ] |
| if (ClassTemplateSpecializationDecl *Spec |
| = dyn_cast<ClassTemplateSpecializationDecl>(Class)) { |
| DeclContext *Ctx = Spec->getSpecializedTemplate()->getDeclContext(); |
| if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx)) |
| Result.Classes.insert(EnclosingClass); |
| // Add the associated namespace for this class. |
| CollectEnclosingNamespace(Result.Namespaces, Ctx); |
| |
| const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); |
| for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) |
| addAssociatedClassesAndNamespaces(Result, TemplateArgs[I]); |
| } |
| |
| // Add the class itself. If we've already transitively visited this class, |
| // we don't need to visit base classes. |
| if (!Result.addClassTransitive(Class)) |
| return; |
| |
| // Only recurse into base classes for complete types. |
| if (!Result.S.isCompleteType(Result.InstantiationLoc, |
| Result.S.Context.getRecordType(Class))) |
| return; |
| |
| // Add direct and indirect base classes along with their associated |
| // namespaces. |
| SmallVector<CXXRecordDecl *, 32> Bases; |
| Bases.push_back(Class); |
| while (!Bases.empty()) { |
| // Pop this class off the stack. |
| Class = Bases.pop_back_val(); |
| |
| // Visit the base classes. |
| for (const auto &Base : Class->bases()) { |
| const RecordType *BaseType = Base.getType()->getAs<RecordType>(); |
| // In dependent contexts, we do ADL twice, and the first time around, |
| // the base type might be a dependent TemplateSpecializationType, or a |
| // TemplateTypeParmType. If that happens, simply ignore it. |
| // FIXME: If we want to support export, we probably need to add the |
| // namespace of the template in a TemplateSpecializationType, or even |
| // the classes and namespaces of known non-dependent arguments. |
| if (!BaseType) |
| continue; |
| CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(BaseType->getDecl()); |
| if (Result.addClassTransitive(BaseDecl)) { |
| // Find the associated namespace for this base class. |
| DeclContext *BaseCtx = BaseDecl->getDeclContext(); |
| CollectEnclosingNamespace(Result.Namespaces, BaseCtx); |
| |
| // Make sure we visit the bases of this base class. |
| if (BaseDecl->bases_begin() != BaseDecl->bases_end()) |
| Bases.push_back(BaseDecl); |
| } |
| } |
| } |
| } |
| |
| // Add the associated classes and namespaces for |
| // argument-dependent lookup with an argument of type T |
| // (C++ [basic.lookup.koenig]p2). |
| static void |
| addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType Ty) { |
| // C++ [basic.lookup.koenig]p2: |
| // |
| // For each argument type T in the function call, there is a set |
| // of zero or more associated namespaces and a set of zero or more |
| // associated classes to be considered. The sets of namespaces and |
| // classes is determined entirely by the types of the function |
| // arguments (and the namespace of any template template |
| // argument). Typedef names and using-declarations used to specify |
| // the types do not contribute to this set. The sets of namespaces |
| // and classes are determined in the following way: |
| |
| SmallVector<const Type *, 16> Queue; |
| const Type *T = Ty->getCanonicalTypeInternal().getTypePtr(); |
| |
| while (true) { |
| switch (T->getTypeClass()) { |
| |
| #define TYPE(Class, Base) |
| #define DEPENDENT_TYPE(Class, Base) case Type::Class: |
| #define NON_CANONICAL_TYPE(Class, Base) case Type::Class: |
| #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: |
| #define ABSTRACT_TYPE(Class, Base) |
| #include "clang/AST/TypeNodes.inc" |
| // T is canonical. We can also ignore dependent types because |
| // we don't need to do ADL at the definition point, but if we |
| // wanted to implement template export (or if we find some other |
| // use for associated classes and namespaces...) this would be |
| // wrong. |
| break; |
| |
| // -- If T is a pointer to U or an array of U, its associated |
| // namespaces and classes are those associated with U. |
| case Type::Pointer: |
| T = cast<PointerType>(T)->getPointeeType().getTypePtr(); |
| continue; |
| case Type::ConstantArray: |
| case Type::IncompleteArray: |
| case Type::VariableArray: |
| T = cast<ArrayType>(T)->getElementType().getTypePtr(); |
| continue; |
| |
| // -- If T is a fundamental type, its associated sets of |
| // namespaces and classes are both empty. |
| case Type::Builtin: |
| break; |
| |
| // -- If T is a class type (including unions), its associated |
| // classes are: the class itself; the class of which it is |
| // a member, if any; and its direct and indirect base classes. |
| // Its associated namespaces are the innermost enclosing |
| // namespaces of its associated classes. |
| case Type::Record: { |
| CXXRecordDecl *Class = |
| cast<CXXRecordDecl>(cast<RecordType>(T)->getDecl()); |
| addAssociatedClassesAndNamespaces(Result, Class); |
| break; |
| } |
| |
| // -- If T is an enumeration type, its associated namespace |
| // is the innermost enclosing namespace of its declaration. |
| // If it is a class member, its associated class is the |
| // member’s class; else it has no associated class. |
| case Type::Enum: { |
| EnumDecl *Enum = cast<EnumType>(T)->getDecl(); |
| |
| DeclContext *Ctx = Enum->getDeclContext(); |
| if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx)) |
| Result.Classes.insert(EnclosingClass); |
| |
| // Add the associated namespace for this enumeration. |
| CollectEnclosingNamespace(Result.Namespaces, Ctx); |
| |
|