• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===--------------------- SemaLookup.cpp - Name Lookup  ------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file implements name lookup for C, C++, Objective-C, and
11 //  Objective-C++.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/Sema/Lookup.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/ASTMutationListener.h"
18 #include "clang/AST/CXXInheritance.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclLookups.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/DeclTemplate.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/ExprCXX.h"
26 #include "clang/Basic/Builtins.h"
27 #include "clang/Basic/LangOptions.h"
28 #include "clang/Lex/HeaderSearch.h"
29 #include "clang/Lex/ModuleLoader.h"
30 #include "clang/Lex/Preprocessor.h"
31 #include "clang/Sema/DeclSpec.h"
32 #include "clang/Sema/Overload.h"
33 #include "clang/Sema/Scope.h"
34 #include "clang/Sema/ScopeInfo.h"
35 #include "clang/Sema/Sema.h"
36 #include "clang/Sema/SemaInternal.h"
37 #include "clang/Sema/TemplateDeduction.h"
38 #include "clang/Sema/TypoCorrection.h"
39 #include "llvm/ADT/STLExtras.h"
40 #include "llvm/ADT/SetVector.h"
41 #include "llvm/ADT/SmallPtrSet.h"
42 #include "llvm/ADT/StringMap.h"
43 #include "llvm/ADT/TinyPtrVector.h"
44 #include "llvm/ADT/edit_distance.h"
45 #include "llvm/Support/ErrorHandling.h"
46 #include <algorithm>
47 #include <iterator>
48 #include <limits>
49 #include <list>
50 #include <map>
51 #include <set>
52 #include <utility>
53 #include <vector>
54 
55 using namespace clang;
56 using namespace sema;
57 
58 namespace {
59   class UnqualUsingEntry {
60     const DeclContext *Nominated;
61     const DeclContext *CommonAncestor;
62 
63   public:
UnqualUsingEntry(const DeclContext * Nominated,const DeclContext * CommonAncestor)64     UnqualUsingEntry(const DeclContext *Nominated,
65                      const DeclContext *CommonAncestor)
66       : Nominated(Nominated), CommonAncestor(CommonAncestor) {
67     }
68 
getCommonAncestor() const69     const DeclContext *getCommonAncestor() const {
70       return CommonAncestor;
71     }
72 
getNominatedNamespace() const73     const DeclContext *getNominatedNamespace() const {
74       return Nominated;
75     }
76 
77     // Sort by the pointer value of the common ancestor.
78     struct Comparator {
operator ()__anon19e32a9a0111::UnqualUsingEntry::Comparator79       bool operator()(const UnqualUsingEntry &L, const UnqualUsingEntry &R) {
80         return L.getCommonAncestor() < R.getCommonAncestor();
81       }
82 
operator ()__anon19e32a9a0111::UnqualUsingEntry::Comparator83       bool operator()(const UnqualUsingEntry &E, const DeclContext *DC) {
84         return E.getCommonAncestor() < DC;
85       }
86 
operator ()__anon19e32a9a0111::UnqualUsingEntry::Comparator87       bool operator()(const DeclContext *DC, const UnqualUsingEntry &E) {
88         return DC < E.getCommonAncestor();
89       }
90     };
91   };
92 
93   /// A collection of using directives, as used by C++ unqualified
94   /// lookup.
95   class UnqualUsingDirectiveSet {
96     typedef SmallVector<UnqualUsingEntry, 8> ListTy;
97 
98     ListTy list;
99     llvm::SmallPtrSet<DeclContext*, 8> visited;
100 
101   public:
UnqualUsingDirectiveSet()102     UnqualUsingDirectiveSet() {}
103 
visitScopeChain(Scope * S,Scope * InnermostFileScope)104     void visitScopeChain(Scope *S, Scope *InnermostFileScope) {
105       // C++ [namespace.udir]p1:
106       //   During unqualified name lookup, the names appear as if they
107       //   were declared in the nearest enclosing namespace which contains
108       //   both the using-directive and the nominated namespace.
109       DeclContext *InnermostFileDC = InnermostFileScope->getEntity();
110       assert(InnermostFileDC && InnermostFileDC->isFileContext());
111 
112       for (; S; S = S->getParent()) {
113         // C++ [namespace.udir]p1:
114         //   A using-directive shall not appear in class scope, but may
115         //   appear in namespace scope or in block scope.
116         DeclContext *Ctx = S->getEntity();
117         if (Ctx && Ctx->isFileContext()) {
118           visit(Ctx, Ctx);
119         } else if (!Ctx || Ctx->isFunctionOrMethod()) {
120           for (auto *I : S->using_directives())
121             visit(I, InnermostFileDC);
122         }
123       }
124     }
125 
126     // Visits a context and collect all of its using directives
127     // recursively.  Treats all using directives as if they were
128     // declared in the context.
129     //
130     // A given context is only every visited once, so it is important
131     // that contexts be visited from the inside out in order to get
132     // the effective DCs right.
visit(DeclContext * DC,DeclContext * EffectiveDC)133     void visit(DeclContext *DC, DeclContext *EffectiveDC) {
134       if (!visited.insert(DC).second)
135         return;
136 
137       addUsingDirectives(DC, EffectiveDC);
138     }
139 
140     // Visits a using directive and collects all of its using
141     // directives recursively.  Treats all using directives as if they
142     // were declared in the effective DC.
visit(UsingDirectiveDecl * UD,DeclContext * EffectiveDC)143     void visit(UsingDirectiveDecl *UD, DeclContext *EffectiveDC) {
144       DeclContext *NS = UD->getNominatedNamespace();
145       if (!visited.insert(NS).second)
146         return;
147 
148       addUsingDirective(UD, EffectiveDC);
149       addUsingDirectives(NS, EffectiveDC);
150     }
151 
152     // Adds all the using directives in a context (and those nominated
153     // by its using directives, transitively) as if they appeared in
154     // the given effective context.
addUsingDirectives(DeclContext * DC,DeclContext * EffectiveDC)155     void addUsingDirectives(DeclContext *DC, DeclContext *EffectiveDC) {
156       SmallVector<DeclContext*, 4> queue;
157       while (true) {
158         for (auto UD : DC->using_directives()) {
159           DeclContext *NS = UD->getNominatedNamespace();
160           if (visited.insert(NS).second) {
161             addUsingDirective(UD, EffectiveDC);
162             queue.push_back(NS);
163           }
164         }
165 
166         if (queue.empty())
167           return;
168 
169         DC = queue.pop_back_val();
170       }
171     }
172 
173     // Add a using directive as if it had been declared in the given
174     // context.  This helps implement C++ [namespace.udir]p3:
175     //   The using-directive is transitive: if a scope contains a
176     //   using-directive that nominates a second namespace that itself
177     //   contains using-directives, the effect is as if the
178     //   using-directives from the second namespace also appeared in
179     //   the first.
addUsingDirective(UsingDirectiveDecl * UD,DeclContext * EffectiveDC)180     void addUsingDirective(UsingDirectiveDecl *UD, DeclContext *EffectiveDC) {
181       // Find the common ancestor between the effective context and
182       // the nominated namespace.
183       DeclContext *Common = UD->getNominatedNamespace();
184       while (!Common->Encloses(EffectiveDC))
185         Common = Common->getParent();
186       Common = Common->getPrimaryContext();
187 
188       list.push_back(UnqualUsingEntry(UD->getNominatedNamespace(), Common));
189     }
190 
done()191     void done() {
192       std::sort(list.begin(), list.end(), UnqualUsingEntry::Comparator());
193     }
194 
195     typedef ListTy::const_iterator const_iterator;
196 
begin() const197     const_iterator begin() const { return list.begin(); }
end() const198     const_iterator end() const { return list.end(); }
199 
200     llvm::iterator_range<const_iterator>
getNamespacesFor(DeclContext * DC) const201     getNamespacesFor(DeclContext *DC) const {
202       return llvm::make_range(std::equal_range(begin(), end(),
203                                                DC->getPrimaryContext(),
204                                                UnqualUsingEntry::Comparator()));
205     }
206   };
207 } // end anonymous namespace
208 
209 // Retrieve the set of identifier namespaces that correspond to a
210 // specific kind of name lookup.
getIDNS(Sema::LookupNameKind NameKind,bool CPlusPlus,bool Redeclaration)211 static inline unsigned getIDNS(Sema::LookupNameKind NameKind,
212                                bool CPlusPlus,
213                                bool Redeclaration) {
214   unsigned IDNS = 0;
215   switch (NameKind) {
216   case Sema::LookupObjCImplicitSelfParam:
217   case Sema::LookupOrdinaryName:
218   case Sema::LookupRedeclarationWithLinkage:
219   case Sema::LookupLocalFriendName:
220     IDNS = Decl::IDNS_Ordinary;
221     if (CPlusPlus) {
222       IDNS |= Decl::IDNS_Tag | Decl::IDNS_Member | Decl::IDNS_Namespace;
223       if (Redeclaration)
224         IDNS |= Decl::IDNS_TagFriend | Decl::IDNS_OrdinaryFriend;
225     }
226     if (Redeclaration)
227       IDNS |= Decl::IDNS_LocalExtern;
228     break;
229 
230   case Sema::LookupOperatorName:
231     // Operator lookup is its own crazy thing;  it is not the same
232     // as (e.g.) looking up an operator name for redeclaration.
233     assert(!Redeclaration && "cannot do redeclaration operator lookup");
234     IDNS = Decl::IDNS_NonMemberOperator;
235     break;
236 
237   case Sema::LookupTagName:
238     if (CPlusPlus) {
239       IDNS = Decl::IDNS_Type;
240 
241       // When looking for a redeclaration of a tag name, we add:
242       // 1) TagFriend to find undeclared friend decls
243       // 2) Namespace because they can't "overload" with tag decls.
244       // 3) Tag because it includes class templates, which can't
245       //    "overload" with tag decls.
246       if (Redeclaration)
247         IDNS |= Decl::IDNS_Tag | Decl::IDNS_TagFriend | Decl::IDNS_Namespace;
248     } else {
249       IDNS = Decl::IDNS_Tag;
250     }
251     break;
252 
253   case Sema::LookupLabel:
254     IDNS = Decl::IDNS_Label;
255     break;
256 
257   case Sema::LookupMemberName:
258     IDNS = Decl::IDNS_Member;
259     if (CPlusPlus)
260       IDNS |= Decl::IDNS_Tag | Decl::IDNS_Ordinary;
261     break;
262 
263   case Sema::LookupNestedNameSpecifierName:
264     IDNS = Decl::IDNS_Type | Decl::IDNS_Namespace;
265     break;
266 
267   case Sema::LookupNamespaceName:
268     IDNS = Decl::IDNS_Namespace;
269     break;
270 
271   case Sema::LookupUsingDeclName:
272     assert(Redeclaration && "should only be used for redecl lookup");
273     IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Member |
274            Decl::IDNS_Using | Decl::IDNS_TagFriend | Decl::IDNS_OrdinaryFriend |
275            Decl::IDNS_LocalExtern;
276     break;
277 
278   case Sema::LookupObjCProtocolName:
279     IDNS = Decl::IDNS_ObjCProtocol;
280     break;
281 
282   case Sema::LookupOMPReductionName:
283     IDNS = Decl::IDNS_OMPReduction;
284     break;
285 
286   case Sema::LookupAnyName:
287     IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Member
288       | Decl::IDNS_Using | Decl::IDNS_Namespace | Decl::IDNS_ObjCProtocol
289       | Decl::IDNS_Type;
290     break;
291   }
292   return IDNS;
293 }
294 
configure()295 void LookupResult::configure() {
296   IDNS = getIDNS(LookupKind, getSema().getLangOpts().CPlusPlus,
297                  isForRedeclaration());
298 
299   // If we're looking for one of the allocation or deallocation
300   // operators, make sure that the implicitly-declared new and delete
301   // operators can be found.
302   switch (NameInfo.getName().getCXXOverloadedOperator()) {
303   case OO_New:
304   case OO_Delete:
305   case OO_Array_New:
306   case OO_Array_Delete:
307     getSema().DeclareGlobalNewDelete();
308     break;
309 
310   default:
311     break;
312   }
313 
314   // Compiler builtins are always visible, regardless of where they end
315   // up being declared.
316   if (IdentifierInfo *Id = NameInfo.getName().getAsIdentifierInfo()) {
317     if (unsigned BuiltinID = Id->getBuiltinID()) {
318       if (!getSema().Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
319         AllowHidden = true;
320     }
321   }
322 }
323 
sanity() const324 bool LookupResult::sanity() const {
325   // This function is never called by NDEBUG builds.
326   assert(ResultKind != NotFound || Decls.size() == 0);
327   assert(ResultKind != Found || Decls.size() == 1);
328   assert(ResultKind != FoundOverloaded || Decls.size() > 1 ||
329          (Decls.size() == 1 &&
330           isa<FunctionTemplateDecl>((*begin())->getUnderlyingDecl())));
331   assert(ResultKind != FoundUnresolvedValue || sanityCheckUnresolved());
332   assert(ResultKind != Ambiguous || Decls.size() > 1 ||
333          (Decls.size() == 1 && (Ambiguity == AmbiguousBaseSubobjects ||
334                                 Ambiguity == AmbiguousBaseSubobjectTypes)));
335   assert((Paths != nullptr) == (ResultKind == Ambiguous &&
336                                 (Ambiguity == AmbiguousBaseSubobjectTypes ||
337                                  Ambiguity == AmbiguousBaseSubobjects)));
338   return true;
339 }
340 
341 // Necessary because CXXBasePaths is not complete in Sema.h
deletePaths(CXXBasePaths * Paths)342 void LookupResult::deletePaths(CXXBasePaths *Paths) {
343   delete Paths;
344 }
345 
346 /// Get a representative context for a declaration such that two declarations
347 /// will have the same context if they were found within the same scope.
getContextForScopeMatching(Decl * D)348 static DeclContext *getContextForScopeMatching(Decl *D) {
349   // For function-local declarations, use that function as the context. This
350   // doesn't account for scopes within the function; the caller must deal with
351   // those.
352   DeclContext *DC = D->getLexicalDeclContext();
353   if (DC->isFunctionOrMethod())
354     return DC;
355 
356   // Otherwise, look at the semantic context of the declaration. The
357   // declaration must have been found there.
358   return D->getDeclContext()->getRedeclContext();
359 }
360 
361 /// \brief Determine whether \p D is a better lookup result than \p Existing,
362 /// given that they declare the same entity.
isPreferredLookupResult(Sema & S,Sema::LookupNameKind Kind,NamedDecl * D,NamedDecl * Existing)363 static bool isPreferredLookupResult(Sema &S, Sema::LookupNameKind Kind,
364                                     NamedDecl *D, NamedDecl *Existing) {
365   // When looking up redeclarations of a using declaration, prefer a using
366   // shadow declaration over any other declaration of the same entity.
367   if (Kind == Sema::LookupUsingDeclName && isa<UsingShadowDecl>(D) &&
368       !isa<UsingShadowDecl>(Existing))
369     return true;
370 
371   auto *DUnderlying = D->getUnderlyingDecl();
372   auto *EUnderlying = Existing->getUnderlyingDecl();
373 
374   // If they have different underlying declarations, prefer a typedef over the
375   // original type (this happens when two type declarations denote the same
376   // type), per a generous reading of C++ [dcl.typedef]p3 and p4. The typedef
377   // might carry additional semantic information, such as an alignment override.
378   // However, per C++ [dcl.typedef]p5, when looking up a tag name, prefer a tag
379   // declaration over a typedef.
380   if (DUnderlying->getCanonicalDecl() != EUnderlying->getCanonicalDecl()) {
381     assert(isa<TypeDecl>(DUnderlying) && isa<TypeDecl>(EUnderlying));
382     bool HaveTag = isa<TagDecl>(EUnderlying);
383     bool WantTag = Kind == Sema::LookupTagName;
384     return HaveTag != WantTag;
385   }
386 
387   // Pick the function with more default arguments.
388   // FIXME: In the presence of ambiguous default arguments, we should keep both,
389   //        so we can diagnose the ambiguity if the default argument is needed.
390   //        See C++ [over.match.best]p3.
391   if (auto *DFD = dyn_cast<FunctionDecl>(DUnderlying)) {
392     auto *EFD = cast<FunctionDecl>(EUnderlying);
393     unsigned DMin = DFD->getMinRequiredArguments();
394     unsigned EMin = EFD->getMinRequiredArguments();
395     // If D has more default arguments, it is preferred.
396     if (DMin != EMin)
397       return DMin < EMin;
398     // FIXME: When we track visibility for default function arguments, check
399     // that we pick the declaration with more visible default arguments.
400   }
401 
402   // Pick the template with more default template arguments.
403   if (auto *DTD = dyn_cast<TemplateDecl>(DUnderlying)) {
404     auto *ETD = cast<TemplateDecl>(EUnderlying);
405     unsigned DMin = DTD->getTemplateParameters()->getMinRequiredArguments();
406     unsigned EMin = ETD->getTemplateParameters()->getMinRequiredArguments();
407     // If D has more default arguments, it is preferred. Note that default
408     // arguments (and their visibility) is monotonically increasing across the
409     // redeclaration chain, so this is a quick proxy for "is more recent".
410     if (DMin != EMin)
411       return DMin < EMin;
412     // If D has more *visible* default arguments, it is preferred. Note, an
413     // earlier default argument being visible does not imply that a later
414     // default argument is visible, so we can't just check the first one.
415     for (unsigned I = DMin, N = DTD->getTemplateParameters()->size();
416         I != N; ++I) {
417       if (!S.hasVisibleDefaultArgument(
418               ETD->getTemplateParameters()->getParam(I)) &&
419           S.hasVisibleDefaultArgument(
420               DTD->getTemplateParameters()->getParam(I)))
421         return true;
422     }
423   }
424 
425   // VarDecl can have incomplete array types, prefer the one with more complete
426   // array type.
427   if (VarDecl *DVD = dyn_cast<VarDecl>(DUnderlying)) {
428     VarDecl *EVD = cast<VarDecl>(EUnderlying);
429     if (EVD->getType()->isIncompleteType() &&
430         !DVD->getType()->isIncompleteType()) {
431       // Prefer the decl with a more complete type if visible.
432       return S.isVisible(DVD);
433     }
434     return false; // Avoid picking up a newer decl, just because it was newer.
435   }
436 
437   // For most kinds of declaration, it doesn't really matter which one we pick.
438   if (!isa<FunctionDecl>(DUnderlying) && !isa<VarDecl>(DUnderlying)) {
439     // If the existing declaration is hidden, prefer the new one. Otherwise,
440     // keep what we've got.
441     return !S.isVisible(Existing);
442   }
443 
444   // Pick the newer declaration; it might have a more precise type.
445   for (Decl *Prev = DUnderlying->getPreviousDecl(); Prev;
446        Prev = Prev->getPreviousDecl())
447     if (Prev == EUnderlying)
448       return true;
449   return false;
450 }
451 
452 /// Determine whether \p D can hide a tag declaration.
canHideTag(NamedDecl * D)453 static bool canHideTag(NamedDecl *D) {
454   // C++ [basic.scope.declarative]p4:
455   //   Given a set of declarations in a single declarative region [...]
456   //   exactly one declaration shall declare a class name or enumeration name
457   //   that is not a typedef name and the other declarations shall all refer to
458   //   the same variable or enumerator, or all refer to functions and function
459   //   templates; in this case the class name or enumeration name is hidden.
460   // C++ [basic.scope.hiding]p2:
461   //   A class name or enumeration name can be hidden by the name of a
462   //   variable, data member, function, or enumerator declared in the same
463   //   scope.
464   D = D->getUnderlyingDecl();
465   return isa<VarDecl>(D) || isa<EnumConstantDecl>(D) || isa<FunctionDecl>(D) ||
466          isa<FunctionTemplateDecl>(D) || isa<FieldDecl>(D);
467 }
468 
469 /// Resolves the result kind of this lookup.
resolveKind()470 void LookupResult::resolveKind() {
471   unsigned N = Decls.size();
472 
473   // Fast case: no possible ambiguity.
474   if (N == 0) {
475     assert(ResultKind == NotFound ||
476            ResultKind == NotFoundInCurrentInstantiation);
477     return;
478   }
479 
480   // If there's a single decl, we need to examine it to decide what
481   // kind of lookup this is.
482   if (N == 1) {
483     NamedDecl *D = (*Decls.begin())->getUnderlyingDecl();
484     if (isa<FunctionTemplateDecl>(D))
485       ResultKind = FoundOverloaded;
486     else if (isa<UnresolvedUsingValueDecl>(D))
487       ResultKind = FoundUnresolvedValue;
488     return;
489   }
490 
491   // Don't do any extra resolution if we've already resolved as ambiguous.
492   if (ResultKind == Ambiguous) return;
493 
494   llvm::SmallDenseMap<NamedDecl*, unsigned, 16> Unique;
495   llvm::SmallDenseMap<QualType, unsigned, 16> UniqueTypes;
496 
497   bool Ambiguous = false;
498   bool HasTag = false, HasFunction = false;
499   bool HasFunctionTemplate = false, HasUnresolved = false;
500   NamedDecl *HasNonFunction = nullptr;
501 
502   llvm::SmallVector<NamedDecl*, 4> EquivalentNonFunctions;
503 
504   unsigned UniqueTagIndex = 0;
505 
506   unsigned I = 0;
507   while (I < N) {
508     NamedDecl *D = Decls[I]->getUnderlyingDecl();
509     D = cast<NamedDecl>(D->getCanonicalDecl());
510 
511     // Ignore an invalid declaration unless it's the only one left.
512     if (D->isInvalidDecl() && !(I == 0 && N == 1)) {
513       Decls[I] = Decls[--N];
514       continue;
515     }
516 
517     llvm::Optional<unsigned> ExistingI;
518 
519     // Redeclarations of types via typedef can occur both within a scope
520     // and, through using declarations and directives, across scopes. There is
521     // no ambiguity if they all refer to the same type, so unique based on the
522     // canonical type.
523     if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
524       QualType T = getSema().Context.getTypeDeclType(TD);
525       auto UniqueResult = UniqueTypes.insert(
526           std::make_pair(getSema().Context.getCanonicalType(T), I));
527       if (!UniqueResult.second) {
528         // The type is not unique.
529         ExistingI = UniqueResult.first->second;
530       }
531     }
532 
533     // For non-type declarations, check for a prior lookup result naming this
534     // canonical declaration.
535     if (!ExistingI) {
536       auto UniqueResult = Unique.insert(std::make_pair(D, I));
537       if (!UniqueResult.second) {
538         // We've seen this entity before.
539         ExistingI = UniqueResult.first->second;
540       }
541     }
542 
543     if (ExistingI) {
544       // This is not a unique lookup result. Pick one of the results and
545       // discard the other.
546       if (isPreferredLookupResult(getSema(), getLookupKind(), Decls[I],
547                                   Decls[*ExistingI]))
548         Decls[*ExistingI] = Decls[I];
549       Decls[I] = Decls[--N];
550       continue;
551     }
552 
553     // Otherwise, do some decl type analysis and then continue.
554 
555     if (isa<UnresolvedUsingValueDecl>(D)) {
556       HasUnresolved = true;
557     } else if (isa<TagDecl>(D)) {
558       if (HasTag)
559         Ambiguous = true;
560       UniqueTagIndex = I;
561       HasTag = true;
562     } else if (isa<FunctionTemplateDecl>(D)) {
563       HasFunction = true;
564       HasFunctionTemplate = true;
565     } else if (isa<FunctionDecl>(D)) {
566       HasFunction = true;
567     } else {
568       if (HasNonFunction) {
569         // If we're about to create an ambiguity between two declarations that
570         // are equivalent, but one is an internal linkage declaration from one
571         // module and the other is an internal linkage declaration from another
572         // module, just skip it.
573         if (getSema().isEquivalentInternalLinkageDeclaration(HasNonFunction,
574                                                              D)) {
575           EquivalentNonFunctions.push_back(D);
576           Decls[I] = Decls[--N];
577           continue;
578         }
579 
580         Ambiguous = true;
581       }
582       HasNonFunction = D;
583     }
584     I++;
585   }
586 
587   // C++ [basic.scope.hiding]p2:
588   //   A class name or enumeration name can be hidden by the name of
589   //   an object, function, or enumerator declared in the same
590   //   scope. If a class or enumeration name and an object, function,
591   //   or enumerator are declared in the same scope (in any order)
592   //   with the same name, the class or enumeration name is hidden
593   //   wherever the object, function, or enumerator name is visible.
594   // But it's still an error if there are distinct tag types found,
595   // even if they're not visible. (ref?)
596   if (N > 1 && HideTags && HasTag && !Ambiguous &&
597       (HasFunction || HasNonFunction || HasUnresolved)) {
598     NamedDecl *OtherDecl = Decls[UniqueTagIndex ? 0 : N - 1];
599     if (isa<TagDecl>(Decls[UniqueTagIndex]->getUnderlyingDecl()) &&
600         getContextForScopeMatching(Decls[UniqueTagIndex])->Equals(
601             getContextForScopeMatching(OtherDecl)) &&
602         canHideTag(OtherDecl))
603       Decls[UniqueTagIndex] = Decls[--N];
604     else
605       Ambiguous = true;
606   }
607 
608   // FIXME: This diagnostic should really be delayed until we're done with
609   // the lookup result, in case the ambiguity is resolved by the caller.
610   if (!EquivalentNonFunctions.empty() && !Ambiguous)
611     getSema().diagnoseEquivalentInternalLinkageDeclarations(
612         getNameLoc(), HasNonFunction, EquivalentNonFunctions);
613 
614   Decls.set_size(N);
615 
616   if (HasNonFunction && (HasFunction || HasUnresolved))
617     Ambiguous = true;
618 
619   if (Ambiguous)
620     setAmbiguous(LookupResult::AmbiguousReference);
621   else if (HasUnresolved)
622     ResultKind = LookupResult::FoundUnresolvedValue;
623   else if (N > 1 || HasFunctionTemplate)
624     ResultKind = LookupResult::FoundOverloaded;
625   else
626     ResultKind = LookupResult::Found;
627 }
628 
addDeclsFromBasePaths(const CXXBasePaths & P)629 void LookupResult::addDeclsFromBasePaths(const CXXBasePaths &P) {
630   CXXBasePaths::const_paths_iterator I, E;
631   for (I = P.begin(), E = P.end(); I != E; ++I)
632     for (DeclContext::lookup_iterator DI = I->Decls.begin(),
633          DE = I->Decls.end(); DI != DE; ++DI)
634       addDecl(*DI);
635 }
636 
setAmbiguousBaseSubobjects(CXXBasePaths & P)637 void LookupResult::setAmbiguousBaseSubobjects(CXXBasePaths &P) {
638   Paths = new CXXBasePaths;
639   Paths->swap(P);
640   addDeclsFromBasePaths(*Paths);
641   resolveKind();
642   setAmbiguous(AmbiguousBaseSubobjects);
643 }
644 
setAmbiguousBaseSubobjectTypes(CXXBasePaths & P)645 void LookupResult::setAmbiguousBaseSubobjectTypes(CXXBasePaths &P) {
646   Paths = new CXXBasePaths;
647   Paths->swap(P);
648   addDeclsFromBasePaths(*Paths);
649   resolveKind();
650   setAmbiguous(AmbiguousBaseSubobjectTypes);
651 }
652 
print(raw_ostream & Out)653 void LookupResult::print(raw_ostream &Out) {
654   Out << Decls.size() << " result(s)";
655   if (isAmbiguous()) Out << ", ambiguous";
656   if (Paths) Out << ", base paths present";
657 
658   for (iterator I = begin(), E = end(); I != E; ++I) {
659     Out << "\n";
660     (*I)->print(Out, 2);
661   }
662 }
663 
dump()664 LLVM_DUMP_METHOD void LookupResult::dump() {
665   llvm::errs() << "lookup results for " << getLookupName().getAsString()
666                << ":\n";
667   for (NamedDecl *D : *this)
668     D->dump();
669 }
670 
671 /// \brief Lookup a builtin function, when name lookup would otherwise
672 /// fail.
LookupBuiltin(Sema & S,LookupResult & R)673 static bool LookupBuiltin(Sema &S, LookupResult &R) {
674   Sema::LookupNameKind NameKind = R.getLookupKind();
675 
676   // If we didn't find a use of this identifier, and if the identifier
677   // corresponds to a compiler builtin, create the decl object for the builtin
678   // now, injecting it into translation unit scope, and return it.
679   if (NameKind == Sema::LookupOrdinaryName ||
680       NameKind == Sema::LookupRedeclarationWithLinkage) {
681     IdentifierInfo *II = R.getLookupName().getAsIdentifierInfo();
682     if (II) {
683       if (S.getLangOpts().CPlusPlus && NameKind == Sema::LookupOrdinaryName) {
684         if (II == S.getASTContext().getMakeIntegerSeqName()) {
685           R.addDecl(S.getASTContext().getMakeIntegerSeqDecl());
686           return true;
687         } else if (II == S.getASTContext().getTypePackElementName()) {
688           R.addDecl(S.getASTContext().getTypePackElementDecl());
689           return true;
690         }
691       }
692 
693       // If this is a builtin on this (or all) targets, create the decl.
694       if (unsigned BuiltinID = II->getBuiltinID()) {
695         // In C++ and OpenCL (spec v1.2 s6.9.f), we don't have any predefined
696         // library functions like 'malloc'. Instead, we'll just error.
697         if ((S.getLangOpts().CPlusPlus || S.getLangOpts().OpenCL) &&
698             S.Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
699           return false;
700 
701         if (NamedDecl *D = S.LazilyCreateBuiltin((IdentifierInfo *)II,
702                                                  BuiltinID, S.TUScope,
703                                                  R.isForRedeclaration(),
704                                                  R.getNameLoc())) {
705           R.addDecl(D);
706           return true;
707         }
708       }
709     }
710   }
711 
712   return false;
713 }
714 
715 /// \brief Determine whether we can declare a special member function within
716 /// the class at this point.
CanDeclareSpecialMemberFunction(const CXXRecordDecl * Class)717 static bool CanDeclareSpecialMemberFunction(const CXXRecordDecl *Class) {
718   // We need to have a definition for the class.
719   if (!Class->getDefinition() || Class->isDependentContext())
720     return false;
721 
722   // We can't be in the middle of defining the class.
723   return !Class->isBeingDefined();
724 }
725 
ForceDeclarationOfImplicitMembers(CXXRecordDecl * Class)726 void Sema::ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class) {
727   if (!CanDeclareSpecialMemberFunction(Class))
728     return;
729 
730   // If the default constructor has not yet been declared, do so now.
731   if (Class->needsImplicitDefaultConstructor())
732     DeclareImplicitDefaultConstructor(Class);
733 
734   // If the copy constructor has not yet been declared, do so now.
735   if (Class->needsImplicitCopyConstructor())
736     DeclareImplicitCopyConstructor(Class);
737 
738   // If the copy assignment operator has not yet been declared, do so now.
739   if (Class->needsImplicitCopyAssignment())
740     DeclareImplicitCopyAssignment(Class);
741 
742   if (getLangOpts().CPlusPlus11) {
743     // If the move constructor has not yet been declared, do so now.
744     if (Class->needsImplicitMoveConstructor())
745       DeclareImplicitMoveConstructor(Class);
746 
747     // If the move assignment operator has not yet been declared, do so now.
748     if (Class->needsImplicitMoveAssignment())
749       DeclareImplicitMoveAssignment(Class);
750   }
751 
752   // If the destructor has not yet been declared, do so now.
753   if (Class->needsImplicitDestructor())
754     DeclareImplicitDestructor(Class);
755 }
756 
757 /// \brief Determine whether this is the name of an implicitly-declared
758 /// special member function.
isImplicitlyDeclaredMemberFunctionName(DeclarationName Name)759 static bool isImplicitlyDeclaredMemberFunctionName(DeclarationName Name) {
760   switch (Name.getNameKind()) {
761   case DeclarationName::CXXConstructorName:
762   case DeclarationName::CXXDestructorName:
763     return true;
764 
765   case DeclarationName::CXXOperatorName:
766     return Name.getCXXOverloadedOperator() == OO_Equal;
767 
768   default:
769     break;
770   }
771 
772   return false;
773 }
774 
775 /// \brief If there are any implicit member functions with the given name
776 /// that need to be declared in the given declaration context, do so.
DeclareImplicitMemberFunctionsWithName(Sema & S,DeclarationName Name,const DeclContext * DC)777 static void DeclareImplicitMemberFunctionsWithName(Sema &S,
778                                                    DeclarationName Name,
779                                                    const DeclContext *DC) {
780   if (!DC)
781     return;
782 
783   switch (Name.getNameKind()) {
784   case DeclarationName::CXXConstructorName:
785     if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC))
786       if (Record->getDefinition() && CanDeclareSpecialMemberFunction(Record)) {
787         CXXRecordDecl *Class = const_cast<CXXRecordDecl *>(Record);
788         if (Record->needsImplicitDefaultConstructor())
789           S.DeclareImplicitDefaultConstructor(Class);
790         if (Record->needsImplicitCopyConstructor())
791           S.DeclareImplicitCopyConstructor(Class);
792         if (S.getLangOpts().CPlusPlus11 &&
793             Record->needsImplicitMoveConstructor())
794           S.DeclareImplicitMoveConstructor(Class);
795       }
796     break;
797 
798   case DeclarationName::CXXDestructorName:
799     if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC))
800       if (Record->getDefinition() && Record->needsImplicitDestructor() &&
801           CanDeclareSpecialMemberFunction(Record))
802         S.DeclareImplicitDestructor(const_cast<CXXRecordDecl *>(Record));
803     break;
804 
805   case DeclarationName::CXXOperatorName:
806     if (Name.getCXXOverloadedOperator() != OO_Equal)
807       break;
808 
809     if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) {
810       if (Record->getDefinition() && CanDeclareSpecialMemberFunction(Record)) {
811         CXXRecordDecl *Class = const_cast<CXXRecordDecl *>(Record);
812         if (Record->needsImplicitCopyAssignment())
813           S.DeclareImplicitCopyAssignment(Class);
814         if (S.getLangOpts().CPlusPlus11 &&
815             Record->needsImplicitMoveAssignment())
816           S.DeclareImplicitMoveAssignment(Class);
817       }
818     }
819     break;
820 
821   default:
822     break;
823   }
824 }
825 
826 // Adds all qualifying matches for a name within a decl context to the
827 // given lookup result.  Returns true if any matches were found.
LookupDirect(Sema & S,LookupResult & R,const DeclContext * DC)828 static bool LookupDirect(Sema &S, LookupResult &R, const DeclContext *DC) {
829   bool Found = false;
830 
831   // Lazily declare C++ special member functions.
832   if (S.getLangOpts().CPlusPlus)
833     DeclareImplicitMemberFunctionsWithName(S, R.getLookupName(), DC);
834 
835   // Perform lookup into this declaration context.
836   DeclContext::lookup_result DR = DC->lookup(R.getLookupName());
837   for (DeclContext::lookup_iterator I = DR.begin(), E = DR.end(); I != E;
838        ++I) {
839     NamedDecl *D = *I;
840     if ((D = R.getAcceptableDecl(D))) {
841       R.addDecl(D);
842       Found = true;
843     }
844   }
845 
846   if (!Found && DC->isTranslationUnit() && LookupBuiltin(S, R))
847     return true;
848 
849   if (R.getLookupName().getNameKind()
850         != DeclarationName::CXXConversionFunctionName ||
851       R.getLookupName().getCXXNameType()->isDependentType() ||
852       !isa<CXXRecordDecl>(DC))
853     return Found;
854 
855   // C++ [temp.mem]p6:
856   //   A specialization of a conversion function template is not found by
857   //   name lookup. Instead, any conversion function templates visible in the
858   //   context of the use are considered. [...]
859   const CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
860   if (!Record->isCompleteDefinition())
861     return Found;
862 
863   for (CXXRecordDecl::conversion_iterator U = Record->conversion_begin(),
864          UEnd = Record->conversion_end(); U != UEnd; ++U) {
865     FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(*U);
866     if (!ConvTemplate)
867       continue;
868 
869     // When we're performing lookup for the purposes of redeclaration, just
870     // add the conversion function template. When we deduce template
871     // arguments for specializations, we'll end up unifying the return
872     // type of the new declaration with the type of the function template.
873     if (R.isForRedeclaration()) {
874       R.addDecl(ConvTemplate);
875       Found = true;
876       continue;
877     }
878 
879     // C++ [temp.mem]p6:
880     //   [...] For each such operator, if argument deduction succeeds
881     //   (14.9.2.3), the resulting specialization is used as if found by
882     //   name lookup.
883     //
884     // When referencing a conversion function for any purpose other than
885     // a redeclaration (such that we'll be building an expression with the
886     // result), perform template argument deduction and place the
887     // specialization into the result set. We do this to avoid forcing all
888     // callers to perform special deduction for conversion functions.
889     TemplateDeductionInfo Info(R.getNameLoc());
890     FunctionDecl *Specialization = nullptr;
891 
892     const FunctionProtoType *ConvProto
893       = ConvTemplate->getTemplatedDecl()->getType()->getAs<FunctionProtoType>();
894     assert(ConvProto && "Nonsensical conversion function template type");
895 
896     // Compute the type of the function that we would expect the conversion
897     // function to have, if it were to match the name given.
898     // FIXME: Calling convention!
899     FunctionProtoType::ExtProtoInfo EPI = ConvProto->getExtProtoInfo();
900     EPI.ExtInfo = EPI.ExtInfo.withCallingConv(CC_C);
901     EPI.ExceptionSpec = EST_None;
902     QualType ExpectedType
903       = R.getSema().Context.getFunctionType(R.getLookupName().getCXXNameType(),
904                                             None, EPI);
905 
906     // Perform template argument deduction against the type that we would
907     // expect the function to have.
908     if (R.getSema().DeduceTemplateArguments(ConvTemplate, nullptr, ExpectedType,
909                                             Specialization, Info)
910           == Sema::TDK_Success) {
911       R.addDecl(Specialization);
912       Found = true;
913     }
914   }
915 
916   return Found;
917 }
918 
919 // Performs C++ unqualified lookup into the given file context.
920 static bool
CppNamespaceLookup(Sema & S,LookupResult & R,ASTContext & Context,DeclContext * NS,UnqualUsingDirectiveSet & UDirs)921 CppNamespaceLookup(Sema &S, LookupResult &R, ASTContext &Context,
922                    DeclContext *NS, UnqualUsingDirectiveSet &UDirs) {
923 
924   assert(NS && NS->isFileContext() && "CppNamespaceLookup() requires namespace!");
925 
926   // Perform direct name lookup into the LookupCtx.
927   bool Found = LookupDirect(S, R, NS);
928 
929   // Perform direct name lookup into the namespaces nominated by the
930   // using directives whose common ancestor is this namespace.
931   for (const UnqualUsingEntry &UUE : UDirs.getNamespacesFor(NS))
932     if (LookupDirect(S, R, UUE.getNominatedNamespace()))
933       Found = true;
934 
935   R.resolveKind();
936 
937   return Found;
938 }
939 
isNamespaceOrTranslationUnitScope(Scope * S)940 static bool isNamespaceOrTranslationUnitScope(Scope *S) {
941   if (DeclContext *Ctx = S->getEntity())
942     return Ctx->isFileContext();
943   return false;
944 }
945 
946 // Find the next outer declaration context from this scope. This
947 // routine actually returns the semantic outer context, which may
948 // differ from the lexical context (encoded directly in the Scope
949 // stack) when we are parsing a member of a class template. In this
950 // case, the second element of the pair will be true, to indicate that
951 // name lookup should continue searching in this semantic context when
952 // it leaves the current template parameter scope.
findOuterContext(Scope * S)953 static std::pair<DeclContext *, bool> findOuterContext(Scope *S) {
954   DeclContext *DC = S->getEntity();
955   DeclContext *Lexical = nullptr;
956   for (Scope *OuterS = S->getParent(); OuterS;
957        OuterS = OuterS->getParent()) {
958     if (OuterS->getEntity()) {
959       Lexical = OuterS->getEntity();
960       break;
961     }
962   }
963 
964   // C++ [temp.local]p8:
965   //   In the definition of a member of a class template that appears
966   //   outside of the namespace containing the class template
967   //   definition, the name of a template-parameter hides the name of
968   //   a member of this namespace.
969   //
970   // Example:
971   //
972   //   namespace N {
973   //     class C { };
974   //
975   //     template<class T> class B {
976   //       void f(T);
977   //     };
978   //   }
979   //
980   //   template<class C> void N::B<C>::f(C) {
981   //     C b;  // C is the template parameter, not N::C
982   //   }
983   //
984   // In this example, the lexical context we return is the
985   // TranslationUnit, while the semantic context is the namespace N.
986   if (!Lexical || !DC || !S->getParent() ||
987       !S->getParent()->isTemplateParamScope())
988     return std::make_pair(Lexical, false);
989 
990   // Find the outermost template parameter scope.
991   // For the example, this is the scope for the template parameters of
992   // template<class C>.
993   Scope *OutermostTemplateScope = S->getParent();
994   while (OutermostTemplateScope->getParent() &&
995          OutermostTemplateScope->getParent()->isTemplateParamScope())
996     OutermostTemplateScope = OutermostTemplateScope->getParent();
997 
998   // Find the namespace context in which the original scope occurs. In
999   // the example, this is namespace N.
1000   DeclContext *Semantic = DC;
1001   while (!Semantic->isFileContext())
1002     Semantic = Semantic->getParent();
1003 
1004   // Find the declaration context just outside of the template
1005   // parameter scope. This is the context in which the template is
1006   // being lexically declaration (a namespace context). In the
1007   // example, this is the global scope.
1008   if (Lexical->isFileContext() && !Lexical->Equals(Semantic) &&
1009       Lexical->Encloses(Semantic))
1010     return std::make_pair(Semantic, true);
1011 
1012   return std::make_pair(Lexical, false);
1013 }
1014 
1015 namespace {
1016 /// An RAII object to specify that we want to find block scope extern
1017 /// declarations.
1018 struct FindLocalExternScope {
FindLocalExternScope__anon19e32a9a0211::FindLocalExternScope1019   FindLocalExternScope(LookupResult &R)
1020       : R(R), OldFindLocalExtern(R.getIdentifierNamespace() &
1021                                  Decl::IDNS_LocalExtern) {
1022     R.setFindLocalExtern(R.getIdentifierNamespace() & Decl::IDNS_Ordinary);
1023   }
restore__anon19e32a9a0211::FindLocalExternScope1024   void restore() {
1025     R.setFindLocalExtern(OldFindLocalExtern);
1026   }
~FindLocalExternScope__anon19e32a9a0211::FindLocalExternScope1027   ~FindLocalExternScope() {
1028     restore();
1029   }
1030   LookupResult &R;
1031   bool OldFindLocalExtern;
1032 };
1033 } // end anonymous namespace
1034 
CppLookupName(LookupResult & R,Scope * S)1035 bool Sema::CppLookupName(LookupResult &R, Scope *S) {
1036   assert(getLangOpts().CPlusPlus && "Can perform only C++ lookup");
1037 
1038   DeclarationName Name = R.getLookupName();
1039   Sema::LookupNameKind NameKind = R.getLookupKind();
1040 
1041   // If this is the name of an implicitly-declared special member function,
1042   // go through the scope stack to implicitly declare
1043   if (isImplicitlyDeclaredMemberFunctionName(Name)) {
1044     for (Scope *PreS = S; PreS; PreS = PreS->getParent())
1045       if (DeclContext *DC = PreS->getEntity())
1046         DeclareImplicitMemberFunctionsWithName(*this, Name, DC);
1047   }
1048 
1049   // Implicitly declare member functions with the name we're looking for, if in
1050   // fact we are in a scope where it matters.
1051 
1052   Scope *Initial = S;
1053   IdentifierResolver::iterator
1054     I = IdResolver.begin(Name),
1055     IEnd = IdResolver.end();
1056 
1057   // First we lookup local scope.
1058   // We don't consider using-directives, as per 7.3.4.p1 [namespace.udir]
1059   // ...During unqualified name lookup (3.4.1), the names appear as if
1060   // they were declared in the nearest enclosing namespace which contains
1061   // both the using-directive and the nominated namespace.
1062   // [Note: in this context, "contains" means "contains directly or
1063   // indirectly".
1064   //
1065   // For example:
1066   // namespace A { int i; }
1067   // void foo() {
1068   //   int i;
1069   //   {
1070   //     using namespace A;
1071   //     ++i; // finds local 'i', A::i appears at global scope
1072   //   }
1073   // }
1074   //
1075   UnqualUsingDirectiveSet UDirs;
1076   bool VisitedUsingDirectives = false;
1077   bool LeftStartingScope = false;
1078   DeclContext *OutsideOfTemplateParamDC = nullptr;
1079 
1080   // When performing a scope lookup, we want to find local extern decls.
1081   FindLocalExternScope FindLocals(R);
1082 
1083   for (; S && !isNamespaceOrTranslationUnitScope(S); S = S->getParent()) {
1084     DeclContext *Ctx = S->getEntity();
1085     bool SearchNamespaceScope = true;
1086     // Check whether the IdResolver has anything in this scope.
1087     for (; I != IEnd && S->isDeclScope(*I); ++I) {
1088       if (NamedDecl *ND = R.getAcceptableDecl(*I)) {
1089         if (NameKind == LookupRedeclarationWithLinkage &&
1090             !(*I)->isTemplateParameter()) {
1091           // If it's a template parameter, we still find it, so we can diagnose
1092           // the invalid redeclaration.
1093 
1094           // Determine whether this (or a previous) declaration is
1095           // out-of-scope.
1096           if (!LeftStartingScope && !Initial->isDeclScope(*I))
1097             LeftStartingScope = true;
1098 
1099           // If we found something outside of our starting scope that
1100           // does not have linkage, skip it.
1101           if (LeftStartingScope && !((*I)->hasLinkage())) {
1102             R.setShadowed();
1103             continue;
1104           }
1105         } else {
1106           // We found something in this scope, we should not look at the
1107           // namespace scope
1108           SearchNamespaceScope = false;
1109         }
1110         R.addDecl(ND);
1111       }
1112     }
1113     if (!SearchNamespaceScope) {
1114       R.resolveKind();
1115       if (S->isClassScope())
1116         if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(Ctx))
1117           R.setNamingClass(Record);
1118       return true;
1119     }
1120 
1121     if (NameKind == LookupLocalFriendName && !S->isClassScope()) {
1122       // C++11 [class.friend]p11:
1123       //   If a friend declaration appears in a local class and the name
1124       //   specified is an unqualified name, a prior declaration is
1125       //   looked up without considering scopes that are outside the
1126       //   innermost enclosing non-class scope.
1127       return false;
1128     }
1129 
1130     if (!Ctx && S->isTemplateParamScope() && OutsideOfTemplateParamDC &&
1131         S->getParent() && !S->getParent()->isTemplateParamScope()) {
1132       // We've just searched the last template parameter scope and
1133       // found nothing, so look into the contexts between the
1134       // lexical and semantic declaration contexts returned by
1135       // findOuterContext(). This implements the name lookup behavior
1136       // of C++ [temp.local]p8.
1137       Ctx = OutsideOfTemplateParamDC;
1138       OutsideOfTemplateParamDC = nullptr;
1139     }
1140 
1141     if (Ctx) {
1142       DeclContext *OuterCtx;
1143       bool SearchAfterTemplateScope;
1144       std::tie(OuterCtx, SearchAfterTemplateScope) = findOuterContext(S);
1145       if (SearchAfterTemplateScope)
1146         OutsideOfTemplateParamDC = OuterCtx;
1147 
1148       for (; Ctx && !Ctx->Equals(OuterCtx); Ctx = Ctx->getLookupParent()) {
1149         // We do not directly look into transparent contexts, since
1150         // those entities will be found in the nearest enclosing
1151         // non-transparent context.
1152         if (Ctx->isTransparentContext())
1153           continue;
1154 
1155         // We do not look directly into function or method contexts,
1156         // since all of the local variables and parameters of the
1157         // function/method are present within the Scope.
1158         if (Ctx->isFunctionOrMethod()) {
1159           // If we have an Objective-C instance method, look for ivars
1160           // in the corresponding interface.
1161           if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(Ctx)) {
1162             if (Method->isInstanceMethod() && Name.getAsIdentifierInfo())
1163               if (ObjCInterfaceDecl *Class = Method->getClassInterface()) {
1164                 ObjCInterfaceDecl *ClassDeclared;
1165                 if (ObjCIvarDecl *Ivar = Class->lookupInstanceVariable(
1166                                                  Name.getAsIdentifierInfo(),
1167                                                              ClassDeclared)) {
1168                   if (NamedDecl *ND = R.getAcceptableDecl(Ivar)) {
1169                     R.addDecl(ND);
1170                     R.resolveKind();
1171                     return true;
1172                   }
1173                 }
1174               }
1175           }
1176 
1177           continue;
1178         }
1179 
1180         // If this is a file context, we need to perform unqualified name
1181         // lookup considering using directives.
1182         if (Ctx->isFileContext()) {
1183           // If we haven't handled using directives yet, do so now.
1184           if (!VisitedUsingDirectives) {
1185             // Add using directives from this context up to the top level.
1186             for (DeclContext *UCtx = Ctx; UCtx; UCtx = UCtx->getParent()) {
1187               if (UCtx->isTransparentContext())
1188                 continue;
1189 
1190               UDirs.visit(UCtx, UCtx);
1191             }
1192 
1193             // Find the innermost file scope, so we can add using directives
1194             // from local scopes.
1195             Scope *InnermostFileScope = S;
1196             while (InnermostFileScope &&
1197                    !isNamespaceOrTranslationUnitScope(InnermostFileScope))
1198               InnermostFileScope = InnermostFileScope->getParent();
1199             UDirs.visitScopeChain(Initial, InnermostFileScope);
1200 
1201             UDirs.done();
1202 
1203             VisitedUsingDirectives = true;
1204           }
1205 
1206           if (CppNamespaceLookup(*this, R, Context, Ctx, UDirs)) {
1207             R.resolveKind();
1208             return true;
1209           }
1210 
1211           continue;
1212         }
1213 
1214         // Perform qualified name lookup into this context.
1215         // FIXME: In some cases, we know that every name that could be found by
1216         // this qualified name lookup will also be on the identifier chain. For
1217         // example, inside a class without any base classes, we never need to
1218         // perform qualified lookup because all of the members are on top of the
1219         // identifier chain.
1220         if (LookupQualifiedName(R, Ctx, /*InUnqualifiedLookup=*/true))
1221           return true;
1222       }
1223     }
1224   }
1225 
1226   // Stop if we ran out of scopes.
1227   // FIXME:  This really, really shouldn't be happening.
1228   if (!S) return false;
1229 
1230   // If we are looking for members, no need to look into global/namespace scope.
1231   if (NameKind == LookupMemberName)
1232     return false;
1233 
1234   // Collect UsingDirectiveDecls in all scopes, and recursively all
1235   // nominated namespaces by those using-directives.
1236   //
1237   // FIXME: Cache this sorted list in Scope structure, and DeclContext, so we
1238   // don't build it for each lookup!
1239   if (!VisitedUsingDirectives) {
1240     UDirs.visitScopeChain(Initial, S);
1241     UDirs.done();
1242   }
1243 
1244   // If we're not performing redeclaration lookup, do not look for local
1245   // extern declarations outside of a function scope.
1246   if (!R.isForRedeclaration())
1247     FindLocals.restore();
1248 
1249   // Lookup namespace scope, and global scope.
1250   // Unqualified name lookup in C++ requires looking into scopes
1251   // that aren't strictly lexical, and therefore we walk through the
1252   // context as well as walking through the scopes.
1253   for (; S; S = S->getParent()) {
1254     // Check whether the IdResolver has anything in this scope.
1255     bool Found = false;
1256     for (; I != IEnd && S->isDeclScope(*I); ++I) {
1257       if (NamedDecl *ND = R.getAcceptableDecl(*I)) {
1258         // We found something.  Look for anything else in our scope
1259         // with this same name and in an acceptable identifier
1260         // namespace, so that we can construct an overload set if we
1261         // need to.
1262         Found = true;
1263         R.addDecl(ND);
1264       }
1265     }
1266 
1267     if (Found && S->isTemplateParamScope()) {
1268       R.resolveKind();
1269       return true;
1270     }
1271 
1272     DeclContext *Ctx = S->getEntity();
1273     if (!Ctx && S->isTemplateParamScope() && OutsideOfTemplateParamDC &&
1274         S->getParent() && !S->getParent()->isTemplateParamScope()) {
1275       // We've just searched the last template parameter scope and
1276       // found nothing, so look into the contexts between the
1277       // lexical and semantic declaration contexts returned by
1278       // findOuterContext(). This implements the name lookup behavior
1279       // of C++ [temp.local]p8.
1280       Ctx = OutsideOfTemplateParamDC;
1281       OutsideOfTemplateParamDC = nullptr;
1282     }
1283 
1284     if (Ctx) {
1285       DeclContext *OuterCtx;
1286       bool SearchAfterTemplateScope;
1287       std::tie(OuterCtx, SearchAfterTemplateScope) = findOuterContext(S);
1288       if (SearchAfterTemplateScope)
1289         OutsideOfTemplateParamDC = OuterCtx;
1290 
1291       for (; Ctx && !Ctx->Equals(OuterCtx); Ctx = Ctx->getLookupParent()) {
1292         // We do not directly look into transparent contexts, since
1293         // those entities will be found in the nearest enclosing
1294         // non-transparent context.
1295         if (Ctx->isTransparentContext())
1296           continue;
1297 
1298         // If we have a context, and it's not a context stashed in the
1299         // template parameter scope for an out-of-line definition, also
1300         // look into that context.
1301         if (!(Found && S && S->isTemplateParamScope())) {
1302           assert(Ctx->isFileContext() &&
1303               "We should have been looking only at file context here already.");
1304 
1305           // Look into context considering using-directives.
1306           if (CppNamespaceLookup(*this, R, Context, Ctx, UDirs))
1307             Found = true;
1308         }
1309 
1310         if (Found) {
1311           R.resolveKind();
1312           return true;
1313         }
1314 
1315         if (R.isForRedeclaration() && !Ctx->isTransparentContext())
1316           return false;
1317       }
1318     }
1319 
1320     if (R.isForRedeclaration() && Ctx && !Ctx->isTransparentContext())
1321       return false;
1322   }
1323 
1324   return !R.empty();
1325 }
1326 
1327 /// \brief Find the declaration that a class temploid member specialization was
1328 /// instantiated from, or the member itself if it is an explicit specialization.
getInstantiatedFrom(Decl * D,MemberSpecializationInfo * MSInfo)1329 static Decl *getInstantiatedFrom(Decl *D, MemberSpecializationInfo *MSInfo) {
1330   return MSInfo->isExplicitSpecialization() ? D : MSInfo->getInstantiatedFrom();
1331 }
1332 
getOwningModule(Decl * Entity)1333 Module *Sema::getOwningModule(Decl *Entity) {
1334   // If it's imported, grab its owning module.
1335   Module *M = Entity->getImportedOwningModule();
1336   if (M || !isa<NamedDecl>(Entity) || !cast<NamedDecl>(Entity)->isHidden())
1337     return M;
1338   assert(!Entity->isFromASTFile() &&
1339          "hidden entity from AST file has no owning module");
1340 
1341   if (!getLangOpts().ModulesLocalVisibility) {
1342     // If we're not tracking visibility locally, the only way a declaration
1343     // can be hidden and local is if it's hidden because it's parent is (for
1344     // instance, maybe this is a lazily-declared special member of an imported
1345     // class).
1346     auto *Parent = cast<NamedDecl>(Entity->getDeclContext());
1347     assert(Parent->isHidden() && "unexpectedly hidden decl");
1348     return getOwningModule(Parent);
1349   }
1350 
1351   // It's local and hidden; grab or compute its owning module.
1352   M = Entity->getLocalOwningModule();
1353   if (M)
1354     return M;
1355 
1356   if (auto *Containing =
1357           PP.getModuleContainingLocation(Entity->getLocation())) {
1358     M = Containing;
1359   } else if (Entity->isInvalidDecl() || Entity->getLocation().isInvalid()) {
1360     // Don't bother tracking visibility for invalid declarations with broken
1361     // locations.
1362     cast<NamedDecl>(Entity)->setHidden(false);
1363   } else {
1364     // We need to assign a module to an entity that exists outside of any
1365     // module, so that we can hide it from modules that we textually enter.
1366     // Invent a fake module for all such entities.
1367     if (!CachedFakeTopLevelModule) {
1368       CachedFakeTopLevelModule =
1369           PP.getHeaderSearchInfo().getModuleMap().findOrCreateModule(
1370               "<top-level>", nullptr, false, false).first;
1371 
1372       auto &SrcMgr = PP.getSourceManager();
1373       SourceLocation StartLoc =
1374           SrcMgr.getLocForStartOfFile(SrcMgr.getMainFileID());
1375       auto &TopLevel =
1376           VisibleModulesStack.empty() ? VisibleModules : VisibleModulesStack[0];
1377       TopLevel.setVisible(CachedFakeTopLevelModule, StartLoc);
1378     }
1379 
1380     M = CachedFakeTopLevelModule;
1381   }
1382 
1383   if (M)
1384     Entity->setLocalOwningModule(M);
1385   return M;
1386 }
1387 
makeMergedDefinitionVisible(NamedDecl * ND,SourceLocation Loc)1388 void Sema::makeMergedDefinitionVisible(NamedDecl *ND, SourceLocation Loc) {
1389   if (auto *M = PP.getModuleContainingLocation(Loc))
1390     Context.mergeDefinitionIntoModule(ND, M);
1391   else
1392     // We're not building a module; just make the definition visible.
1393     ND->setHidden(false);
1394 
1395   // If ND is a template declaration, make the template parameters
1396   // visible too. They're not (necessarily) within a mergeable DeclContext.
1397   if (auto *TD = dyn_cast<TemplateDecl>(ND))
1398     for (auto *Param : *TD->getTemplateParameters())
1399       makeMergedDefinitionVisible(Param, Loc);
1400 }
1401 
1402 /// \brief Find the module in which the given declaration was defined.
getDefiningModule(Sema & S,Decl * Entity)1403 static Module *getDefiningModule(Sema &S, Decl *Entity) {
1404   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Entity)) {
1405     // If this function was instantiated from a template, the defining module is
1406     // the module containing the pattern.
1407     if (FunctionDecl *Pattern = FD->getTemplateInstantiationPattern())
1408       Entity = Pattern;
1409   } else if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Entity)) {
1410     if (CXXRecordDecl *Pattern = RD->getTemplateInstantiationPattern())
1411       Entity = Pattern;
1412   } else if (EnumDecl *ED = dyn_cast<EnumDecl>(Entity)) {
1413     if (MemberSpecializationInfo *MSInfo = ED->getMemberSpecializationInfo())
1414       Entity = getInstantiatedFrom(ED, MSInfo);
1415   } else if (VarDecl *VD = dyn_cast<VarDecl>(Entity)) {
1416     // FIXME: Map from variable template specializations back to the template.
1417     if (MemberSpecializationInfo *MSInfo = VD->getMemberSpecializationInfo())
1418       Entity = getInstantiatedFrom(VD, MSInfo);
1419   }
1420 
1421   // Walk up to the containing context. That might also have been instantiated
1422   // from a template.
1423   DeclContext *Context = Entity->getDeclContext();
1424   if (Context->isFileContext())
1425     return S.getOwningModule(Entity);
1426   return getDefiningModule(S, cast<Decl>(Context));
1427 }
1428 
getLookupModules()1429 llvm::DenseSet<Module*> &Sema::getLookupModules() {
1430   unsigned N = ActiveTemplateInstantiations.size();
1431   for (unsigned I = ActiveTemplateInstantiationLookupModules.size();
1432        I != N; ++I) {
1433     Module *M =
1434         getDefiningModule(*this, ActiveTemplateInstantiations[I].Entity);
1435     if (M && !LookupModulesCache.insert(M).second)
1436       M = nullptr;
1437     ActiveTemplateInstantiationLookupModules.push_back(M);
1438   }
1439   return LookupModulesCache;
1440 }
1441 
hasVisibleMergedDefinition(NamedDecl * Def)1442 bool Sema::hasVisibleMergedDefinition(NamedDecl *Def) {
1443   for (Module *Merged : Context.getModulesWithMergedDefinition(Def))
1444     if (isModuleVisible(Merged))
1445       return true;
1446   return false;
1447 }
1448 
1449 template<typename ParmDecl>
1450 static bool
hasVisibleDefaultArgument(Sema & S,const ParmDecl * D,llvm::SmallVectorImpl<Module * > * Modules)1451 hasVisibleDefaultArgument(Sema &S, const ParmDecl *D,
1452                           llvm::SmallVectorImpl<Module *> *Modules) {
1453   if (!D->hasDefaultArgument())
1454     return false;
1455 
1456   while (D) {
1457     auto &DefaultArg = D->getDefaultArgStorage();
1458     if (!DefaultArg.isInherited() && S.isVisible(D))
1459       return true;
1460 
1461     if (!DefaultArg.isInherited() && Modules) {
1462       auto *NonConstD = const_cast<ParmDecl*>(D);
1463       Modules->push_back(S.getOwningModule(NonConstD));
1464       const auto &Merged = S.Context.getModulesWithMergedDefinition(NonConstD);
1465       Modules->insert(Modules->end(), Merged.begin(), Merged.end());
1466     }
1467 
1468     // If there was a previous default argument, maybe its parameter is visible.
1469     D = DefaultArg.getInheritedFrom();
1470   }
1471   return false;
1472 }
1473 
hasVisibleDefaultArgument(const NamedDecl * D,llvm::SmallVectorImpl<Module * > * Modules)1474 bool Sema::hasVisibleDefaultArgument(const NamedDecl *D,
1475                                      llvm::SmallVectorImpl<Module *> *Modules) {
1476   if (auto *P = dyn_cast<TemplateTypeParmDecl>(D))
1477     return ::hasVisibleDefaultArgument(*this, P, Modules);
1478   if (auto *P = dyn_cast<NonTypeTemplateParmDecl>(D))
1479     return ::hasVisibleDefaultArgument(*this, P, Modules);
1480   return ::hasVisibleDefaultArgument(*this, cast<TemplateTemplateParmDecl>(D),
1481                                      Modules);
1482 }
1483 
hasVisibleMemberSpecialization(const NamedDecl * D,llvm::SmallVectorImpl<Module * > * Modules)1484 bool Sema::hasVisibleMemberSpecialization(
1485     const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
1486   assert(isa<CXXRecordDecl>(D->getDeclContext()) &&
1487          "not a member specialization");
1488   for (auto *Redecl : D->redecls()) {
1489     // If the specialization is declared at namespace scope, then it's a member
1490     // specialization declaration. If it's lexically inside the class
1491     // definition then it was instantiated.
1492     //
1493     // FIXME: This is a hack. There should be a better way to determine this.
1494     // FIXME: What about MS-style explicit specializations declared within a
1495     //        class definition?
1496     if (Redecl->getLexicalDeclContext()->isFileContext()) {
1497       auto *NonConstR = const_cast<NamedDecl*>(cast<NamedDecl>(Redecl));
1498 
1499       if (isVisible(NonConstR))
1500         return true;
1501 
1502       if (Modules) {
1503         Modules->push_back(getOwningModule(NonConstR));
1504         const auto &Merged = Context.getModulesWithMergedDefinition(NonConstR);
1505         Modules->insert(Modules->end(), Merged.begin(), Merged.end());
1506       }
1507     }
1508   }
1509 
1510   return false;
1511 }
1512 
1513 /// \brief Determine whether a declaration is visible to name lookup.
1514 ///
1515 /// This routine determines whether the declaration D is visible in the current
1516 /// lookup context, taking into account the current template instantiation
1517 /// stack. During template instantiation, a declaration is visible if it is
1518 /// visible from a module containing any entity on the template instantiation
1519 /// path (by instantiating a template, you allow it to see the declarations that
1520 /// your module can see, including those later on in your module).
isVisibleSlow(Sema & SemaRef,NamedDecl * D)1521 bool LookupResult::isVisibleSlow(Sema &SemaRef, NamedDecl *D) {
1522   assert(D->isHidden() && "should not call this: not in slow case");
1523   Module *DeclModule = nullptr;
1524 
1525   if (SemaRef.getLangOpts().ModulesLocalVisibility) {
1526     DeclModule = SemaRef.getOwningModule(D);
1527     if (!DeclModule) {
1528       // getOwningModule() may have decided the declaration should not be hidden.
1529       assert(!D->isHidden() && "hidden decl not from a module");
1530       return true;
1531     }
1532 
1533     // If the owning module is visible, and the decl is not module private,
1534     // then the decl is visible too. (Module private is ignored within the same
1535     // top-level module.)
1536     if ((!D->isFromASTFile() || !D->isModulePrivate()) &&
1537         (SemaRef.isModuleVisible(DeclModule) ||
1538          SemaRef.hasVisibleMergedDefinition(D)))
1539       return true;
1540   }
1541 
1542   // If this declaration is not at namespace scope nor module-private,
1543   // then it is visible if its lexical parent has a visible definition.
1544   DeclContext *DC = D->getLexicalDeclContext();
1545   if (!D->isModulePrivate() &&
1546       DC && !DC->isFileContext() && !isa<LinkageSpecDecl>(DC)) {
1547     // For a parameter, check whether our current template declaration's
1548     // lexical context is visible, not whether there's some other visible
1549     // definition of it, because parameters aren't "within" the definition.
1550     if ((D->isTemplateParameter() || isa<ParmVarDecl>(D))
1551             ? isVisible(SemaRef, cast<NamedDecl>(DC))
1552             : SemaRef.hasVisibleDefinition(cast<NamedDecl>(DC))) {
1553       if (SemaRef.ActiveTemplateInstantiations.empty() &&
1554           // FIXME: Do something better in this case.
1555           !SemaRef.getLangOpts().ModulesLocalVisibility) {
1556         // Cache the fact that this declaration is implicitly visible because
1557         // its parent has a visible definition.
1558         D->setHidden(false);
1559       }
1560       return true;
1561     }
1562     return false;
1563   }
1564 
1565   // Find the extra places where we need to look.
1566   llvm::DenseSet<Module*> &LookupModules = SemaRef.getLookupModules();
1567   if (LookupModules.empty())
1568     return false;
1569 
1570   if (!DeclModule) {
1571     DeclModule = SemaRef.getOwningModule(D);
1572     assert(DeclModule && "hidden decl not from a module");
1573   }
1574 
1575   // If our lookup set contains the decl's module, it's visible.
1576   if (LookupModules.count(DeclModule))
1577     return true;
1578 
1579   // If the declaration isn't exported, it's not visible in any other module.
1580   if (D->isModulePrivate())
1581     return false;
1582 
1583   // Check whether DeclModule is transitively exported to an import of
1584   // the lookup set.
1585   return std::any_of(LookupModules.begin(), LookupModules.end(),
1586                      [&](Module *M) { return M->isModuleVisible(DeclModule); });
1587 }
1588 
isVisibleSlow(const NamedDecl * D)1589 bool Sema::isVisibleSlow(const NamedDecl *D) {
1590   return LookupResult::isVisible(*this, const_cast<NamedDecl*>(D));
1591 }
1592 
shouldLinkPossiblyHiddenDecl(LookupResult & R,const NamedDecl * New)1593 bool Sema::shouldLinkPossiblyHiddenDecl(LookupResult &R, const NamedDecl *New) {
1594   for (auto *D : R) {
1595     if (isVisible(D))
1596       return true;
1597   }
1598   return New->isExternallyVisible();
1599 }
1600 
1601 /// \brief Retrieve the visible declaration corresponding to D, if any.
1602 ///
1603 /// This routine determines whether the declaration D is visible in the current
1604 /// module, with the current imports. If not, it checks whether any
1605 /// redeclaration of D is visible, and if so, returns that declaration.
1606 ///
1607 /// \returns D, or a visible previous declaration of D, whichever is more recent
1608 /// and visible. If no declaration of D is visible, returns null.
findAcceptableDecl(Sema & SemaRef,NamedDecl * D)1609 static NamedDecl *findAcceptableDecl(Sema &SemaRef, NamedDecl *D) {
1610   assert(!LookupResult::isVisible(SemaRef, D) && "not in slow case");
1611 
1612   for (auto RD : D->redecls()) {
1613     // Don't bother with extra checks if we already know this one isn't visible.
1614     if (RD == D)
1615       continue;
1616 
1617     auto ND = cast<NamedDecl>(RD);
1618     // FIXME: This is wrong in the case where the previous declaration is not
1619     // visible in the same scope as D. This needs to be done much more
1620     // carefully.
1621     if (LookupResult::isVisible(SemaRef, ND))
1622       return ND;
1623   }
1624 
1625   return nullptr;
1626 }
1627 
hasVisibleDeclarationSlow(const NamedDecl * D,llvm::SmallVectorImpl<Module * > * Modules)1628 bool Sema::hasVisibleDeclarationSlow(const NamedDecl *D,
1629                                      llvm::SmallVectorImpl<Module *> *Modules) {
1630   assert(!isVisible(D) && "not in slow case");
1631 
1632   for (auto *Redecl : D->redecls()) {
1633     auto *NonConstR = const_cast<NamedDecl*>(cast<NamedDecl>(Redecl));
1634     if (isVisible(NonConstR))
1635       return true;
1636 
1637     if (Modules) {
1638       Modules->push_back(getOwningModule(NonConstR));
1639       const auto &Merged = Context.getModulesWithMergedDefinition(NonConstR);
1640       Modules->insert(Modules->end(), Merged.begin(), Merged.end());
1641     }
1642   }
1643 
1644   return false;
1645 }
1646 
getAcceptableDeclSlow(NamedDecl * D) const1647 NamedDecl *LookupResult::getAcceptableDeclSlow(NamedDecl *D) const {
1648   if (auto *ND = dyn_cast<NamespaceDecl>(D)) {
1649     // Namespaces are a bit of a special case: we expect there to be a lot of
1650     // redeclarations of some namespaces, all declarations of a namespace are
1651     // essentially interchangeable, all declarations are found by name lookup
1652     // if any is, and namespaces are never looked up during template
1653     // instantiation. So we benefit from caching the check in this case, and
1654     // it is correct to do so.
1655     auto *Key = ND->getCanonicalDecl();
1656     if (auto *Acceptable = getSema().VisibleNamespaceCache.lookup(Key))
1657       return Acceptable;
1658     auto *Acceptable =
1659         isVisible(getSema(), Key) ? Key : findAcceptableDecl(getSema(), Key);
1660     if (Acceptable)
1661       getSema().VisibleNamespaceCache.insert(std::make_pair(Key, Acceptable));
1662     return Acceptable;
1663   }
1664 
1665   return findAcceptableDecl(getSema(), D);
1666 }
1667 
1668 /// @brief Perform unqualified name lookup starting from a given
1669 /// scope.
1670 ///
1671 /// Unqualified name lookup (C++ [basic.lookup.unqual], C99 6.2.1) is
1672 /// used to find names within the current scope. For example, 'x' in
1673 /// @code
1674 /// int x;
1675 /// int f() {
1676 ///   return x; // unqualified name look finds 'x' in the global scope
1677 /// }
1678 /// @endcode
1679 ///
1680 /// Different lookup criteria can find different names. For example, a
1681 /// particular scope can have both a struct and a function of the same
1682 /// name, and each can be found by certain lookup criteria. For more
1683 /// information about lookup criteria, see the documentation for the
1684 /// class LookupCriteria.
1685 ///
1686 /// @param S        The scope from which unqualified name lookup will
1687 /// begin. If the lookup criteria permits, name lookup may also search
1688 /// in the parent scopes.
1689 ///
1690 /// @param [in,out] R Specifies the lookup to perform (e.g., the name to
1691 /// look up and the lookup kind), and is updated with the results of lookup
1692 /// including zero or more declarations and possibly additional information
1693 /// used to diagnose ambiguities.
1694 ///
1695 /// @returns \c true if lookup succeeded and false otherwise.
LookupName(LookupResult & R,Scope * S,bool AllowBuiltinCreation)1696 bool Sema::LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation) {
1697   DeclarationName Name = R.getLookupName();
1698   if (!Name) return false;
1699 
1700   LookupNameKind NameKind = R.getLookupKind();
1701 
1702   if (!getLangOpts().CPlusPlus) {
1703     // Unqualified name lookup in C/Objective-C is purely lexical, so
1704     // search in the declarations attached to the name.
1705     if (NameKind == Sema::LookupRedeclarationWithLinkage) {
1706       // Find the nearest non-transparent declaration scope.
1707       while (!(S->getFlags() & Scope::DeclScope) ||
1708              (S->getEntity() && S->getEntity()->isTransparentContext()))
1709         S = S->getParent();
1710     }
1711 
1712     // When performing a scope lookup, we want to find local extern decls.
1713     FindLocalExternScope FindLocals(R);
1714 
1715     // Scan up the scope chain looking for a decl that matches this
1716     // identifier that is in the appropriate namespace.  This search
1717     // should not take long, as shadowing of names is uncommon, and
1718     // deep shadowing is extremely uncommon.
1719     bool LeftStartingScope = false;
1720 
1721     for (IdentifierResolver::iterator I = IdResolver.begin(Name),
1722                                    IEnd = IdResolver.end();
1723          I != IEnd; ++I)
1724       if (NamedDecl *D = R.getAcceptableDecl(*I)) {
1725         if (NameKind == LookupRedeclarationWithLinkage) {
1726           // Determine whether this (or a previous) declaration is
1727           // out-of-scope.
1728           if (!LeftStartingScope && !S->isDeclScope(*I))
1729             LeftStartingScope = true;
1730 
1731           // If we found something outside of our starting scope that
1732           // does not have linkage, skip it.
1733           if (LeftStartingScope && !((*I)->hasLinkage())) {
1734             R.setShadowed();
1735             continue;
1736           }
1737         }
1738         else if (NameKind == LookupObjCImplicitSelfParam &&
1739                  !isa<ImplicitParamDecl>(*I))
1740           continue;
1741 
1742         R.addDecl(D);
1743 
1744         // Check whether there are any other declarations with the same name
1745         // and in the same scope.
1746         if (I != IEnd) {
1747           // Find the scope in which this declaration was declared (if it
1748           // actually exists in a Scope).
1749           while (S && !S->isDeclScope(D))
1750             S = S->getParent();
1751 
1752           // If the scope containing the declaration is the translation unit,
1753           // then we'll need to perform our checks based on the matching
1754           // DeclContexts rather than matching scopes.
1755           if (S && isNamespaceOrTranslationUnitScope(S))
1756             S = nullptr;
1757 
1758           // Compute the DeclContext, if we need it.
1759           DeclContext *DC = nullptr;
1760           if (!S)
1761             DC = (*I)->getDeclContext()->getRedeclContext();
1762 
1763           IdentifierResolver::iterator LastI = I;
1764           for (++LastI; LastI != IEnd; ++LastI) {
1765             if (S) {
1766               // Match based on scope.
1767               if (!S->isDeclScope(*LastI))
1768                 break;
1769             } else {
1770               // Match based on DeclContext.
1771               DeclContext *LastDC
1772                 = (*LastI)->getDeclContext()->getRedeclContext();
1773               if (!LastDC->Equals(DC))
1774                 break;
1775             }
1776 
1777             // If the declaration is in the right namespace and visible, add it.
1778             if (NamedDecl *LastD = R.getAcceptableDecl(*LastI))
1779               R.addDecl(LastD);
1780           }
1781 
1782           R.resolveKind();
1783         }
1784 
1785         return true;
1786       }
1787   } else {
1788     // Perform C++ unqualified name lookup.
1789     if (CppLookupName(R, S))
1790       return true;
1791   }
1792 
1793   // If we didn't find a use of this identifier, and if the identifier
1794   // corresponds to a compiler builtin, create the decl object for the builtin
1795   // now, injecting it into translation unit scope, and return it.
1796   if (AllowBuiltinCreation && LookupBuiltin(*this, R))
1797     return true;
1798 
1799   // If we didn't find a use of this identifier, the ExternalSource
1800   // may be able to handle the situation.
1801   // Note: some lookup failures are expected!
1802   // See e.g. R.isForRedeclaration().
1803   return (ExternalSource && ExternalSource->LookupUnqualified(R, S));
1804 }
1805 
1806 /// @brief Perform qualified name lookup in the namespaces nominated by
1807 /// using directives by the given context.
1808 ///
1809 /// C++98 [namespace.qual]p2:
1810 ///   Given X::m (where X is a user-declared namespace), or given \::m
1811 ///   (where X is the global namespace), let S be the set of all
1812 ///   declarations of m in X and in the transitive closure of all
1813 ///   namespaces nominated by using-directives in X and its used
1814 ///   namespaces, except that using-directives are ignored in any
1815 ///   namespace, including X, directly containing one or more
1816 ///   declarations of m. No namespace is searched more than once in
1817 ///   the lookup of a name. If S is the empty set, the program is
1818 ///   ill-formed. Otherwise, if S has exactly one member, or if the
1819 ///   context of the reference is a using-declaration
1820 ///   (namespace.udecl), S is the required set of declarations of
1821 ///   m. Otherwise if the use of m is not one that allows a unique
1822 ///   declaration to be chosen from S, the program is ill-formed.
1823 ///
1824 /// C++98 [namespace.qual]p5:
1825 ///   During the lookup of a qualified namespace member name, if the
1826 ///   lookup finds more than one declaration of the member, and if one
1827 ///   declaration introduces a class name or enumeration name and the
1828 ///   other declarations either introduce the same object, the same
1829 ///   enumerator or a set of functions, the non-type name hides the
1830 ///   class or enumeration name if and only if the declarations are
1831 ///   from the same namespace; otherwise (the declarations are from
1832 ///   different namespaces), the program is ill-formed.
LookupQualifiedNameInUsingDirectives(Sema & S,LookupResult & R,DeclContext * StartDC)1833 static bool LookupQualifiedNameInUsingDirectives(Sema &S, LookupResult &R,
1834                                                  DeclContext *StartDC) {
1835   assert(StartDC->isFileContext() && "start context is not a file context");
1836 
1837   DeclContext::udir_range UsingDirectives = StartDC->using_directives();
1838   if (UsingDirectives.begin() == UsingDirectives.end()) return false;
1839 
1840   // We have at least added all these contexts to the queue.
1841   llvm::SmallPtrSet<DeclContext*, 8> Visited;
1842   Visited.insert(StartDC);
1843 
1844   // We have not yet looked into these namespaces, much less added
1845   // their "using-children" to the queue.
1846   SmallVector<NamespaceDecl*, 8> Queue;
1847 
1848   // We have already looked into the initial namespace; seed the queue
1849   // with its using-children.
1850   for (auto *I : UsingDirectives) {
1851     NamespaceDecl *ND = I->getNominatedNamespace()->getOriginalNamespace();
1852     if (Visited.insert(ND).second)
1853       Queue.push_back(ND);
1854   }
1855 
1856   // The easiest way to implement the restriction in [namespace.qual]p5
1857   // is to check whether any of the individual results found a tag
1858   // and, if so, to declare an ambiguity if the final result is not
1859   // a tag.
1860   bool FoundTag = false;
1861   bool FoundNonTag = false;
1862 
1863   LookupResult LocalR(LookupResult::Temporary, R);
1864 
1865   bool Found = false;
1866   while (!Queue.empty()) {
1867     NamespaceDecl *ND = Queue.pop_back_val();
1868 
1869     // We go through some convolutions here to avoid copying results
1870     // between LookupResults.
1871     bool UseLocal = !R.empty();
1872     LookupResult &DirectR = UseLocal ? LocalR : R;
1873     bool FoundDirect = LookupDirect(S, DirectR, ND);
1874 
1875     if (FoundDirect) {
1876       // First do any local hiding.
1877       DirectR.resolveKind();
1878 
1879       // If the local result is a tag, remember that.
1880       if (DirectR.isSingleTagDecl())
1881         FoundTag = true;
1882       else
1883         FoundNonTag = true;
1884 
1885       // Append the local results to the total results if necessary.
1886       if (UseLocal) {
1887         R.addAllDecls(LocalR);
1888         LocalR.clear();
1889       }
1890     }
1891 
1892     // If we find names in this namespace, ignore its using directives.
1893     if (FoundDirect) {
1894       Found = true;
1895       continue;
1896     }
1897 
1898     for (auto I : ND->using_directives()) {
1899       NamespaceDecl *Nom = I->getNominatedNamespace();
1900       if (Visited.insert(Nom).second)
1901         Queue.push_back(Nom);
1902     }
1903   }
1904 
1905   if (Found) {
1906     if (FoundTag && FoundNonTag)
1907       R.setAmbiguousQualifiedTagHiding();
1908     else
1909       R.resolveKind();
1910   }
1911 
1912   return Found;
1913 }
1914 
1915 /// \brief Callback that looks for any member of a class with the given name.
LookupAnyMember(const CXXBaseSpecifier * Specifier,CXXBasePath & Path,DeclarationName Name)1916 static bool LookupAnyMember(const CXXBaseSpecifier *Specifier,
1917                             CXXBasePath &Path, DeclarationName Name) {
1918   RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
1919 
1920   Path.Decls = BaseRecord->lookup(Name);
1921   return !Path.Decls.empty();
1922 }
1923 
1924 /// \brief Determine whether the given set of member declarations contains only
1925 /// static members, nested types, and enumerators.
1926 template<typename InputIterator>
HasOnlyStaticMembers(InputIterator First,InputIterator Last)1927 static bool HasOnlyStaticMembers(InputIterator First, InputIterator Last) {
1928   Decl *D = (*First)->getUnderlyingDecl();
1929   if (isa<VarDecl>(D) || isa<TypeDecl>(D) || isa<EnumConstantDecl>(D))
1930     return true;
1931 
1932   if (isa<CXXMethodDecl>(D)) {
1933     // Determine whether all of the methods are static.
1934     bool AllMethodsAreStatic = true;
1935     for(; First != Last; ++First) {
1936       D = (*First)->getUnderlyingDecl();
1937 
1938       if (!isa<CXXMethodDecl>(D)) {
1939         assert(isa<TagDecl>(D) && "Non-function must be a tag decl");
1940         break;
1941       }
1942 
1943       if (!cast<CXXMethodDecl>(D)->isStatic()) {
1944         AllMethodsAreStatic = false;
1945         break;
1946       }
1947     }
1948 
1949     if (AllMethodsAreStatic)
1950       return true;
1951   }
1952 
1953   return false;
1954 }
1955 
1956 /// \brief Perform qualified name lookup into a given context.
1957 ///
1958 /// Qualified name lookup (C++ [basic.lookup.qual]) is used to find
1959 /// names when the context of those names is explicit specified, e.g.,
1960 /// "std::vector" or "x->member", or as part of unqualified name lookup.
1961 ///
1962 /// Different lookup criteria can find different names. For example, a
1963 /// particular scope can have both a struct and a function of the same
1964 /// name, and each can be found by certain lookup criteria. For more
1965 /// information about lookup criteria, see the documentation for the
1966 /// class LookupCriteria.
1967 ///
1968 /// \param R captures both the lookup criteria and any lookup results found.
1969 ///
1970 /// \param LookupCtx The context in which qualified name lookup will
1971 /// search. If the lookup criteria permits, name lookup may also search
1972 /// in the parent contexts or (for C++ classes) base classes.
1973 ///
1974 /// \param InUnqualifiedLookup true if this is qualified name lookup that
1975 /// occurs as part of unqualified name lookup.
1976 ///
1977 /// \returns true if lookup succeeded, false if it failed.
LookupQualifiedName(LookupResult & R,DeclContext * LookupCtx,bool InUnqualifiedLookup)1978 bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
1979                                bool InUnqualifiedLookup) {
1980   assert(LookupCtx && "Sema::LookupQualifiedName requires a lookup context");
1981 
1982   if (!R.getLookupName())
1983     return false;
1984 
1985   // Make sure that the declaration context is complete.
1986   assert((!isa<TagDecl>(LookupCtx) ||
1987           LookupCtx->isDependentContext() ||
1988           cast<TagDecl>(LookupCtx)->isCompleteDefinition() ||
1989           cast<TagDecl>(LookupCtx)->isBeingDefined()) &&
1990          "Declaration context must already be complete!");
1991 
1992   struct QualifiedLookupInScope {
1993     bool oldVal;
1994     DeclContext *Context;
1995     // Set flag in DeclContext informing debugger that we're looking for qualified name
1996     QualifiedLookupInScope(DeclContext *ctx) : Context(ctx) {
1997       oldVal = ctx->setUseQualifiedLookup();
1998     }
1999     ~QualifiedLookupInScope() {
2000       Context->setUseQualifiedLookup(oldVal);
2001     }
2002   } QL(LookupCtx);
2003 
2004   if (LookupDirect(*this, R, LookupCtx)) {
2005     R.resolveKind();
2006     if (isa<CXXRecordDecl>(LookupCtx))
2007       R.setNamingClass(cast<CXXRecordDecl>(LookupCtx));
2008     return true;
2009   }
2010 
2011   // Don't descend into implied contexts for redeclarations.
2012   // C++98 [namespace.qual]p6:
2013   //   In a declaration for a namespace member in which the
2014   //   declarator-id is a qualified-id, given that the qualified-id
2015   //   for the namespace member has the form
2016   //     nested-name-specifier unqualified-id
2017   //   the unqualified-id shall name a member of the namespace
2018   //   designated by the nested-name-specifier.
2019   // See also [class.mfct]p5 and [class.static.data]p2.
2020   if (R.isForRedeclaration())
2021     return false;
2022 
2023   // If this is a namespace, look it up in the implied namespaces.
2024   if (LookupCtx->isFileContext())
2025     return LookupQualifiedNameInUsingDirectives(*this, R, LookupCtx);
2026 
2027   // If this isn't a C++ class, we aren't allowed to look into base
2028   // classes, we're done.
2029   CXXRecordDecl *LookupRec = dyn_cast<CXXRecordDecl>(LookupCtx);
2030   if (!LookupRec || !LookupRec->getDefinition())
2031     return false;
2032 
2033   // If we're performing qualified name lookup into a dependent class,
2034   // then we are actually looking into a current instantiation. If we have any
2035   // dependent base classes, then we either have to delay lookup until
2036   // template instantiation time (at which point all bases will be available)
2037   // or we have to fail.
2038   if (!InUnqualifiedLookup && LookupRec->isDependentContext() &&
2039       LookupRec->hasAnyDependentBases()) {
2040     R.setNotFoundInCurrentInstantiation();
2041     return false;
2042   }
2043 
2044   // Perform lookup into our base classes.
2045   CXXBasePaths Paths;
2046   Paths.setOrigin(LookupRec);
2047 
2048   // Look for this member in our base classes
2049   bool (*BaseCallback)(const CXXBaseSpecifier *Specifier, CXXBasePath &Path,
2050                        DeclarationName Name) = nullptr;
2051   switch (R.getLookupKind()) {
2052     case LookupObjCImplicitSelfParam:
2053     case LookupOrdinaryName:
2054     case LookupMemberName:
2055     case LookupRedeclarationWithLinkage:
2056     case LookupLocalFriendName:
2057       BaseCallback = &CXXRecordDecl::FindOrdinaryMember;
2058       break;
2059 
2060     case LookupTagName:
2061       BaseCallback = &CXXRecordDecl::FindTagMember;
2062       break;
2063 
2064     case LookupAnyName:
2065       BaseCallback = &LookupAnyMember;
2066       break;
2067 
2068     case LookupOMPReductionName:
2069       BaseCallback = &CXXRecordDecl::FindOMPReductionMember;
2070       break;
2071 
2072     case LookupUsingDeclName:
2073       // This lookup is for redeclarations only.
2074 
2075     case LookupOperatorName:
2076     case LookupNamespaceName:
2077     case LookupObjCProtocolName:
2078     case LookupLabel:
2079       // These lookups will never find a member in a C++ class (or base class).
2080       return false;
2081 
2082     case LookupNestedNameSpecifierName:
2083       BaseCallback = &CXXRecordDecl::FindNestedNameSpecifierMember;
2084       break;
2085   }
2086 
2087   DeclarationName Name = R.getLookupName();
2088   if (!LookupRec->lookupInBases(
2089           [=](const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
2090             return BaseCallback(Specifier, Path, Name);
2091           },
2092           Paths))
2093     return false;
2094 
2095   R.setNamingClass(LookupRec);
2096 
2097   // C++ [class.member.lookup]p2:
2098   //   [...] If the resulting set of declarations are not all from
2099   //   sub-objects of the same type, or the set has a nonstatic member
2100   //   and includes members from distinct sub-objects, there is an
2101   //   ambiguity and the program is ill-formed. Otherwise that set is
2102   //   the result of the lookup.
2103   QualType SubobjectType;
2104   int SubobjectNumber = 0;
2105   AccessSpecifier SubobjectAccess = AS_none;
2106 
2107   for (CXXBasePaths::paths_iterator Path = Paths.begin(), PathEnd = Paths.end();
2108        Path != PathEnd; ++Path) {
2109     const CXXBasePathElement &PathElement = Path->back();
2110 
2111     // Pick the best (i.e. most permissive i.e. numerically lowest) access
2112     // across all paths.
2113     SubobjectAccess = std::min(SubobjectAccess, Path->Access);
2114 
2115     // Determine whether we're looking at a distinct sub-object or not.
2116     if (SubobjectType.isNull()) {
2117       // This is the first subobject we've looked at. Record its type.
2118       SubobjectType = Context.getCanonicalType(PathElement.Base->getType());
2119       SubobjectNumber = PathElement.SubobjectNumber;
2120       continue;
2121     }
2122 
2123     if (SubobjectType
2124                  != Context.getCanonicalType(PathElement.Base->getType())) {
2125       // We found members of the given name in two subobjects of
2126       // different types. If the declaration sets aren't the same, this
2127       // lookup is ambiguous.
2128       if (HasOnlyStaticMembers(Path->Decls.begin(), Path->Decls.end())) {
2129         CXXBasePaths::paths_iterator FirstPath = Paths.begin();
2130         DeclContext::lookup_iterator FirstD = FirstPath->Decls.begin();
2131         DeclContext::lookup_iterator CurrentD = Path->Decls.begin();
2132 
2133         while (FirstD != FirstPath->Decls.end() &&
2134                CurrentD != Path->Decls.end()) {
2135          if ((*FirstD)->getUnderlyingDecl()->getCanonicalDecl() !=
2136              (*CurrentD)->getUnderlyingDecl()->getCanonicalDecl())
2137            break;
2138 
2139           ++FirstD;
2140           ++CurrentD;
2141         }
2142 
2143         if (FirstD == FirstPath->Decls.end() &&
2144             CurrentD == Path->Decls.end())
2145           continue;
2146       }
2147 
2148       R.setAmbiguousBaseSubobjectTypes(Paths);
2149       return true;
2150     }
2151 
2152     if (SubobjectNumber != PathElement.SubobjectNumber) {
2153       // We have a different subobject of the same type.
2154 
2155       // C++ [class.member.lookup]p5:
2156       //   A static member, a nested type or an enumerator defined in
2157       //   a base class T can unambiguously be found even if an object
2158       //   has more than one base class subobject of type T.
2159       if (HasOnlyStaticMembers(Path->Decls.begin(), Path->Decls.end()))
2160         continue;
2161 
2162       // We have found a nonstatic member name in multiple, distinct
2163       // subobjects. Name lookup is ambiguous.
2164       R.setAmbiguousBaseSubobjects(Paths);
2165       return true;
2166     }
2167   }
2168 
2169   // Lookup in a base class succeeded; return these results.
2170 
2171   for (auto *D : Paths.front().Decls) {
2172     AccessSpecifier AS = CXXRecordDecl::MergeAccess(SubobjectAccess,
2173                                                     D->getAccess());
2174     R.addDecl(D, AS);
2175   }
2176   R.resolveKind();
2177   return true;
2178 }
2179 
2180 /// \brief Performs qualified name lookup or special type of lookup for
2181 /// "__super::" scope specifier.
2182 ///
2183 /// This routine is a convenience overload meant to be called from contexts
2184 /// that need to perform a qualified name lookup with an optional C++ scope
2185 /// specifier that might require special kind of lookup.
2186 ///
2187 /// \param R captures both the lookup criteria and any lookup results found.
2188 ///
2189 /// \param LookupCtx The context in which qualified name lookup will
2190 /// search.
2191 ///
2192 /// \param SS An optional C++ scope-specifier.
2193 ///
2194 /// \returns true if lookup succeeded, false if it failed.
LookupQualifiedName(LookupResult & R,DeclContext * LookupCtx,CXXScopeSpec & SS)2195 bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
2196                                CXXScopeSpec &SS) {
2197   auto *NNS = SS.getScopeRep();
2198   if (NNS && NNS->getKind() == NestedNameSpecifier::Super)
2199     return LookupInSuper(R, NNS->getAsRecordDecl());
2200   else
2201 
2202     return LookupQualifiedName(R, LookupCtx);
2203 }
2204 
2205 /// @brief Performs name lookup for a name that was parsed in the
2206 /// source code, and may contain a C++ scope specifier.
2207 ///
2208 /// This routine is a convenience routine meant to be called from
2209 /// contexts that receive a name and an optional C++ scope specifier
2210 /// (e.g., "N::M::x"). It will then perform either qualified or
2211 /// unqualified name lookup (with LookupQualifiedName or LookupName,
2212 /// respectively) on the given name and return those results. It will
2213 /// perform a special type of lookup for "__super::" scope specifier.
2214 ///
2215 /// @param S        The scope from which unqualified name lookup will
2216 /// begin.
2217 ///
2218 /// @param SS       An optional C++ scope-specifier, e.g., "::N::M".
2219 ///
2220 /// @param EnteringContext Indicates whether we are going to enter the
2221 /// context of the scope-specifier SS (if present).
2222 ///
2223 /// @returns True if any decls were found (but possibly ambiguous)
LookupParsedName(LookupResult & R,Scope * S,CXXScopeSpec * SS,bool AllowBuiltinCreation,bool EnteringContext)2224 bool Sema::LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,
2225                             bool AllowBuiltinCreation, bool EnteringContext) {
2226   if (SS && SS->isInvalid()) {
2227     // When the scope specifier is invalid, don't even look for
2228     // anything.
2229     return false;
2230   }
2231 
2232   if (SS && SS->isSet()) {
2233     NestedNameSpecifier *NNS = SS->getScopeRep();
2234     if (NNS->getKind() == NestedNameSpecifier::Super)
2235       return LookupInSuper(R, NNS->getAsRecordDecl());
2236 
2237     if (DeclContext *DC = computeDeclContext(*SS, EnteringContext)) {
2238       // We have resolved the scope specifier to a particular declaration
2239       // contex, and will perform name lookup in that context.
2240       if (!DC->isDependentContext() && RequireCompleteDeclContext(*SS, DC))
2241         return false;
2242 
2243       R.setContextRange(SS->getRange());
2244       return LookupQualifiedName(R, DC);
2245     }
2246 
2247     // We could not resolve the scope specified to a specific declaration
2248     // context, which means that SS refers to an unknown specialization.
2249     // Name lookup can't find anything in this case.
2250     R.setNotFoundInCurrentInstantiation();
2251     R.setContextRange(SS->getRange());
2252     return false;
2253   }
2254 
2255   // Perform unqualified name lookup starting in the given scope.
2256   return LookupName(R, S, AllowBuiltinCreation);
2257 }
2258 
2259 /// \brief Perform qualified name lookup into all base classes of the given
2260 /// class.
2261 ///
2262 /// \param R captures both the lookup criteria and any lookup results found.
2263 ///
2264 /// \param Class The context in which qualified name lookup will
2265 /// search. Name lookup will search in all base classes merging the results.
2266 ///
2267 /// @returns True if any decls were found (but possibly ambiguous)
LookupInSuper(LookupResult & R,CXXRecordDecl * Class)2268 bool Sema::LookupInSuper(LookupResult &R, CXXRecordDecl *Class) {
2269   // The access-control rules we use here are essentially the rules for
2270   // doing a lookup in Class that just magically skipped the direct
2271   // members of Class itself.  That is, the naming class is Class, and the
2272   // access includes the access of the base.
2273   for (const auto &BaseSpec : Class->bases()) {
2274     CXXRecordDecl *RD = cast<CXXRecordDecl>(
2275         BaseSpec.getType()->castAs<RecordType>()->getDecl());
2276     LookupResult Result(*this, R.getLookupNameInfo(), R.getLookupKind());
2277 	Result.setBaseObjectType(Context.getRecordType(Class));
2278     LookupQualifiedName(Result, RD);
2279 
2280     // Copy the lookup results into the target, merging the base's access into
2281     // the path access.
2282     for (auto I = Result.begin(), E = Result.end(); I != E; ++I) {
2283       R.addDecl(I.getDecl(),
2284                 CXXRecordDecl::MergeAccess(BaseSpec.getAccessSpecifier(),
2285                                            I.getAccess()));
2286     }
2287 
2288     Result.suppressDiagnostics();
2289   }
2290 
2291   R.resolveKind();
2292   R.setNamingClass(Class);
2293 
2294   return !R.empty();
2295 }
2296 
2297 /// \brief Produce a diagnostic describing the ambiguity that resulted
2298 /// from name lookup.
2299 ///
2300 /// \param Result The result of the ambiguous lookup to be diagnosed.
DiagnoseAmbiguousLookup(LookupResult & Result)2301 void Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {
2302   assert(Result.isAmbiguous() && "Lookup result must be ambiguous");
2303 
2304   DeclarationName Name = Result.getLookupName();
2305   SourceLocation NameLoc = Result.getNameLoc();
2306   SourceRange LookupRange = Result.getContextRange();
2307 
2308   switch (Result.getAmbiguityKind()) {
2309   case LookupResult::AmbiguousBaseSubobjects: {
2310     CXXBasePaths *Paths = Result.getBasePaths();
2311     QualType SubobjectType = Paths->front().back().Base->getType();
2312     Diag(NameLoc, diag::err_ambiguous_member_multiple_subobjects)
2313       << Name << SubobjectType << getAmbiguousPathsDisplayString(*Paths)
2314       << LookupRange;
2315 
2316     DeclContext::lookup_iterator Found = Paths->front().Decls.begin();
2317     while (isa<CXXMethodDecl>(*Found) &&
2318            cast<CXXMethodDecl>(*Found)->isStatic())
2319       ++Found;
2320 
2321     Diag((*Found)->getLocation(), diag::note_ambiguous_member_found);
2322     break;
2323   }
2324 
2325   case LookupResult::AmbiguousBaseSubobjectTypes: {
2326     Diag(NameLoc, diag::err_ambiguous_member_multiple_subobject_types)
2327       << Name << LookupRange;
2328 
2329     CXXBasePaths *Paths = Result.getBasePaths();
2330     std::set<Decl *> DeclsPrinted;
2331     for (CXXBasePaths::paths_iterator Path = Paths->begin(),
2332                                       PathEnd = Paths->end();
2333          Path != PathEnd; ++Path) {
2334       Decl *D = Path->Decls.front();
2335       if (DeclsPrinted.insert(D).second)
2336         Diag(D->getLocation(), diag::note_ambiguous_member_found);
2337     }
2338     break;
2339   }
2340 
2341   case LookupResult::AmbiguousTagHiding: {
2342     Diag(NameLoc, diag::err_ambiguous_tag_hiding) << Name << LookupRange;
2343 
2344     llvm::SmallPtrSet<NamedDecl*, 8> TagDecls;
2345 
2346     for (auto *D : Result)
2347       if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
2348         TagDecls.insert(TD);
2349         Diag(TD->getLocation(), diag::note_hidden_tag);
2350       }
2351 
2352     for (auto *D : Result)
2353       if (!isa<TagDecl>(D))
2354         Diag(D->getLocation(), diag::note_hiding_object);
2355 
2356     // For recovery purposes, go ahead and implement the hiding.
2357     LookupResult::Filter F = Result.makeFilter();
2358     while (F.hasNext()) {
2359       if (TagDecls.count(F.next()))
2360         F.erase();
2361     }
2362     F.done();
2363     break;
2364   }
2365 
2366   case LookupResult::AmbiguousReference: {
2367     Diag(NameLoc, diag::err_ambiguous_reference) << Name << LookupRange;
2368 
2369     for (auto *D : Result)
2370       Diag(D->getLocation(), diag::note_ambiguous_candidate) << D;
2371     break;
2372   }
2373   }
2374 }
2375 
2376 namespace {
2377   struct AssociatedLookup {
AssociatedLookup__anon19e32a9a0511::AssociatedLookup2378     AssociatedLookup(Sema &S, SourceLocation InstantiationLoc,
2379                      Sema::AssociatedNamespaceSet &Namespaces,
2380                      Sema::AssociatedClassSet &Classes)
2381       : S(S), Namespaces(Namespaces), Classes(Classes),
2382         InstantiationLoc(InstantiationLoc) {
2383     }
2384 
2385     Sema &S;
2386     Sema::AssociatedNamespaceSet &Namespaces;
2387     Sema::AssociatedClassSet &Classes;
2388     SourceLocation InstantiationLoc;
2389   };
2390 } // end anonymous namespace
2391 
2392 static void
2393 addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType T);
2394 
CollectEnclosingNamespace(Sema::AssociatedNamespaceSet & Namespaces,DeclContext * Ctx)2395 static void CollectEnclosingNamespace(Sema::AssociatedNamespaceSet &Namespaces,
2396                                       DeclContext *Ctx) {
2397   // Add the associated namespace for this class.
2398 
2399   // We don't use DeclContext::getEnclosingNamespaceContext() as this may
2400   // be a locally scoped record.
2401 
2402   // We skip out of inline namespaces. The innermost non-inline namespace
2403   // contains all names of all its nested inline namespaces anyway, so we can
2404   // replace the entire inline namespace tree with its root.
2405   while (Ctx->isRecord() || Ctx->isTransparentContext() ||
2406          Ctx->isInlineNamespace())
2407     Ctx = Ctx->getParent();
2408 
2409   if (Ctx->isFileContext())
2410     Namespaces.insert(Ctx->getPrimaryContext());
2411 }
2412 
2413 // \brief Add the associated classes and namespaces for argument-dependent
2414 // lookup that involves a template argument (C++ [basic.lookup.koenig]p2).
2415 static void
addAssociatedClassesAndNamespaces(AssociatedLookup & Result,const TemplateArgument & Arg)2416 addAssociatedClassesAndNamespaces(AssociatedLookup &Result,
2417                                   const TemplateArgument &Arg) {
2418   // C++ [basic.lookup.koenig]p2, last bullet:
2419   //   -- [...] ;
2420   switch (Arg.getKind()) {
2421     case TemplateArgument::Null:
2422       break;
2423 
2424     case TemplateArgument::Type:
2425       // [...] the namespaces and classes associated with the types of the
2426       // template arguments provided for template type parameters (excluding
2427       // template template parameters)
2428       addAssociatedClassesAndNamespaces(Result, Arg.getAsType());
2429       break;
2430 
2431     case TemplateArgument::Template:
2432     case TemplateArgument::TemplateExpansion: {
2433       // [...] the namespaces in which any template template arguments are
2434       // defined; and the classes in which any member templates used as
2435       // template template arguments are defined.
2436       TemplateName Template = Arg.getAsTemplateOrTemplatePattern();
2437       if (ClassTemplateDecl *ClassTemplate
2438                  = dyn_cast<ClassTemplateDecl>(Template.getAsTemplateDecl())) {
2439         DeclContext *Ctx = ClassTemplate->getDeclContext();
2440         if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))
2441           Result.Classes.insert(EnclosingClass);
2442         // Add the associated namespace for this class.
2443         CollectEnclosingNamespace(Result.Namespaces, Ctx);
2444       }
2445       break;
2446     }
2447 
2448     case TemplateArgument::Declaration:
2449     case TemplateArgument::Integral:
2450     case TemplateArgument::Expression:
2451     case TemplateArgument::NullPtr:
2452       // [Note: non-type template arguments do not contribute to the set of
2453       //  associated namespaces. ]
2454       break;
2455 
2456     case TemplateArgument::Pack:
2457       for (const auto &P : Arg.pack_elements())
2458         addAssociatedClassesAndNamespaces(Result, P);
2459       break;
2460   }
2461 }
2462 
2463 // \brief Add the associated classes and namespaces for
2464 // argument-dependent lookup with an argument of class type
2465 // (C++ [basic.lookup.koenig]p2).
2466 static void
addAssociatedClassesAndNamespaces(AssociatedLookup & Result,CXXRecordDecl * Class)2467 addAssociatedClassesAndNamespaces(AssociatedLookup &Result,
2468                                   CXXRecordDecl *Class) {
2469 
2470   // Just silently ignore anything whose name is __va_list_tag.
2471   if (Class->getDeclName() == Result.S.VAListTagName)
2472     return;
2473 
2474   // C++ [basic.lookup.koenig]p2:
2475   //   [...]
2476   //     -- If T is a class type (including unions), its associated
2477   //        classes are: the class itself; the class of which it is a
2478   //        member, if any; and its direct and indirect base
2479   //        classes. Its associated namespaces are the namespaces in
2480   //        which its associated classes are defined.
2481 
2482   // Add the class of which it is a member, if any.
2483   DeclContext *Ctx = Class->getDeclContext();
2484   if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))
2485     Result.Classes.insert(EnclosingClass);
2486   // Add the associated namespace for this class.
2487   CollectEnclosingNamespace(Result.Namespaces, Ctx);
2488 
2489   // Add the class itself. If we've already seen this class, we don't
2490   // need to visit base classes.
2491   //
2492   // FIXME: That's not correct, we may have added this class only because it
2493   // was the enclosing class of another class, and in that case we won't have
2494   // added its base classes yet.
2495   if (!Result.Classes.insert(Class))
2496     return;
2497 
2498   // -- If T is a template-id, its associated namespaces and classes are
2499   //    the namespace in which the template is defined; for member
2500   //    templates, the member template's class; the namespaces and classes
2501   //    associated with the types of the template arguments provided for
2502   //    template type parameters (excluding template template parameters); the
2503   //    namespaces in which any template template arguments are defined; and
2504   //    the classes in which any member templates used as template template
2505   //    arguments are defined. [Note: non-type template arguments do not
2506   //    contribute to the set of associated namespaces. ]
2507   if (ClassTemplateSpecializationDecl *Spec
2508         = dyn_cast<ClassTemplateSpecializationDecl>(Class)) {
2509     DeclContext *Ctx = Spec->getSpecializedTemplate()->getDeclContext();
2510     if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))
2511       Result.Classes.insert(EnclosingClass);
2512     // Add the associated namespace for this class.
2513     CollectEnclosingNamespace(Result.Namespaces, Ctx);
2514 
2515     const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
2516     for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
2517       addAssociatedClassesAndNamespaces(Result, TemplateArgs[I]);
2518   }
2519 
2520   // Only recurse into base classes for complete types.
2521   if (!Result.S.isCompleteType(Result.InstantiationLoc,
2522                                Result.S.Context.getRecordType(Class)))
2523     return;
2524 
2525   // Add direct and indirect base classes along with their associated
2526   // namespaces.
2527   SmallVector<CXXRecordDecl *, 32> Bases;
2528   Bases.push_back(Class);
2529   while (!Bases.empty()) {
2530     // Pop this class off the stack.
2531     Class = Bases.pop_back_val();
2532 
2533     // Visit the base classes.
2534     for (const auto &Base : Class->bases()) {
2535       const RecordType *BaseType = Base.getType()->getAs<RecordType>();
2536       // In dependent contexts, we do ADL twice, and the first time around,
2537       // the base type might be a dependent TemplateSpecializationType, or a
2538       // TemplateTypeParmType. If that happens, simply ignore it.
2539       // FIXME: If we want to support export, we probably need to add the
2540       // namespace of the template in a TemplateSpecializationType, or even
2541       // the classes and namespaces of known non-dependent arguments.
2542       if (!BaseType)
2543         continue;
2544       CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(BaseType->getDecl());
2545       if (Result.Classes.insert(BaseDecl)) {
2546         // Find the associated namespace for this base class.
2547         DeclContext *BaseCtx = BaseDecl->getDeclContext();
2548         CollectEnclosingNamespace(Result.Namespaces, BaseCtx);
2549 
2550         // Make sure we visit the bases of this base class.
2551         if (BaseDecl->bases_begin() != BaseDecl->bases_end())
2552           Bases.push_back(BaseDecl);
2553       }
2554     }
2555   }
2556 }
2557 
2558 // \brief Add the associated classes and namespaces for
2559 // argument-dependent lookup with an argument of type T
2560 // (C++ [basic.lookup.koenig]p2).
2561 static void
addAssociatedClassesAndNamespaces(AssociatedLookup & Result,QualType Ty)2562 addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType Ty) {
2563   // C++ [basic.lookup.koenig]p2:
2564   //
2565   //   For each argument type T in the function call, there is a set
2566   //   of zero or more associated namespaces and a set of zero or more
2567   //   associated classes to be considered. The sets of namespaces and
2568   //   classes is determined entirely by the types of the function
2569   //   arguments (and the namespace of any template template
2570   //   argument). Typedef names and using-declarations used to specify
2571   //   the types do not contribute to this set. The sets of namespaces
2572   //   and classes are determined in the following way:
2573 
2574   SmallVector<const Type *, 16> Queue;
2575   const Type *T = Ty->getCanonicalTypeInternal().getTypePtr();
2576 
2577   while (true) {
2578     switch (T->getTypeClass()) {
2579 
2580 #define TYPE(Class, Base)
2581 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
2582 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
2583 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
2584 #define ABSTRACT_TYPE(Class, Base)
2585 #include "clang/AST/TypeNodes.def"
2586       // T is canonical.  We can also ignore dependent types because
2587       // we don't need to do ADL at the definition point, but if we
2588       // wanted to implement template export (or if we find some other
2589       // use for associated classes and namespaces...) this would be
2590       // wrong.
2591       break;
2592 
2593     //    -- If T is a pointer to U or an array of U, its associated
2594     //       namespaces and classes are those associated with U.
2595     case Type::Pointer:
2596       T = cast<PointerType>(T)->getPointeeType().getTypePtr();
2597       continue;
2598     case Type::ConstantArray:
2599     case Type::IncompleteArray:
2600     case Type::VariableArray:
2601       T = cast<ArrayType>(T)->getElementType().getTypePtr();
2602       continue;
2603 
2604     //     -- If T is a fundamental type, its associated sets of
2605     //        namespaces and classes are both empty.
2606     case Type::Builtin:
2607       break;
2608 
2609     //     -- If T is a class type (including unions), its associated
2610     //        classes are: the class itself; the class of which it is a
2611     //        member, if any; and its direct and indirect base
2612     //        classes. Its associated namespaces are the namespaces in
2613     //        which its associated classes are defined.
2614     case Type::Record: {
2615       CXXRecordDecl *Class =
2616           cast<CXXRecordDecl>(cast<RecordType>(T)->getDecl());
2617       addAssociatedClassesAndNamespaces(Result, Class);
2618       break;
2619     }
2620 
2621     //     -- If T is an enumeration type, its associated namespace is
2622     //        the namespace in which it is defined. If it is class
2623     //        member, its associated class is the member's class; else
2624     //        it has no associated class.
2625     case Type::Enum: {
2626       EnumDecl *Enum = cast<EnumType>(T)->getDecl();
2627 
2628       DeclContext *Ctx = Enum->getDeclContext();
2629       if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))
2630         Result.Classes.insert(EnclosingClass);
2631 
2632       // Add the associated namespace for this class.
2633       CollectEnclosingNamespace(Result.Namespaces, Ctx);
2634 
2635       break;
2636     }
2637 
2638     //     -- If T is a function type, its associated namespaces and
2639     //        classes are those associated with the function parameter
2640     //        types and those associated with the return type.
2641     case Type::FunctionProto: {
2642       const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
2643       for (const auto &Arg : Proto->param_types())
2644         Queue.push_back(Arg.getTypePtr());
2645       // fallthrough
2646     }
2647     case Type::FunctionNoProto: {
2648       const FunctionType *FnType = cast<FunctionType>(T);
2649       T = FnType->getReturnType().getTypePtr();
2650       continue;
2651     }
2652 
2653     //     -- If T is a pointer to a member function of a class X, its
2654     //        associated namespaces and classes are those associated
2655     //        with the function parameter types and return type,
2656     //        together with those associated with X.
2657     //
2658     //     -- If T is a pointer to a data member of class X, its
2659     //        associated namespaces and classes are those associated
2660     //        with the member type together with those associated with
2661     //        X.
2662     case Type::MemberPointer: {
2663       const MemberPointerType *MemberPtr = cast<MemberPointerType>(T);
2664 
2665       // Queue up the class type into which this points.
2666       Queue.push_back(MemberPtr->getClass());
2667 
2668       // And directly continue with the pointee type.
2669       T = MemberPtr->getPointeeType().getTypePtr();
2670       continue;
2671     }
2672 
2673     // As an extension, treat this like a normal pointer.
2674     case Type::BlockPointer:
2675       T = cast<BlockPointerType>(T)->getPointeeType().getTypePtr();
2676       continue;
2677 
2678     // References aren't covered by the standard, but that's such an
2679     // obvious defect that we cover them anyway.
2680     case Type::LValueReference:
2681     case Type::RValueReference:
2682       T = cast<ReferenceType>(T)->getPointeeType().getTypePtr();
2683       continue;
2684 
2685     // These are fundamental types.
2686     case Type::Vector:
2687     case Type::ExtVector:
2688     case Type::Complex:
2689       break;
2690 
2691     // Non-deduced auto types only get here for error cases.
2692     case Type::Auto:
2693       break;
2694 
2695     // If T is an Objective-C object or interface type, or a pointer to an
2696     // object or interface type, the associated namespace is the global
2697     // namespace.
2698     case Type::ObjCObject:
2699     case Type::ObjCInterface:
2700     case Type::ObjCObjectPointer:
2701       Result.Namespaces.insert(Result.S.Context.getTranslationUnitDecl());
2702       break;
2703 
2704     // Atomic types are just wrappers; use the associations of the
2705     // contained type.
2706     case Type::Atomic:
2707       T = cast<AtomicType>(T)->getValueType().getTypePtr();
2708       continue;
2709     case Type::Pipe:
2710       T = cast<PipeType>(T)->getElementType().getTypePtr();
2711       continue;
2712     }
2713 
2714     if (Queue.empty())
2715       break;
2716     T = Queue.pop_back_val();
2717   }
2718 }
2719 
2720 /// \brief Find the associated classes and namespaces for
2721 /// argument-dependent lookup for a call with the given set of
2722 /// arguments.
2723 ///
2724 /// This routine computes the sets of associated classes and associated
2725 /// namespaces searched by argument-dependent lookup
2726 /// (C++ [basic.lookup.argdep]) for a given set of arguments.
FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc,ArrayRef<Expr * > Args,AssociatedNamespaceSet & AssociatedNamespaces,AssociatedClassSet & AssociatedClasses)2727 void Sema::FindAssociatedClassesAndNamespaces(
2728     SourceLocation InstantiationLoc, ArrayRef<Expr *> Args,
2729     AssociatedNamespaceSet &AssociatedNamespaces,
2730     AssociatedClassSet &AssociatedClasses) {
2731   AssociatedNamespaces.clear();
2732   AssociatedClasses.clear();
2733 
2734   AssociatedLookup Result(*this, InstantiationLoc,
2735                           AssociatedNamespaces, AssociatedClasses);
2736 
2737   // C++ [basic.lookup.koenig]p2:
2738   //   For each argument type T in the function call, there is a set
2739   //   of zero or more associated namespaces and a set of zero or more
2740   //   associated classes to be considered. The sets of namespaces and
2741   //   classes is determined entirely by the types of the function
2742   //   arguments (and the namespace of any template template
2743   //   argument).
2744   for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
2745     Expr *Arg = Args[ArgIdx];
2746 
2747     if (Arg->getType() != Context.OverloadTy) {
2748       addAssociatedClassesAndNamespaces(Result, Arg->getType());
2749       continue;
2750     }
2751 
2752     // [...] In addition, if the argument is the name or address of a
2753     // set of overloaded functions and/or function templates, its
2754     // associated classes and namespaces are the union of those
2755     // associated with each of the members of the set: the namespace
2756     // in which the function or function template is defined and the
2757     // classes and namespaces associated with its (non-dependent)
2758     // parameter types and return type.
2759     Arg = Arg->IgnoreParens();
2760     if (UnaryOperator *unaryOp = dyn_cast<UnaryOperator>(Arg))
2761       if (unaryOp->getOpcode() == UO_AddrOf)
2762         Arg = unaryOp->getSubExpr();
2763 
2764     UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Arg);
2765     if (!ULE) continue;
2766 
2767     for (const auto *D : ULE->decls()) {
2768       // Look through any using declarations to find the underlying function.
2769       const FunctionDecl *FDecl = D->getUnderlyingDecl()->getAsFunction();
2770 
2771       // Add the classes and namespaces associated with the parameter
2772       // types and return type of this function.
2773       addAssociatedClassesAndNamespaces(Result, FDecl->getType());
2774     }
2775   }
2776 }
2777 
LookupSingleName(Scope * S,DeclarationName Name,SourceLocation Loc,LookupNameKind NameKind,RedeclarationKind Redecl)2778 NamedDecl *Sema::LookupSingleName(Scope *S, DeclarationName Name,
2779                                   SourceLocation Loc,
2780                                   LookupNameKind NameKind,
2781                                   RedeclarationKind Redecl) {
2782   LookupResult R(*this, Name, Loc, NameKind, Redecl);
2783   LookupName(R, S);
2784   return R.getAsSingle<NamedDecl>();
2785 }
2786 
2787 /// \brief Find the protocol with the given name, if any.
LookupProtocol(IdentifierInfo * II,SourceLocation IdLoc,RedeclarationKind Redecl)2788 ObjCProtocolDecl *Sema::LookupProtocol(IdentifierInfo *II,
2789                                        SourceLocation IdLoc,
2790                                        RedeclarationKind Redecl) {
2791   Decl *D = LookupSingleName(TUScope, II, IdLoc,
2792                              LookupObjCProtocolName, Redecl);
2793   return cast_or_null<ObjCProtocolDecl>(D);
2794 }
2795 
LookupOverloadedOperatorName(OverloadedOperatorKind Op,Scope * S,QualType T1,QualType T2,UnresolvedSetImpl & Functions)2796 void Sema::LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
2797                                         QualType T1, QualType T2,
2798                                         UnresolvedSetImpl &Functions) {
2799   // C++ [over.match.oper]p3:
2800   //     -- The set of non-member candidates is the result of the
2801   //        unqualified lookup of operator@ in the context of the
2802   //        expression according to the usual rules for name lookup in
2803   //        unqualified function calls (3.4.2) except that all member
2804   //        functions are ignored.
2805   DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
2806   LookupResult Operators(*this, OpName, SourceLocation(), LookupOperatorName);
2807   LookupName(Operators, S);
2808 
2809   assert(!Operators.isAmbiguous() && "Operator lookup cannot be ambiguous");
2810   Functions.append(Operators.begin(), Operators.end());
2811 }
2812 
LookupSpecialMember(CXXRecordDecl * RD,CXXSpecialMember SM,bool ConstArg,bool VolatileArg,bool RValueThis,bool ConstThis,bool VolatileThis)2813 Sema::SpecialMemberOverloadResult *Sema::LookupSpecialMember(CXXRecordDecl *RD,
2814                                                             CXXSpecialMember SM,
2815                                                             bool ConstArg,
2816                                                             bool VolatileArg,
2817                                                             bool RValueThis,
2818                                                             bool ConstThis,
2819                                                             bool VolatileThis) {
2820   assert(CanDeclareSpecialMemberFunction(RD) &&
2821          "doing special member lookup into record that isn't fully complete");
2822   RD = RD->getDefinition();
2823   if (RValueThis || ConstThis || VolatileThis)
2824     assert((SM == CXXCopyAssignment || SM == CXXMoveAssignment) &&
2825            "constructors and destructors always have unqualified lvalue this");
2826   if (ConstArg || VolatileArg)
2827     assert((SM != CXXDefaultConstructor && SM != CXXDestructor) &&
2828            "parameter-less special members can't have qualified arguments");
2829 
2830   llvm::FoldingSetNodeID ID;
2831   ID.AddPointer(RD);
2832   ID.AddInteger(SM);
2833   ID.AddInteger(ConstArg);
2834   ID.AddInteger(VolatileArg);
2835   ID.AddInteger(RValueThis);
2836   ID.AddInteger(ConstThis);
2837   ID.AddInteger(VolatileThis);
2838 
2839   void *InsertPoint;
2840   SpecialMemberOverloadResult *Result =
2841     SpecialMemberCache.FindNodeOrInsertPos(ID, InsertPoint);
2842 
2843   // This was already cached
2844   if (Result)
2845     return Result;
2846 
2847   Result = BumpAlloc.Allocate<SpecialMemberOverloadResult>();
2848   Result = new (Result) SpecialMemberOverloadResult(ID);
2849   SpecialMemberCache.InsertNode(Result, InsertPoint);
2850 
2851   if (SM == CXXDestructor) {
2852     if (RD->needsImplicitDestructor())
2853       DeclareImplicitDestructor(RD);
2854     CXXDestructorDecl *DD = RD->getDestructor();
2855     assert(DD && "record without a destructor");
2856     Result->setMethod(DD);
2857     Result->setKind(DD->isDeleted() ?
2858                     SpecialMemberOverloadResult::NoMemberOrDeleted :
2859                     SpecialMemberOverloadResult::Success);
2860     return Result;
2861   }
2862 
2863   // Prepare for overload resolution. Here we construct a synthetic argument
2864   // if necessary and make sure that implicit functions are declared.
2865   CanQualType CanTy = Context.getCanonicalType(Context.getTagDeclType(RD));
2866   DeclarationName Name;
2867   Expr *Arg = nullptr;
2868   unsigned NumArgs;
2869 
2870   QualType ArgType = CanTy;
2871   ExprValueKind VK = VK_LValue;
2872 
2873   if (SM == CXXDefaultConstructor) {
2874     Name = Context.DeclarationNames.getCXXConstructorName(CanTy);
2875     NumArgs = 0;
2876     if (RD->needsImplicitDefaultConstructor())
2877       DeclareImplicitDefaultConstructor(RD);
2878   } else {
2879     if (SM == CXXCopyConstructor || SM == CXXMoveConstructor) {
2880       Name = Context.DeclarationNames.getCXXConstructorName(CanTy);
2881       if (RD->needsImplicitCopyConstructor())
2882         DeclareImplicitCopyConstructor(RD);
2883       if (getLangOpts().CPlusPlus11 && RD->needsImplicitMoveConstructor())
2884         DeclareImplicitMoveConstructor(RD);
2885     } else {
2886       Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
2887       if (RD->needsImplicitCopyAssignment())
2888         DeclareImplicitCopyAssignment(RD);
2889       if (getLangOpts().CPlusPlus11 && RD->needsImplicitMoveAssignment())
2890         DeclareImplicitMoveAssignment(RD);
2891     }
2892 
2893     if (ConstArg)
2894       ArgType.addConst();
2895     if (VolatileArg)
2896       ArgType.addVolatile();
2897 
2898     // This isn't /really/ specified by the standard, but it's implied
2899     // we should be working from an RValue in the case of move to ensure
2900     // that we prefer to bind to rvalue references, and an LValue in the
2901     // case of copy to ensure we don't bind to rvalue references.
2902     // Possibly an XValue is actually correct in the case of move, but
2903     // there is no semantic difference for class types in this restricted
2904     // case.
2905     if (SM == CXXCopyConstructor || SM == CXXCopyAssignment)
2906       VK = VK_LValue;
2907     else
2908       VK = VK_RValue;
2909   }
2910 
2911   OpaqueValueExpr FakeArg(SourceLocation(), ArgType, VK);
2912 
2913   if (SM != CXXDefaultConstructor) {
2914     NumArgs = 1;
2915     Arg = &FakeArg;
2916   }
2917 
2918   // Create the object argument
2919   QualType ThisTy = CanTy;
2920   if (ConstThis)
2921     ThisTy.addConst();
2922   if (VolatileThis)
2923     ThisTy.addVolatile();
2924   Expr::Classification Classification =
2925     OpaqueValueExpr(SourceLocation(), ThisTy,
2926                     RValueThis ? VK_RValue : VK_LValue).Classify(Context);
2927 
2928   // Now we perform lookup on the name we computed earlier and do overload
2929   // resolution. Lookup is only performed directly into the class since there
2930   // will always be a (possibly implicit) declaration to shadow any others.
2931   OverloadCandidateSet OCS(RD->getLocation(), OverloadCandidateSet::CSK_Normal);
2932   DeclContext::lookup_result R = RD->lookup(Name);
2933 
2934   if (R.empty()) {
2935     // We might have no default constructor because we have a lambda's closure
2936     // type, rather than because there's some other declared constructor.
2937     // Every class has a copy/move constructor, copy/move assignment, and
2938     // destructor.
2939     assert(SM == CXXDefaultConstructor &&
2940            "lookup for a constructor or assignment operator was empty");
2941     Result->setMethod(nullptr);
2942     Result->setKind(SpecialMemberOverloadResult::NoMemberOrDeleted);
2943     return Result;
2944   }
2945 
2946   // Copy the candidates as our processing of them may load new declarations
2947   // from an external source and invalidate lookup_result.
2948   SmallVector<NamedDecl *, 8> Candidates(R.begin(), R.end());
2949 
2950   for (NamedDecl *CandDecl : Candidates) {
2951     if (CandDecl->isInvalidDecl())
2952       continue;
2953 
2954     DeclAccessPair Cand = DeclAccessPair::make(CandDecl, AS_public);
2955     auto CtorInfo = getConstructorInfo(Cand);
2956     if (CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(Cand->getUnderlyingDecl())) {
2957       if (SM == CXXCopyAssignment || SM == CXXMoveAssignment)
2958         AddMethodCandidate(M, Cand, RD, ThisTy, Classification,
2959                            llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
2960       else if (CtorInfo)
2961         AddOverloadCandidate(CtorInfo.Constructor, CtorInfo.FoundDecl,
2962                              llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
2963       else
2964         AddOverloadCandidate(M, Cand, llvm::makeArrayRef(&Arg, NumArgs), OCS,
2965                              true);
2966     } else if (FunctionTemplateDecl *Tmpl =
2967                  dyn_cast<FunctionTemplateDecl>(Cand->getUnderlyingDecl())) {
2968       if (SM == CXXCopyAssignment || SM == CXXMoveAssignment)
2969         AddMethodTemplateCandidate(
2970             Tmpl, Cand, RD, nullptr, ThisTy, Classification,
2971             llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
2972       else if (CtorInfo)
2973         AddTemplateOverloadCandidate(
2974             CtorInfo.ConstructorTmpl, CtorInfo.FoundDecl, nullptr,
2975             llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
2976       else
2977         AddTemplateOverloadCandidate(
2978             Tmpl, Cand, nullptr, llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
2979     } else {
2980       assert(isa<UsingDecl>(Cand.getDecl()) &&
2981              "illegal Kind of operator = Decl");
2982     }
2983   }
2984 
2985   OverloadCandidateSet::iterator Best;
2986   switch (OCS.BestViableFunction(*this, SourceLocation(), Best)) {
2987     case OR_Success:
2988       Result->setMethod(cast<CXXMethodDecl>(Best->Function));
2989       Result->setKind(SpecialMemberOverloadResult::Success);
2990       break;
2991 
2992     case OR_Deleted:
2993       Result->setMethod(cast<CXXMethodDecl>(Best->Function));
2994       Result->setKind(SpecialMemberOverloadResult::NoMemberOrDeleted);
2995       break;
2996 
2997     case OR_Ambiguous:
2998       Result->setMethod(nullptr);
2999       Result->setKind(SpecialMemberOverloadResult::Ambiguous);
3000       break;
3001 
3002     case OR_No_Viable_Function:
3003       Result->setMethod(nullptr);
3004       Result->setKind(SpecialMemberOverloadResult::NoMemberOrDeleted);
3005       break;
3006   }
3007 
3008   return Result;
3009 }
3010 
3011 /// \brief Look up the default constructor for the given class.
LookupDefaultConstructor(CXXRecordDecl * Class)3012 CXXConstructorDecl *Sema::LookupDefaultConstructor(CXXRecordDecl *Class) {
3013   SpecialMemberOverloadResult *Result =
3014     LookupSpecialMember(Class, CXXDefaultConstructor, false, false, false,
3015                         false, false);
3016 
3017   return cast_or_null<CXXConstructorDecl>(Result->getMethod());
3018 }
3019 
3020 /// \brief Look up the copying constructor for the given class.
LookupCopyingConstructor(CXXRecordDecl * Class,unsigned Quals)3021 CXXConstructorDecl *Sema::LookupCopyingConstructor(CXXRecordDecl *Class,
3022                                                    unsigned Quals) {
3023   assert(!(Quals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&
3024          "non-const, non-volatile qualifiers for copy ctor arg");
3025   SpecialMemberOverloadResult *Result =
3026     LookupSpecialMember(Class, CXXCopyConstructor, Quals & Qualifiers::Const,
3027                         Quals & Qualifiers::Volatile, false, false, false);
3028 
3029   return cast_or_null<CXXConstructorDecl>(Result->getMethod());
3030 }
3031 
3032 /// \brief Look up the moving constructor for the given class.
LookupMovingConstructor(CXXRecordDecl * Class,unsigned Quals)3033 CXXConstructorDecl *Sema::LookupMovingConstructor(CXXRecordDecl *Class,
3034                                                   unsigned Quals) {
3035   SpecialMemberOverloadResult *Result =
3036     LookupSpecialMember(Class, CXXMoveConstructor, Quals & Qualifiers::Const,
3037                         Quals & Qualifiers::Volatile, false, false, false);
3038 
3039   return cast_or_null<CXXConstructorDecl>(Result->getMethod());
3040 }
3041 
3042 /// \brief Look up the constructors for the given class.
LookupConstructors(CXXRecordDecl * Class)3043 DeclContext::lookup_result Sema::LookupConstructors(CXXRecordDecl *Class) {
3044   // If the implicit constructors have not yet been declared, do so now.
3045   if (CanDeclareSpecialMemberFunction(Class)) {
3046     if (Class->needsImplicitDefaultConstructor())
3047       DeclareImplicitDefaultConstructor(Class);
3048     if (Class->needsImplicitCopyConstructor())
3049       DeclareImplicitCopyConstructor(Class);
3050     if (getLangOpts().CPlusPlus11 && Class->needsImplicitMoveConstructor())
3051       DeclareImplicitMoveConstructor(Class);
3052   }
3053 
3054   CanQualType T = Context.getCanonicalType(Context.getTypeDeclType(Class));
3055   DeclarationName Name = Context.DeclarationNames.getCXXConstructorName(T);
3056   return Class->lookup(Name);
3057 }
3058 
3059 /// \brief Look up the copying assignment operator for the given class.
LookupCopyingAssignment(CXXRecordDecl * Class,unsigned Quals,bool RValueThis,unsigned ThisQuals)3060 CXXMethodDecl *Sema::LookupCopyingAssignment(CXXRecordDecl *Class,
3061                                              unsigned Quals, bool RValueThis,
3062                                              unsigned ThisQuals) {
3063   assert(!(Quals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&
3064          "non-const, non-volatile qualifiers for copy assignment arg");
3065   assert(!(ThisQuals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&
3066          "non-const, non-volatile qualifiers for copy assignment this");
3067   SpecialMemberOverloadResult *Result =
3068     LookupSpecialMember(Class, CXXCopyAssignment, Quals & Qualifiers::Const,
3069                         Quals & Qualifiers::Volatile, RValueThis,
3070                         ThisQuals & Qualifiers::Const,
3071                         ThisQuals & Qualifiers::Volatile);
3072 
3073   return Result->getMethod();
3074 }
3075 
3076 /// \brief Look up the moving assignment operator for the given class.
LookupMovingAssignment(CXXRecordDecl * Class,unsigned Quals,bool RValueThis,unsigned ThisQuals)3077 CXXMethodDecl *Sema::LookupMovingAssignment(CXXRecordDecl *Class,
3078                                             unsigned Quals,
3079                                             bool RValueThis,
3080                                             unsigned ThisQuals) {
3081   assert(!(ThisQuals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&
3082          "non-const, non-volatile qualifiers for copy assignment this");
3083   SpecialMemberOverloadResult *Result =
3084     LookupSpecialMember(Class, CXXMoveAssignment, Quals & Qualifiers::Const,
3085                         Quals & Qualifiers::Volatile, RValueThis,
3086                         ThisQuals & Qualifiers::Const,
3087                         ThisQuals & Qualifiers::Volatile);
3088 
3089   return Result->getMethod();
3090 }
3091 
3092 /// \brief Look for the destructor of the given class.
3093 ///
3094 /// During semantic analysis, this routine should be used in lieu of
3095 /// CXXRecordDecl::getDestructor().
3096 ///
3097 /// \returns The destructor for this class.
LookupDestructor(CXXRecordDecl * Class)3098 CXXDestructorDecl *Sema::LookupDestructor(CXXRecordDecl *Class) {
3099   return cast<CXXDestructorDecl>(LookupSpecialMember(Class, CXXDestructor,
3100                                                      false, false, false,
3101                                                      false, false)->getMethod());
3102 }
3103 
3104 /// LookupLiteralOperator - Determine which literal operator should be used for
3105 /// a user-defined literal, per C++11 [lex.ext].
3106 ///
3107 /// Normal overload resolution is not used to select which literal operator to
3108 /// call for a user-defined literal. Look up the provided literal operator name,
3109 /// and filter the results to the appropriate set for the given argument types.
3110 Sema::LiteralOperatorLookupResult
LookupLiteralOperator(Scope * S,LookupResult & R,ArrayRef<QualType> ArgTys,bool AllowRaw,bool AllowTemplate,bool AllowStringTemplate)3111 Sema::LookupLiteralOperator(Scope *S, LookupResult &R,
3112                             ArrayRef<QualType> ArgTys,
3113                             bool AllowRaw, bool AllowTemplate,
3114                             bool AllowStringTemplate) {
3115   LookupName(R, S);
3116   assert(R.getResultKind() != LookupResult::Ambiguous &&
3117          "literal operator lookup can't be ambiguous");
3118 
3119   // Filter the lookup results appropriately.
3120   LookupResult::Filter F = R.makeFilter();
3121 
3122   bool FoundRaw = false;
3123   bool FoundTemplate = false;
3124   bool FoundStringTemplate = false;
3125   bool FoundExactMatch = false;
3126 
3127   while (F.hasNext()) {
3128     Decl *D = F.next();
3129     if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D))
3130       D = USD->getTargetDecl();
3131 
3132     // If the declaration we found is invalid, skip it.
3133     if (D->isInvalidDecl()) {
3134       F.erase();
3135       continue;
3136     }
3137 
3138     bool IsRaw = false;
3139     bool IsTemplate = false;
3140     bool IsStringTemplate = false;
3141     bool IsExactMatch = false;
3142 
3143     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
3144       if (FD->getNumParams() == 1 &&
3145           FD->getParamDecl(0)->getType()->getAs<PointerType>())
3146         IsRaw = true;
3147       else if (FD->getNumParams() == ArgTys.size()) {
3148         IsExactMatch = true;
3149         for (unsigned ArgIdx = 0; ArgIdx != ArgTys.size(); ++ArgIdx) {
3150           QualType ParamTy = FD->getParamDecl(ArgIdx)->getType();
3151           if (!Context.hasSameUnqualifiedType(ArgTys[ArgIdx], ParamTy)) {
3152             IsExactMatch = false;
3153             break;
3154           }
3155         }
3156       }
3157     }
3158     if (FunctionTemplateDecl *FD = dyn_cast<FunctionTemplateDecl>(D)) {
3159       TemplateParameterList *Params = FD->getTemplateParameters();
3160       if (Params->size() == 1)
3161         IsTemplate = true;
3162       else
3163         IsStringTemplate = true;
3164     }
3165 
3166     if (IsExactMatch) {
3167       FoundExactMatch = true;
3168       AllowRaw = false;
3169       AllowTemplate = false;
3170       AllowStringTemplate = false;
3171       if (FoundRaw || FoundTemplate || FoundStringTemplate) {
3172         // Go through again and remove the raw and template decls we've
3173         // already found.
3174         F.restart();
3175         FoundRaw = FoundTemplate = FoundStringTemplate = false;
3176       }
3177     } else if (AllowRaw && IsRaw) {
3178       FoundRaw = true;
3179     } else if (AllowTemplate && IsTemplate) {
3180       FoundTemplate = true;
3181     } else if (AllowStringTemplate && IsStringTemplate) {
3182       FoundStringTemplate = true;
3183     } else {
3184       F.erase();
3185     }
3186   }
3187 
3188   F.done();
3189 
3190   // C++11 [lex.ext]p3, p4: If S contains a literal operator with a matching
3191   // parameter type, that is used in preference to a raw literal operator
3192   // or literal operator template.
3193   if (FoundExactMatch)
3194     return LOLR_Cooked;
3195 
3196   // C++11 [lex.ext]p3, p4: S shall contain a raw literal operator or a literal
3197   // operator template, but not both.
3198   if (FoundRaw && FoundTemplate) {
3199     Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call) << R.getLookupName();
3200     for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
3201       NoteOverloadCandidate(*I, (*I)->getUnderlyingDecl()->getAsFunction());
3202     return LOLR_Error;
3203   }
3204 
3205   if (FoundRaw)
3206     return LOLR_Raw;
3207 
3208   if (FoundTemplate)
3209     return LOLR_Template;
3210 
3211   if (FoundStringTemplate)
3212     return LOLR_StringTemplate;
3213 
3214   // Didn't find anything we could use.
3215   Diag(R.getNameLoc(), diag::err_ovl_no_viable_literal_operator)
3216     << R.getLookupName() << (int)ArgTys.size() << ArgTys[0]
3217     << (ArgTys.size() == 2 ? ArgTys[1] : QualType()) << AllowRaw
3218     << (AllowTemplate || AllowStringTemplate);
3219   return LOLR_Error;
3220 }
3221 
insert(NamedDecl * New)3222 void ADLResult::insert(NamedDecl *New) {
3223   NamedDecl *&Old = Decls[cast<NamedDecl>(New->getCanonicalDecl())];
3224 
3225   // If we haven't yet seen a decl for this key, or the last decl
3226   // was exactly this one, we're done.
3227   if (Old == nullptr || Old == New) {
3228     Old = New;
3229     return;
3230   }
3231 
3232   // Otherwise, decide which is a more recent redeclaration.
3233   FunctionDecl *OldFD = Old->getAsFunction();
3234   FunctionDecl *NewFD = New->getAsFunction();
3235 
3236   FunctionDecl *Cursor = NewFD;
3237   while (true) {
3238     Cursor = Cursor->getPreviousDecl();
3239 
3240     // If we got to the end without finding OldFD, OldFD is the newer
3241     // declaration;  leave things as they are.
3242     if (!Cursor) return;
3243 
3244     // If we do find OldFD, then NewFD is newer.
3245     if (Cursor == OldFD) break;
3246 
3247     // Otherwise, keep looking.
3248   }
3249 
3250   Old = New;
3251 }
3252 
ArgumentDependentLookup(DeclarationName Name,SourceLocation Loc,ArrayRef<Expr * > Args,ADLResult & Result)3253 void Sema::ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc,
3254                                    ArrayRef<Expr *> Args, ADLResult &Result) {
3255   // Find all of the associated namespaces and classes based on the
3256   // arguments we have.
3257   AssociatedNamespaceSet AssociatedNamespaces;
3258   AssociatedClassSet AssociatedClasses;
3259   FindAssociatedClassesAndNamespaces(Loc, Args,
3260                                      AssociatedNamespaces,
3261                                      AssociatedClasses);
3262 
3263   // C++ [basic.lookup.argdep]p3:
3264   //   Let X be the lookup set produced by unqualified lookup (3.4.1)
3265   //   and let Y be the lookup set produced by argument dependent
3266   //   lookup (defined as follows). If X contains [...] then Y is
3267   //   empty. Otherwise Y is the set of declarations found in the
3268   //   namespaces associated with the argument types as described
3269   //   below. The set of declarations found by the lookup of the name
3270   //   is the union of X and Y.
3271   //
3272   // Here, we compute Y and add its members to the overloaded
3273   // candidate set.
3274   for (auto *NS : AssociatedNamespaces) {
3275     //   When considering an associated namespace, the lookup is the
3276     //   same as the lookup performed when the associated namespace is
3277     //   used as a qualifier (3.4.3.2) except that:
3278     //
3279     //     -- Any using-directives in the associated namespace are
3280     //        ignored.
3281     //
3282     //     -- Any namespace-scope friend functions declared in
3283     //        associated classes are visible within their respective
3284     //        namespaces even if they are not visible during an ordinary
3285     //        lookup (11.4).
3286     DeclContext::lookup_result R = NS->lookup(Name);
3287     for (auto *D : R) {
3288       // If the only declaration here is an ordinary friend, consider
3289       // it only if it was declared in an associated classes.
3290       if ((D->getIdentifierNamespace() & Decl::IDNS_Ordinary) == 0) {
3291         // If it's neither ordinarily visible nor a friend, we can't find it.
3292         if ((D->getIdentifierNamespace() & Decl::IDNS_OrdinaryFriend) == 0)
3293           continue;
3294 
3295         bool DeclaredInAssociatedClass = false;
3296         for (Decl *DI = D; DI; DI = DI->getPreviousDecl()) {
3297           DeclContext *LexDC = DI->getLexicalDeclContext();
3298           if (isa<CXXRecordDecl>(LexDC) &&
3299               AssociatedClasses.count(cast<CXXRecordDecl>(LexDC)) &&
3300               isVisible(cast<NamedDecl>(DI))) {
3301             DeclaredInAssociatedClass = true;
3302             break;
3303           }
3304         }
3305         if (!DeclaredInAssociatedClass)
3306           continue;
3307       }
3308 
3309       if (isa<UsingShadowDecl>(D))
3310         D = cast<UsingShadowDecl>(D)->getTargetDecl();
3311 
3312       if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D))
3313         continue;
3314 
3315       if (!isVisible(D) && !(D = findAcceptableDecl(*this, D)))
3316         continue;
3317 
3318       Result.insert(D);
3319     }
3320   }
3321 }
3322 
3323 //----------------------------------------------------------------------------
3324 // Search for all visible declarations.
3325 //----------------------------------------------------------------------------
~VisibleDeclConsumer()3326 VisibleDeclConsumer::~VisibleDeclConsumer() { }
3327 
includeHiddenDecls() const3328 bool VisibleDeclConsumer::includeHiddenDecls() const { return false; }
3329 
3330 namespace {
3331 
3332 class ShadowContextRAII;
3333 
3334 class VisibleDeclsRecord {
3335 public:
3336   /// \brief An entry in the shadow map, which is optimized to store a
3337   /// single declaration (the common case) but can also store a list
3338   /// of declarations.
3339   typedef llvm::TinyPtrVector<NamedDecl*> ShadowMapEntry;
3340 
3341 private:
3342   /// \brief A mapping from declaration names to the declarations that have
3343   /// this name within a particular scope.
3344   typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
3345 
3346   /// \brief A list of shadow maps, which is used to model name hiding.
3347   std::list<ShadowMap> ShadowMaps;
3348 
3349   /// \brief The declaration contexts we have already visited.
3350   llvm::SmallPtrSet<DeclContext *, 8> VisitedContexts;
3351 
3352   friend class ShadowContextRAII;
3353 
3354 public:
3355   /// \brief Determine whether we have already visited this context
3356   /// (and, if not, note that we are going to visit that context now).
visitedContext(DeclContext * Ctx)3357   bool visitedContext(DeclContext *Ctx) {
3358     return !VisitedContexts.insert(Ctx).second;
3359   }
3360 
alreadyVisitedContext(DeclContext * Ctx)3361   bool alreadyVisitedContext(DeclContext *Ctx) {
3362     return VisitedContexts.count(Ctx);
3363   }
3364 
3365   /// \brief Determine whether the given declaration is hidden in the
3366   /// current scope.
3367   ///
3368   /// \returns the declaration that hides the given declaration, or
3369   /// NULL if no such declaration exists.
3370   NamedDecl *checkHidden(NamedDecl *ND);
3371 
3372   /// \brief Add a declaration to the current shadow map.
add(NamedDecl * ND)3373   void add(NamedDecl *ND) {
3374     ShadowMaps.back()[ND->getDeclName()].push_back(ND);
3375   }
3376 };
3377 
3378 /// \brief RAII object that records when we've entered a shadow context.
3379 class ShadowContextRAII {
3380   VisibleDeclsRecord &Visible;
3381 
3382   typedef VisibleDeclsRecord::ShadowMap ShadowMap;
3383 
3384 public:
ShadowContextRAII(VisibleDeclsRecord & Visible)3385   ShadowContextRAII(VisibleDeclsRecord &Visible) : Visible(Visible) {
3386     Visible.ShadowMaps.emplace_back();
3387   }
3388 
~ShadowContextRAII()3389   ~ShadowContextRAII() {
3390     Visible.ShadowMaps.pop_back();
3391   }
3392 };
3393 
3394 } // end anonymous namespace
3395 
checkHidden(NamedDecl * ND)3396 NamedDecl *VisibleDeclsRecord::checkHidden(NamedDecl *ND) {
3397   unsigned IDNS = ND->getIdentifierNamespace();
3398   std::list<ShadowMap>::reverse_iterator SM = ShadowMaps.rbegin();
3399   for (std::list<ShadowMap>::reverse_iterator SMEnd = ShadowMaps.rend();
3400        SM != SMEnd; ++SM) {
3401     ShadowMap::iterator Pos = SM->find(ND->getDeclName());
3402     if (Pos == SM->end())
3403       continue;
3404 
3405     for (auto *D : Pos->second) {
3406       // A tag declaration does not hide a non-tag declaration.
3407       if (D->hasTagIdentifierNamespace() &&
3408           (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
3409                    Decl::IDNS_ObjCProtocol)))
3410         continue;
3411 
3412       // Protocols are in distinct namespaces from everything else.
3413       if (((D->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol)
3414            || (IDNS & Decl::IDNS_ObjCProtocol)) &&
3415           D->getIdentifierNamespace() != IDNS)
3416         continue;
3417 
3418       // Functions and function templates in the same scope overload
3419       // rather than hide.  FIXME: Look for hiding based on function
3420       // signatures!
3421       if (D->getUnderlyingDecl()->isFunctionOrFunctionTemplate() &&
3422           ND->getUnderlyingDecl()->isFunctionOrFunctionTemplate() &&
3423           SM == ShadowMaps.rbegin())
3424         continue;
3425 
3426       // We've found a declaration that hides this one.
3427       return D;
3428     }
3429   }
3430 
3431   return nullptr;
3432 }
3433 
LookupVisibleDecls(DeclContext * Ctx,LookupResult & Result,bool QualifiedNameLookup,bool InBaseClass,VisibleDeclConsumer & Consumer,VisibleDeclsRecord & Visited)3434 static void LookupVisibleDecls(DeclContext *Ctx, LookupResult &Result,
3435                                bool QualifiedNameLookup,
3436                                bool InBaseClass,
3437                                VisibleDeclConsumer &Consumer,
3438                                VisibleDeclsRecord &Visited) {
3439   if (!Ctx)
3440     return;
3441 
3442   // Make sure we don't visit the same context twice.
3443   if (Visited.visitedContext(Ctx->getPrimaryContext()))
3444     return;
3445 
3446   // Outside C++, lookup results for the TU live on identifiers.
3447   if (isa<TranslationUnitDecl>(Ctx) &&
3448       !Result.getSema().getLangOpts().CPlusPlus) {
3449     auto &S = Result.getSema();
3450     auto &Idents = S.Context.Idents;
3451 
3452     // Ensure all external identifiers are in the identifier table.
3453     if (IdentifierInfoLookup *External = Idents.getExternalIdentifierLookup()) {
3454       std::unique_ptr<IdentifierIterator> Iter(External->getIdentifiers());
3455       for (StringRef Name = Iter->Next(); !Name.empty(); Name = Iter->Next())
3456         Idents.get(Name);
3457     }
3458 
3459     // Walk all lookup results in the TU for each identifier.
3460     for (const auto &Ident : Idents) {
3461       for (auto I = S.IdResolver.begin(Ident.getValue()),
3462                 E = S.IdResolver.end();
3463            I != E; ++I) {
3464         if (S.IdResolver.isDeclInScope(*I, Ctx)) {
3465           if (NamedDecl *ND = Result.getAcceptableDecl(*I)) {
3466             Consumer.FoundDecl(ND, Visited.checkHidden(ND), Ctx, InBaseClass);
3467             Visited.add(ND);
3468           }
3469         }
3470       }
3471     }
3472 
3473     return;
3474   }
3475 
3476   if (CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(Ctx))
3477     Result.getSema().ForceDeclarationOfImplicitMembers(Class);
3478 
3479   // Enumerate all of the results in this context.
3480   for (DeclContextLookupResult R : Ctx->lookups()) {
3481     for (auto *D : R) {
3482       if (auto *ND = Result.getAcceptableDecl(D)) {
3483         Consumer.FoundDecl(ND, Visited.checkHidden(ND), Ctx, InBaseClass);
3484         Visited.add(ND);
3485       }
3486     }
3487   }
3488 
3489   // Traverse using directives for qualified name lookup.
3490   if (QualifiedNameLookup) {
3491     ShadowContextRAII Shadow(Visited);
3492     for (auto I : Ctx->using_directives()) {
3493       LookupVisibleDecls(I->getNominatedNamespace(), Result,
3494                          QualifiedNameLookup, InBaseClass, Consumer, Visited);
3495     }
3496   }
3497 
3498   // Traverse the contexts of inherited C++ classes.
3499   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx)) {
3500     if (!Record->hasDefinition())
3501       return;
3502 
3503     for (const auto &B : Record->bases()) {
3504       QualType BaseType = B.getType();
3505 
3506       // Don't look into dependent bases, because name lookup can't look
3507       // there anyway.
3508       if (BaseType->isDependentType())
3509         continue;
3510 
3511       const RecordType *Record = BaseType->getAs<RecordType>();
3512       if (!Record)
3513         continue;
3514 
3515       // FIXME: It would be nice to be able to determine whether referencing
3516       // a particular member would be ambiguous. For example, given
3517       //
3518       //   struct A { int member; };
3519       //   struct B { int member; };
3520       //   struct C : A, B { };
3521       //
3522       //   void f(C *c) { c->### }
3523       //
3524       // accessing 'member' would result in an ambiguity. However, we
3525       // could be smart enough to qualify the member with the base
3526       // class, e.g.,
3527       //
3528       //   c->B::member
3529       //
3530       // or
3531       //
3532       //   c->A::member
3533 
3534       // Find results in this base class (and its bases).
3535       ShadowContextRAII Shadow(Visited);
3536       LookupVisibleDecls(Record->getDecl(), Result, QualifiedNameLookup,
3537                          true, Consumer, Visited);
3538     }
3539   }
3540 
3541   // Traverse the contexts of Objective-C classes.
3542   if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Ctx)) {
3543     // Traverse categories.
3544     for (auto *Cat : IFace->visible_categories()) {
3545       ShadowContextRAII Shadow(Visited);
3546       LookupVisibleDecls(Cat, Result, QualifiedNameLookup, false,
3547                          Consumer, Visited);
3548     }
3549 
3550     // Traverse protocols.
3551     for (auto *I : IFace->all_referenced_protocols()) {
3552       ShadowContextRAII Shadow(Visited);
3553       LookupVisibleDecls(I, Result, QualifiedNameLookup, false, Consumer,
3554                          Visited);
3555     }
3556 
3557     // Traverse the superclass.
3558     if (IFace->getSuperClass()) {
3559       ShadowContextRAII Shadow(Visited);
3560       LookupVisibleDecls(IFace->getSuperClass(), Result, QualifiedNameLookup,
3561                          true, Consumer, Visited);
3562     }
3563 
3564     // If there is an implementation, traverse it. We do this to find
3565     // synthesized ivars.
3566     if (IFace->getImplementation()) {
3567       ShadowContextRAII Shadow(Visited);
3568       LookupVisibleDecls(IFace->getImplementation(), Result,
3569                          QualifiedNameLookup, InBaseClass, Consumer, Visited);
3570     }
3571   } else if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Ctx)) {
3572     for (auto *I : Protocol->protocols()) {
3573       ShadowContextRAII Shadow(Visited);
3574       LookupVisibleDecls(I, Result, QualifiedNameLookup, false, Consumer,
3575                          Visited);
3576     }
3577   } else if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Ctx)) {
3578     for (auto *I : Category->protocols()) {
3579       ShadowContextRAII Shadow(Visited);
3580       LookupVisibleDecls(I, Result, QualifiedNameLookup, false, Consumer,
3581                          Visited);
3582     }
3583 
3584     // If there is an implementation, traverse it.
3585     if (Category->getImplementation()) {
3586       ShadowContextRAII Shadow(Visited);
3587       LookupVisibleDecls(Category->getImplementation(), Result,
3588                          QualifiedNameLookup, true, Consumer, Visited);
3589     }
3590   }
3591 }
3592 
LookupVisibleDecls(Scope * S,LookupResult & Result,UnqualUsingDirectiveSet & UDirs,VisibleDeclConsumer & Consumer,VisibleDeclsRecord & Visited)3593 static void LookupVisibleDecls(Scope *S, LookupResult &Result,
3594                                UnqualUsingDirectiveSet &UDirs,
3595                                VisibleDeclConsumer &Consumer,
3596                                VisibleDeclsRecord &Visited) {
3597   if (!S)
3598     return;
3599 
3600   if (!S->getEntity() ||
3601       (!S->getParent() &&
3602        !Visited.alreadyVisitedContext(S->getEntity())) ||
3603       (S->getEntity())->isFunctionOrMethod()) {
3604     FindLocalExternScope FindLocals(Result);
3605     // Walk through the declarations in this Scope.
3606     for (auto *D : S->decls()) {
3607       if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
3608         if ((ND = Result.getAcceptableDecl(ND))) {
3609           Consumer.FoundDecl(ND, Visited.checkHidden(ND), nullptr, false);
3610           Visited.add(ND);
3611         }
3612     }
3613   }
3614 
3615   // FIXME: C++ [temp.local]p8
3616   DeclContext *Entity = nullptr;
3617   if (S->getEntity()) {
3618     // Look into this scope's declaration context, along with any of its
3619     // parent lookup contexts (e.g., enclosing classes), up to the point
3620     // where we hit the context stored in the next outer scope.
3621     Entity = S->getEntity();
3622     DeclContext *OuterCtx = findOuterContext(S).first; // FIXME
3623 
3624     for (DeclContext *Ctx = Entity; Ctx && !Ctx->Equals(OuterCtx);
3625          Ctx = Ctx->getLookupParent()) {
3626       if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(Ctx)) {
3627         if (Method->isInstanceMethod()) {
3628           // For instance methods, look for ivars in the method's interface.
3629           LookupResult IvarResult(Result.getSema(), Result.getLookupName(),
3630                                   Result.getNameLoc(), Sema::LookupMemberName);
3631           if (ObjCInterfaceDecl *IFace = Method->getClassInterface()) {
3632             LookupVisibleDecls(IFace, IvarResult, /*QualifiedNameLookup=*/false,
3633                                /*InBaseClass=*/false, Consumer, Visited);
3634           }
3635         }
3636 
3637         // We've already performed all of the name lookup that we need
3638         // to for Objective-C methods; the next context will be the
3639         // outer scope.
3640         break;
3641       }
3642 
3643       if (Ctx->isFunctionOrMethod())
3644         continue;
3645 
3646       LookupVisibleDecls(Ctx, Result, /*QualifiedNameLookup=*/false,
3647                          /*InBaseClass=*/false, Consumer, Visited);
3648     }
3649   } else if (!S->getParent()) {
3650     // Look into the translation unit scope. We walk through the translation
3651     // unit's declaration context, because the Scope itself won't have all of
3652     // the declarations if we loaded a precompiled header.
3653     // FIXME: We would like the translation unit's Scope object to point to the
3654     // translation unit, so we don't need this special "if" branch. However,
3655     // doing so would force the normal C++ name-lookup code to look into the
3656     // translation unit decl when the IdentifierInfo chains would suffice.
3657     // Once we fix that problem (which is part of a more general "don't look
3658     // in DeclContexts unless we have to" optimization), we can eliminate this.
3659     Entity = Result.getSema().Context.getTranslationUnitDecl();
3660     LookupVisibleDecls(Entity, Result, /*QualifiedNameLookup=*/false,
3661                        /*InBaseClass=*/false, Consumer, Visited);
3662   }
3663 
3664   if (Entity) {
3665     // Lookup visible declarations in any namespaces found by using
3666     // directives.
3667     for (const UnqualUsingEntry &UUE : UDirs.getNamespacesFor(Entity))
3668       LookupVisibleDecls(const_cast<DeclContext *>(UUE.getNominatedNamespace()),
3669                          Result, /*QualifiedNameLookup=*/false,
3670                          /*InBaseClass=*/false, Consumer, Visited);
3671   }
3672 
3673   // Lookup names in the parent scope.
3674   ShadowContextRAII Shadow(Visited);
3675   LookupVisibleDecls(S->getParent(), Result, UDirs, Consumer, Visited);
3676 }
3677 
LookupVisibleDecls(Scope * S,LookupNameKind Kind,VisibleDeclConsumer & Consumer,bool IncludeGlobalScope)3678 void Sema::LookupVisibleDecls(Scope *S, LookupNameKind Kind,
3679                               VisibleDeclConsumer &Consumer,
3680                               bool IncludeGlobalScope) {
3681   // Determine the set of using directives available during
3682   // unqualified name lookup.
3683   Scope *Initial = S;
3684   UnqualUsingDirectiveSet UDirs;
3685   if (getLangOpts().CPlusPlus) {
3686     // Find the first namespace or translation-unit scope.
3687     while (S && !isNamespaceOrTranslationUnitScope(S))
3688       S = S->getParent();
3689 
3690     UDirs.visitScopeChain(Initial, S);
3691   }
3692   UDirs.done();
3693 
3694   // Look for visible declarations.
3695   LookupResult Result(*this, DeclarationName(), SourceLocation(), Kind);
3696   Result.setAllowHidden(Consumer.includeHiddenDecls());
3697   VisibleDeclsRecord Visited;
3698   if (!IncludeGlobalScope)
3699     Visited.visitedContext(Context.getTranslationUnitDecl());
3700   ShadowContextRAII Shadow(Visited);
3701   ::LookupVisibleDecls(Initial, Result, UDirs, Consumer, Visited);
3702 }
3703 
LookupVisibleDecls(DeclContext * Ctx,LookupNameKind Kind,VisibleDeclConsumer & Consumer,bool IncludeGlobalScope)3704 void Sema::LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind,
3705                               VisibleDeclConsumer &Consumer,
3706                               bool IncludeGlobalScope) {
3707   LookupResult Result(*this, DeclarationName(), SourceLocation(), Kind);
3708   Result.setAllowHidden(Consumer.includeHiddenDecls());
3709   VisibleDeclsRecord Visited;
3710   if (!IncludeGlobalScope)
3711     Visited.visitedContext(Context.getTranslationUnitDecl());
3712   ShadowContextRAII Shadow(Visited);
3713   ::LookupVisibleDecls(Ctx, Result, /*QualifiedNameLookup=*/true,
3714                        /*InBaseClass=*/false, Consumer, Visited);
3715 }
3716 
3717 /// LookupOrCreateLabel - Do a name lookup of a label with the specified name.
3718 /// If GnuLabelLoc is a valid source location, then this is a definition
3719 /// of an __label__ label name, otherwise it is a normal label definition
3720 /// or use.
LookupOrCreateLabel(IdentifierInfo * II,SourceLocation Loc,SourceLocation GnuLabelLoc)3721 LabelDecl *Sema::LookupOrCreateLabel(IdentifierInfo *II, SourceLocation Loc,
3722                                      SourceLocation GnuLabelLoc) {
3723   // Do a lookup to see if we have a label with this name already.
3724   NamedDecl *Res = nullptr;
3725 
3726   if (GnuLabelLoc.isValid()) {
3727     // Local label definitions always shadow existing labels.
3728     Res = LabelDecl::Create(Context, CurContext, Loc, II, GnuLabelLoc);
3729     Scope *S = CurScope;
3730     PushOnScopeChains(Res, S, true);
3731     return cast<LabelDecl>(Res);
3732   }
3733 
3734   // Not a GNU local label.
3735   Res = LookupSingleName(CurScope, II, Loc, LookupLabel, NotForRedeclaration);
3736   // If we found a label, check to see if it is in the same context as us.
3737   // When in a Block, we don't want to reuse a label in an enclosing function.
3738   if (Res && Res->getDeclContext() != CurContext)
3739     Res = nullptr;
3740   if (!Res) {
3741     // If not forward referenced or defined already, create the backing decl.
3742     Res = LabelDecl::Create(Context, CurContext, Loc, II);
3743     Scope *S = CurScope->getFnParent();
3744     assert(S && "Not in a function?");
3745     PushOnScopeChains(Res, S, true);
3746   }
3747   return cast<LabelDecl>(Res);
3748 }
3749 
3750 //===----------------------------------------------------------------------===//
3751 // Typo correction
3752 //===----------------------------------------------------------------------===//
3753 
isCandidateViable(CorrectionCandidateCallback & CCC,TypoCorrection & Candidate)3754 static bool isCandidateViable(CorrectionCandidateCallback &CCC,
3755                               TypoCorrection &Candidate) {
3756   Candidate.setCallbackDistance(CCC.RankCandidate(Candidate));
3757   return Candidate.getEditDistance(false) != TypoCorrection::InvalidDistance;
3758 }
3759 
3760 static void LookupPotentialTypoResult(Sema &SemaRef,
3761                                       LookupResult &Res,
3762                                       IdentifierInfo *Name,
3763                                       Scope *S, CXXScopeSpec *SS,
3764                                       DeclContext *MemberContext,
3765                                       bool EnteringContext,
3766                                       bool isObjCIvarLookup,
3767                                       bool FindHidden);
3768 
3769 /// \brief Check whether the declarations found for a typo correction are
3770 /// visible, and if none of them are, convert the correction to an 'import
3771 /// a module' correction.
checkCorrectionVisibility(Sema & SemaRef,TypoCorrection & TC)3772 static void checkCorrectionVisibility(Sema &SemaRef, TypoCorrection &TC) {
3773   if (TC.begin() == TC.end())
3774     return;
3775 
3776   TypoCorrection::decl_iterator DI = TC.begin(), DE = TC.end();
3777 
3778   for (/**/; DI != DE; ++DI)
3779     if (!LookupResult::isVisible(SemaRef, *DI))
3780       break;
3781   // Nothing to do if all decls are visible.
3782   if (DI == DE)
3783     return;
3784 
3785   llvm::SmallVector<NamedDecl*, 4> NewDecls(TC.begin(), DI);
3786   bool AnyVisibleDecls = !NewDecls.empty();
3787 
3788   for (/**/; DI != DE; ++DI) {
3789     NamedDecl *VisibleDecl = *DI;
3790     if (!LookupResult::isVisible(SemaRef, *DI))
3791       VisibleDecl = findAcceptableDecl(SemaRef, *DI);
3792 
3793     if (VisibleDecl) {
3794       if (!AnyVisibleDecls) {
3795         // Found a visible decl, discard all hidden ones.
3796         AnyVisibleDecls = true;
3797         NewDecls.clear();
3798       }
3799       NewDecls.push_back(VisibleDecl);
3800     } else if (!AnyVisibleDecls && !(*DI)->isModulePrivate())
3801       NewDecls.push_back(*DI);
3802   }
3803 
3804   if (NewDecls.empty())
3805     TC = TypoCorrection();
3806   else {
3807     TC.setCorrectionDecls(NewDecls);
3808     TC.setRequiresImport(!AnyVisibleDecls);
3809   }
3810 }
3811 
3812 // Fill the supplied vector with the IdentifierInfo pointers for each piece of
3813 // the given NestedNameSpecifier (i.e. given a NestedNameSpecifier "foo::bar::",
3814 // fill the vector with the IdentifierInfo pointers for "foo" and "bar").
getNestedNameSpecifierIdentifiers(NestedNameSpecifier * NNS,SmallVectorImpl<const IdentifierInfo * > & Identifiers)3815 static void getNestedNameSpecifierIdentifiers(
3816     NestedNameSpecifier *NNS,
3817     SmallVectorImpl<const IdentifierInfo*> &Identifiers) {
3818   if (NestedNameSpecifier *Prefix = NNS->getPrefix())
3819     getNestedNameSpecifierIdentifiers(Prefix, Identifiers);
3820   else
3821     Identifiers.clear();
3822 
3823   const IdentifierInfo *II = nullptr;
3824 
3825   switch (NNS->getKind()) {
3826   case NestedNameSpecifier::Identifier:
3827     II = NNS->getAsIdentifier();
3828     break;
3829 
3830   case NestedNameSpecifier::Namespace:
3831     if (NNS->getAsNamespace()->isAnonymousNamespace())
3832       return;
3833     II = NNS->getAsNamespace()->getIdentifier();
3834     break;
3835 
3836   case NestedNameSpecifier::NamespaceAlias:
3837     II = NNS->getAsNamespaceAlias()->getIdentifier();
3838     break;
3839 
3840   case NestedNameSpecifier::TypeSpecWithTemplate:
3841   case NestedNameSpecifier::TypeSpec:
3842     II = QualType(NNS->getAsType(), 0).getBaseTypeIdentifier();
3843     break;
3844 
3845   case NestedNameSpecifier::Global:
3846   case NestedNameSpecifier::Super:
3847     return;
3848   }
3849 
3850   if (II)
3851     Identifiers.push_back(II);
3852 }
3853 
FoundDecl(NamedDecl * ND,NamedDecl * Hiding,DeclContext * Ctx,bool InBaseClass)3854 void TypoCorrectionConsumer::FoundDecl(NamedDecl *ND, NamedDecl *Hiding,
3855                                        DeclContext *Ctx, bool InBaseClass) {
3856   // Don't consider hidden names for typo correction.
3857   if (Hiding)
3858     return;
3859 
3860   // Only consider entities with identifiers for names, ignoring
3861   // special names (constructors, overloaded operators, selectors,
3862   // etc.).
3863   IdentifierInfo *Name = ND->getIdentifier();
3864   if (!Name)
3865     return;
3866 
3867   // Only consider visible declarations and declarations from modules with
3868   // names that exactly match.
3869   if (!LookupResult::isVisible(SemaRef, ND) && Name != Typo &&
3870       !findAcceptableDecl(SemaRef, ND))
3871     return;
3872 
3873   FoundName(Name->getName());
3874 }
3875 
FoundName(StringRef Name)3876 void TypoCorrectionConsumer::FoundName(StringRef Name) {
3877   // Compute the edit distance between the typo and the name of this
3878   // entity, and add the identifier to the list of results.
3879   addName(Name, nullptr);
3880 }
3881 
addKeywordResult(StringRef Keyword)3882 void TypoCorrectionConsumer::addKeywordResult(StringRef Keyword) {
3883   // Compute the edit distance between the typo and this keyword,
3884   // and add the keyword to the list of results.
3885   addName(Keyword, nullptr, nullptr, true);
3886 }
3887 
addName(StringRef Name,NamedDecl * ND,NestedNameSpecifier * NNS,bool isKeyword)3888 void TypoCorrectionConsumer::addName(StringRef Name, NamedDecl *ND,
3889                                      NestedNameSpecifier *NNS, bool isKeyword) {
3890   // Use a simple length-based heuristic to determine the minimum possible
3891   // edit distance. If the minimum isn't good enough, bail out early.
3892   StringRef TypoStr = Typo->getName();
3893   unsigned MinED = abs((int)Name.size() - (int)TypoStr.size());
3894   if (MinED && TypoStr.size() / MinED < 3)
3895     return;
3896 
3897   // Compute an upper bound on the allowable edit distance, so that the
3898   // edit-distance algorithm can short-circuit.
3899   unsigned UpperBound = (TypoStr.size() + 2) / 3 + 1;
3900   unsigned ED = TypoStr.edit_distance(Name, true, UpperBound);
3901   if (ED >= UpperBound) return;
3902 
3903   TypoCorrection TC(&SemaRef.Context.Idents.get(Name), ND, NNS, ED);
3904   if (isKeyword) TC.makeKeyword();
3905   TC.setCorrectionRange(nullptr, Result.getLookupNameInfo());
3906   addCorrection(TC);
3907 }
3908 
3909 static const unsigned MaxTypoDistanceResultSets = 5;
3910 
addCorrection(TypoCorrection Correction)3911 void TypoCorrectionConsumer::addCorrection(TypoCorrection Correction) {
3912   StringRef TypoStr = Typo->getName();
3913   StringRef Name = Correction.getCorrectionAsIdentifierInfo()->getName();
3914 
3915   // For very short typos, ignore potential corrections that have a different
3916   // base identifier from the typo or which have a normalized edit distance
3917   // longer than the typo itself.
3918   if (TypoStr.size() < 3 &&
3919       (Name != TypoStr || Correction.getEditDistance(true) > TypoStr.size()))
3920     return;
3921 
3922   // If the correction is resolved but is not viable, ignore it.
3923   if (Correction.isResolved()) {
3924     checkCorrectionVisibility(SemaRef, Correction);
3925     if (!Correction || !isCandidateViable(*CorrectionValidator, Correction))
3926       return;
3927   }
3928 
3929   TypoResultList &CList =
3930       CorrectionResults[Correction.getEditDistance(false)][Name];
3931 
3932   if (!CList.empty() && !CList.back().isResolved())
3933     CList.pop_back();
3934   if (NamedDecl *NewND = Correction.getCorrectionDecl()) {
3935     std::string CorrectionStr = Correction.getAsString(SemaRef.getLangOpts());
3936     for (TypoResultList::iterator RI = CList.begin(), RIEnd = CList.end();
3937          RI != RIEnd; ++RI) {
3938       // If the Correction refers to a decl already in the result list,
3939       // replace the existing result if the string representation of Correction
3940       // comes before the current result alphabetically, then stop as there is
3941       // nothing more to be done to add Correction to the candidate set.
3942       if (RI->getCorrectionDecl() == NewND) {
3943         if (CorrectionStr < RI->getAsString(SemaRef.getLangOpts()))
3944           *RI = Correction;
3945         return;
3946       }
3947     }
3948   }
3949   if (CList.empty() || Correction.isResolved())
3950     CList.push_back(Correction);
3951 
3952   while (CorrectionResults.size() > MaxTypoDistanceResultSets)
3953     CorrectionResults.erase(std::prev(CorrectionResults.end()));
3954 }
3955 
addNamespaces(const llvm::MapVector<NamespaceDecl *,bool> & KnownNamespaces)3956 void TypoCorrectionConsumer::addNamespaces(
3957     const llvm::MapVector<NamespaceDecl *, bool> &KnownNamespaces) {
3958   SearchNamespaces = true;
3959 
3960   for (auto KNPair : KnownNamespaces)
3961     Namespaces.addNameSpecifier(KNPair.first);
3962 
3963   bool SSIsTemplate = false;
3964   if (NestedNameSpecifier *NNS =
3965           (SS && SS->isValid()) ? SS->getScopeRep() : nullptr) {
3966     if (const Type *T = NNS->getAsType())
3967       SSIsTemplate = T->getTypeClass() == Type::TemplateSpecialization;
3968   }
3969   // Do not transform this into an iterator-based loop. The loop body can
3970   // trigger the creation of further types (through lazy deserialization) and
3971   // invalide iterators into this list.
3972   auto &Types = SemaRef.getASTContext().getTypes();
3973   for (unsigned I = 0; I != Types.size(); ++I) {
3974     const auto *TI = Types[I];
3975     if (CXXRecordDecl *CD = TI->getAsCXXRecordDecl()) {
3976       CD = CD->getCanonicalDecl();
3977       if (!CD->isDependentType() && !CD->isAnonymousStructOrUnion() &&
3978           !CD->isUnion() && CD->getIdentifier() &&
3979           (SSIsTemplate || !isa<ClassTemplateSpecializationDecl>(CD)) &&
3980           (CD->isBeingDefined() || CD->isCompleteDefinition()))
3981         Namespaces.addNameSpecifier(CD);
3982     }
3983   }
3984 }
3985 
getNextCorrection()3986 const TypoCorrection &TypoCorrectionConsumer::getNextCorrection() {
3987   if (++CurrentTCIndex < ValidatedCorrections.size())
3988     return ValidatedCorrections[CurrentTCIndex];
3989 
3990   CurrentTCIndex = ValidatedCorrections.size();
3991   while (!CorrectionResults.empty()) {
3992     auto DI = CorrectionResults.begin();
3993     if (DI->second.empty()) {
3994       CorrectionResults.erase(DI);
3995       continue;
3996     }
3997 
3998     auto RI = DI->second.begin();
3999     if (RI->second.empty()) {
4000       DI->second.erase(RI);
4001       performQualifiedLookups();
4002       continue;
4003     }
4004 
4005     TypoCorrection TC = RI->second.pop_back_val();
4006     if (TC.isResolved() || TC.requiresImport() || resolveCorrection(TC)) {
4007       ValidatedCorrections.push_back(TC);
4008       return ValidatedCorrections[CurrentTCIndex];
4009     }
4010   }
4011   return ValidatedCorrections[0];  // The empty correction.
4012 }
4013 
resolveCorrection(TypoCorrection & Candidate)4014 bool TypoCorrectionConsumer::resolveCorrection(TypoCorrection &Candidate) {
4015   IdentifierInfo *Name = Candidate.getCorrectionAsIdentifierInfo();
4016   DeclContext *TempMemberContext = MemberContext;
4017   CXXScopeSpec *TempSS = SS.get();
4018 retry_lookup:
4019   LookupPotentialTypoResult(SemaRef, Result, Name, S, TempSS, TempMemberContext,
4020                             EnteringContext,
4021                             CorrectionValidator->IsObjCIvarLookup,
4022                             Name == Typo && !Candidate.WillReplaceSpecifier());
4023   switch (Result.getResultKind()) {
4024   case LookupResult::NotFound:
4025   case LookupResult::NotFoundInCurrentInstantiation:
4026   case LookupResult::FoundUnresolvedValue:
4027     if (TempSS) {
4028       // Immediately retry the lookup without the given CXXScopeSpec
4029       TempSS = nullptr;
4030       Candidate.WillReplaceSpecifier(true);
4031       goto retry_lookup;
4032     }
4033     if (TempMemberContext) {
4034       if (SS && !TempSS)
4035         TempSS = SS.get();
4036       TempMemberContext = nullptr;
4037       goto retry_lookup;
4038     }
4039     if (SearchNamespaces)
4040       QualifiedResults.push_back(Candidate);
4041     break;
4042 
4043   case LookupResult::Ambiguous:
4044     // We don't deal with ambiguities.
4045     break;
4046 
4047   case LookupResult::Found:
4048   case LookupResult::FoundOverloaded:
4049     // Store all of the Decls for overloaded symbols
4050     for (auto *TRD : Result)
4051       Candidate.addCorrectionDecl(TRD);
4052     checkCorrectionVisibility(SemaRef, Candidate);
4053     if (!isCandidateViable(*CorrectionValidator, Candidate)) {
4054       if (SearchNamespaces)
4055         QualifiedResults.push_back(Candidate);
4056       break;
4057     }
4058     Candidate.setCorrectionRange(SS.get(), Result.getLookupNameInfo());
4059     return true;
4060   }
4061   return false;
4062 }
4063 
performQualifiedLookups()4064 void TypoCorrectionConsumer::performQualifiedLookups() {
4065   unsigned TypoLen = Typo->getName().size();
4066   for (const TypoCorrection &QR : QualifiedResults) {
4067     for (const auto &NSI : Namespaces) {
4068       DeclContext *Ctx = NSI.DeclCtx;
4069       const Type *NSType = NSI.NameSpecifier->getAsType();
4070 
4071       // If the current NestedNameSpecifier refers to a class and the
4072       // current correction candidate is the name of that class, then skip
4073       // it as it is unlikely a qualified version of the class' constructor
4074       // is an appropriate correction.
4075       if (CXXRecordDecl *NSDecl = NSType ? NSType->getAsCXXRecordDecl() :
4076                                            nullptr) {
4077         if (NSDecl->getIdentifier() == QR.getCorrectionAsIdentifierInfo())
4078           continue;
4079       }
4080 
4081       TypoCorrection TC(QR);
4082       TC.ClearCorrectionDecls();
4083       TC.setCorrectionSpecifier(NSI.NameSpecifier);
4084       TC.setQualifierDistance(NSI.EditDistance);
4085       TC.setCallbackDistance(0); // Reset the callback distance
4086 
4087       // If the current correction candidate and namespace combination are
4088       // too far away from the original typo based on the normalized edit
4089       // distance, then skip performing a qualified name lookup.
4090       unsigned TmpED = TC.getEditDistance(true);
4091       if (QR.getCorrectionAsIdentifierInfo() != Typo && TmpED &&
4092           TypoLen / TmpED < 3)
4093         continue;
4094 
4095       Result.clear();
4096       Result.setLookupName(QR.getCorrectionAsIdentifierInfo());
4097       if (!SemaRef.LookupQualifiedName(Result, Ctx))
4098         continue;
4099 
4100       // Any corrections added below will be validated in subsequent
4101       // iterations of the main while() loop over the Consumer's contents.
4102       switch (Result.getResultKind()) {
4103       case LookupResult::Found:
4104       case LookupResult::FoundOverloaded: {
4105         if (SS && SS->isValid()) {
4106           std::string NewQualified = TC.getAsString(SemaRef.getLangOpts());
4107           std::string OldQualified;
4108           llvm::raw_string_ostream OldOStream(OldQualified);
4109           SS->getScopeRep()->print(OldOStream, SemaRef.getPrintingPolicy());
4110           OldOStream << Typo->getName();
4111           // If correction candidate would be an identical written qualified
4112           // identifer, then the existing CXXScopeSpec probably included a
4113           // typedef that didn't get accounted for properly.
4114           if (OldOStream.str() == NewQualified)
4115             break;
4116         }
4117         for (LookupResult::iterator TRD = Result.begin(), TRDEnd = Result.end();
4118              TRD != TRDEnd; ++TRD) {
4119           if (SemaRef.CheckMemberAccess(TC.getCorrectionRange().getBegin(),
4120                                         NSType ? NSType->getAsCXXRecordDecl()
4121                                                : nullptr,
4122                                         TRD.getPair()) == Sema::AR_accessible)
4123             TC.addCorrectionDecl(*TRD);
4124         }
4125         if (TC.isResolved()) {
4126           TC.setCorrectionRange(SS.get(), Result.getLookupNameInfo());
4127           addCorrection(TC);
4128         }
4129         break;
4130       }
4131       case LookupResult::NotFound:
4132       case LookupResult::NotFoundInCurrentInstantiation:
4133       case LookupResult::Ambiguous:
4134       case LookupResult::FoundUnresolvedValue:
4135         break;
4136       }
4137     }
4138   }
4139   QualifiedResults.clear();
4140 }
4141 
NamespaceSpecifierSet(ASTContext & Context,DeclContext * CurContext,CXXScopeSpec * CurScopeSpec)4142 TypoCorrectionConsumer::NamespaceSpecifierSet::NamespaceSpecifierSet(
4143     ASTContext &Context, DeclContext *CurContext, CXXScopeSpec *CurScopeSpec)
4144     : Context(Context), CurContextChain(buildContextChain(CurContext)) {
4145   if (NestedNameSpecifier *NNS =
4146           CurScopeSpec ? CurScopeSpec->getScopeRep() : nullptr) {
4147     llvm::raw_string_ostream SpecifierOStream(CurNameSpecifier);
4148     NNS->print(SpecifierOStream, Context.getPrintingPolicy());
4149 
4150     getNestedNameSpecifierIdentifiers(NNS, CurNameSpecifierIdentifiers);
4151   }
4152   // Build the list of identifiers that would be used for an absolute
4153   // (from the global context) NestedNameSpecifier referring to the current
4154   // context.
4155   for (DeclContext *C : llvm::reverse(CurContextChain)) {
4156     if (auto *ND = dyn_cast_or_null<NamespaceDecl>(C))
4157       CurContextIdentifiers.push_back(ND->getIdentifier());
4158   }
4159 
4160   // Add the global context as a NestedNameSpecifier
4161   SpecifierInfo SI = {cast<DeclContext>(Context.getTranslationUnitDecl()),
4162                       NestedNameSpecifier::GlobalSpecifier(Context), 1};
4163   DistanceMap[1].push_back(SI);
4164 }
4165 
buildContextChain(DeclContext * Start)4166 auto TypoCorrectionConsumer::NamespaceSpecifierSet::buildContextChain(
4167     DeclContext *Start) -> DeclContextList {
4168   assert(Start && "Building a context chain from a null context");
4169   DeclContextList Chain;
4170   for (DeclContext *DC = Start->getPrimaryContext(); DC != nullptr;
4171        DC = DC->getLookupParent()) {
4172     NamespaceDecl *ND = dyn_cast_or_null<NamespaceDecl>(DC);
4173     if (!DC->isInlineNamespace() && !DC->isTransparentContext() &&
4174         !(ND && ND->isAnonymousNamespace()))
4175       Chain.push_back(DC->getPrimaryContext());
4176   }
4177   return Chain;
4178 }
4179 
4180 unsigned
buildNestedNameSpecifier(DeclContextList & DeclChain,NestedNameSpecifier * & NNS)4181 TypoCorrectionConsumer::NamespaceSpecifierSet::buildNestedNameSpecifier(
4182     DeclContextList &DeclChain, NestedNameSpecifier *&NNS) {
4183   unsigned NumSpecifiers = 0;
4184   for (DeclContext *C : llvm::reverse(DeclChain)) {
4185     if (auto *ND = dyn_cast_or_null<NamespaceDecl>(C)) {
4186       NNS = NestedNameSpecifier::Create(Context, NNS, ND);
4187       ++NumSpecifiers;
4188     } else if (auto *RD = dyn_cast_or_null<RecordDecl>(C)) {
4189       NNS = NestedNameSpecifier::Create(Context, NNS, RD->isTemplateDecl(),
4190                                         RD->getTypeForDecl());
4191       ++NumSpecifiers;
4192     }
4193   }
4194   return NumSpecifiers;
4195 }
4196 
addNameSpecifier(DeclContext * Ctx)4197 void TypoCorrectionConsumer::NamespaceSpecifierSet::addNameSpecifier(
4198     DeclContext *Ctx) {
4199   NestedNameSpecifier *NNS = nullptr;
4200   unsigned NumSpecifiers = 0;
4201   DeclContextList NamespaceDeclChain(buildContextChain(Ctx));
4202   DeclContextList FullNamespaceDeclChain(NamespaceDeclChain);
4203 
4204   // Eliminate common elements from the two DeclContext chains.
4205   for (DeclContext *C : llvm::reverse(CurContextChain)) {
4206     if (NamespaceDeclChain.empty() || NamespaceDeclChain.back() != C)
4207       break;
4208     NamespaceDeclChain.pop_back();
4209   }
4210 
4211   // Build the NestedNameSpecifier from what is left of the NamespaceDeclChain
4212   NumSpecifiers = buildNestedNameSpecifier(NamespaceDeclChain, NNS);
4213 
4214   // Add an explicit leading '::' specifier if needed.
4215   if (NamespaceDeclChain.empty()) {
4216     // Rebuild the NestedNameSpecifier as a globally-qualified specifier.
4217     NNS = NestedNameSpecifier::GlobalSpecifier(Context);
4218     NumSpecifiers =
4219         buildNestedNameSpecifier(FullNamespaceDeclChain, NNS);
4220   } else if (NamedDecl *ND =
4221                  dyn_cast_or_null<NamedDecl>(NamespaceDeclChain.back())) {
4222     IdentifierInfo *Name = ND->getIdentifier();
4223     bool SameNameSpecifier = false;
4224     if (std::find(CurNameSpecifierIdentifiers.begin(),
4225                   CurNameSpecifierIdentifiers.end(),
4226                   Name) != CurNameSpecifierIdentifiers.end()) {
4227       std::string NewNameSpecifier;
4228       llvm::raw_string_ostream SpecifierOStream(NewNameSpecifier);
4229       SmallVector<const IdentifierInfo *, 4> NewNameSpecifierIdentifiers;
4230       getNestedNameSpecifierIdentifiers(NNS, NewNameSpecifierIdentifiers);
4231       NNS->print(SpecifierOStream, Context.getPrintingPolicy());
4232       SpecifierOStream.flush();
4233       SameNameSpecifier = NewNameSpecifier == CurNameSpecifier;
4234     }
4235     if (SameNameSpecifier ||
4236         std::find(CurContextIdentifiers.begin(), CurContextIdentifiers.end(),
4237                   Name) != CurContextIdentifiers.end()) {
4238       // Rebuild the NestedNameSpecifier as a globally-qualified specifier.
4239       NNS = NestedNameSpecifier::GlobalSpecifier(Context);
4240       NumSpecifiers =
4241           buildNestedNameSpecifier(FullNamespaceDeclChain, NNS);
4242     }
4243   }
4244 
4245   // If the built NestedNameSpecifier would be replacing an existing
4246   // NestedNameSpecifier, use the number of component identifiers that
4247   // would need to be changed as the edit distance instead of the number
4248   // of components in the built NestedNameSpecifier.
4249   if (NNS && !CurNameSpecifierIdentifiers.empty()) {
4250     SmallVector<const IdentifierInfo*, 4> NewNameSpecifierIdentifiers;
4251     getNestedNameSpecifierIdentifiers(NNS, NewNameSpecifierIdentifiers);
4252     NumSpecifiers = llvm::ComputeEditDistance(
4253         llvm::makeArrayRef(CurNameSpecifierIdentifiers),
4254         llvm::makeArrayRef(NewNameSpecifierIdentifiers));
4255   }
4256 
4257   SpecifierInfo SI = {Ctx, NNS, NumSpecifiers};
4258   DistanceMap[NumSpecifiers].push_back(SI);
4259 }
4260 
4261 /// \brief Perform name lookup for a possible result for typo correction.
LookupPotentialTypoResult(Sema & SemaRef,LookupResult & Res,IdentifierInfo * Name,Scope * S,CXXScopeSpec * SS,DeclContext * MemberContext,bool EnteringContext,bool isObjCIvarLookup,bool FindHidden)4262 static void LookupPotentialTypoResult(Sema &SemaRef,
4263                                       LookupResult &Res,
4264                                       IdentifierInfo *Name,
4265                                       Scope *S, CXXScopeSpec *SS,
4266                                       DeclContext *MemberContext,
4267                                       bool EnteringContext,
4268                                       bool isObjCIvarLookup,
4269                                       bool FindHidden) {
4270   Res.suppressDiagnostics();
4271   Res.clear();
4272   Res.setLookupName(Name);
4273   Res.setAllowHidden(FindHidden);
4274   if (MemberContext) {
4275     if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(MemberContext)) {
4276       if (isObjCIvarLookup) {
4277         if (ObjCIvarDecl *Ivar = Class->lookupInstanceVariable(Name)) {
4278           Res.addDecl(Ivar);
4279           Res.resolveKind();
4280           return;
4281         }
4282       }
4283 
4284       if (ObjCPropertyDecl *Prop = Class->FindPropertyDeclaration(
4285               Name, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
4286         Res.addDecl(Prop);
4287         Res.resolveKind();
4288         return;
4289       }
4290     }
4291 
4292     SemaRef.LookupQualifiedName(Res, MemberContext);
4293     return;
4294   }
4295 
4296   SemaRef.LookupParsedName(Res, S, SS, /*AllowBuiltinCreation=*/false,
4297                            EnteringContext);
4298 
4299   // Fake ivar lookup; this should really be part of
4300   // LookupParsedName.
4301   if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
4302     if (Method->isInstanceMethod() && Method->getClassInterface() &&
4303         (Res.empty() ||
4304          (Res.isSingleResult() &&
4305           Res.getFoundDecl()->isDefinedOutsideFunctionOrMethod()))) {
4306        if (ObjCIvarDecl *IV
4307              = Method->getClassInterface()->lookupInstanceVariable(Name)) {
4308          Res.addDecl(IV);
4309          Res.resolveKind();
4310        }
4311      }
4312   }
4313 }
4314 
4315 /// \brief Add keywords to the consumer as possible typo corrections.
AddKeywordsToConsumer(Sema & SemaRef,TypoCorrectionConsumer & Consumer,Scope * S,CorrectionCandidateCallback & CCC,bool AfterNestedNameSpecifier)4316 static void AddKeywordsToConsumer(Sema &SemaRef,
4317                                   TypoCorrectionConsumer &Consumer,
4318                                   Scope *S, CorrectionCandidateCallback &CCC,
4319                                   bool AfterNestedNameSpecifier) {
4320   if (AfterNestedNameSpecifier) {
4321     // For 'X::', we know exactly which keywords can appear next.
4322     Consumer.addKeywordResult("template");
4323     if (CCC.WantExpressionKeywords)
4324       Consumer.addKeywordResult("operator");
4325     return;
4326   }
4327 
4328   if (CCC.WantObjCSuper)
4329     Consumer.addKeywordResult("super");
4330 
4331   if (CCC.WantTypeSpecifiers) {
4332     // Add type-specifier keywords to the set of results.
4333     static const char *const CTypeSpecs[] = {
4334       "char", "const", "double", "enum", "float", "int", "long", "short",
4335       "signed", "struct", "union", "unsigned", "void", "volatile",
4336       "_Complex", "_Imaginary",
4337       // storage-specifiers as well
4338       "extern", "inline", "static", "typedef"
4339     };
4340 
4341     const unsigned NumCTypeSpecs = llvm::array_lengthof(CTypeSpecs);
4342     for (unsigned I = 0; I != NumCTypeSpecs; ++I)
4343       Consumer.addKeywordResult(CTypeSpecs[I]);
4344 
4345     if (SemaRef.getLangOpts().C99)
4346       Consumer.addKeywordResult("restrict");
4347     if (SemaRef.getLangOpts().Bool || SemaRef.getLangOpts().CPlusPlus)
4348       Consumer.addKeywordResult("bool");
4349     else if (SemaRef.getLangOpts().C99)
4350       Consumer.addKeywordResult("_Bool");
4351 
4352     if (SemaRef.getLangOpts().CPlusPlus) {
4353       Consumer.addKeywordResult("class");
4354       Consumer.addKeywordResult("typename");
4355       Consumer.addKeywordResult("wchar_t");
4356 
4357       if (SemaRef.getLangOpts().CPlusPlus11) {
4358         Consumer.addKeywordResult("char16_t");
4359         Consumer.addKeywordResult("char32_t");
4360         Consumer.addKeywordResult("constexpr");
4361         Consumer.addKeywordResult("decltype");
4362         Consumer.addKeywordResult("thread_local");
4363       }
4364     }
4365 
4366     if (SemaRef.getLangOpts().GNUMode)
4367       Consumer.addKeywordResult("typeof");
4368   } else if (CCC.WantFunctionLikeCasts) {
4369     static const char *const CastableTypeSpecs[] = {
4370       "char", "double", "float", "int", "long", "short",
4371       "signed", "unsigned", "void"
4372     };
4373     for (auto *kw : CastableTypeSpecs)
4374       Consumer.addKeywordResult(kw);
4375   }
4376 
4377   if (CCC.WantCXXNamedCasts && SemaRef.getLangOpts().CPlusPlus) {
4378     Consumer.addKeywordResult("const_cast");
4379     Consumer.addKeywordResult("dynamic_cast");
4380     Consumer.addKeywordResult("reinterpret_cast");
4381     Consumer.addKeywordResult("static_cast");
4382   }
4383 
4384   if (CCC.WantExpressionKeywords) {
4385     Consumer.addKeywordResult("sizeof");
4386     if (SemaRef.getLangOpts().Bool || SemaRef.getLangOpts().CPlusPlus) {
4387       Consumer.addKeywordResult("false");
4388       Consumer.addKeywordResult("true");
4389     }
4390 
4391     if (SemaRef.getLangOpts().CPlusPlus) {
4392       static const char *const CXXExprs[] = {
4393         "delete", "new", "operator", "throw", "typeid"
4394       };
4395       const unsigned NumCXXExprs = llvm::array_lengthof(CXXExprs);
4396       for (unsigned I = 0; I != NumCXXExprs; ++I)
4397         Consumer.addKeywordResult(CXXExprs[I]);
4398 
4399       if (isa<CXXMethodDecl>(SemaRef.CurContext) &&
4400           cast<CXXMethodDecl>(SemaRef.CurContext)->isInstance())
4401         Consumer.addKeywordResult("this");
4402 
4403       if (SemaRef.getLangOpts().CPlusPlus11) {
4404         Consumer.addKeywordResult("alignof");
4405         Consumer.addKeywordResult("nullptr");
4406       }
4407     }
4408 
4409     if (SemaRef.getLangOpts().C11) {
4410       // FIXME: We should not suggest _Alignof if the alignof macro
4411       // is present.
4412       Consumer.addKeywordResult("_Alignof");
4413     }
4414   }
4415 
4416   if (CCC.WantRemainingKeywords) {
4417     if (SemaRef.getCurFunctionOrMethodDecl() || SemaRef.getCurBlock()) {
4418       // Statements.
4419       static const char *const CStmts[] = {
4420         "do", "else", "for", "goto", "if", "return", "switch", "while" };
4421       const unsigned NumCStmts = llvm::array_lengthof(CStmts);
4422       for (unsigned I = 0; I != NumCStmts; ++I)
4423         Consumer.addKeywordResult(CStmts[I]);
4424 
4425       if (SemaRef.getLangOpts().CPlusPlus) {
4426         Consumer.addKeywordResult("catch");
4427         Consumer.addKeywordResult("try");
4428       }
4429 
4430       if (S && S->getBreakParent())
4431         Consumer.addKeywordResult("break");
4432 
4433       if (S && S->getContinueParent())
4434         Consumer.addKeywordResult("continue");
4435 
4436       if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
4437         Consumer.addKeywordResult("case");
4438         Consumer.addKeywordResult("default");
4439       }
4440     } else {
4441       if (SemaRef.getLangOpts().CPlusPlus) {
4442         Consumer.addKeywordResult("namespace");
4443         Consumer.addKeywordResult("template");
4444       }
4445 
4446       if (S && S->isClassScope()) {
4447         Consumer.addKeywordResult("explicit");
4448         Consumer.addKeywordResult("friend");
4449         Consumer.addKeywordResult("mutable");
4450         Consumer.addKeywordResult("private");
4451         Consumer.addKeywordResult("protected");
4452         Consumer.addKeywordResult("public");
4453         Consumer.addKeywordResult("virtual");
4454       }
4455     }
4456 
4457     if (SemaRef.getLangOpts().CPlusPlus) {
4458       Consumer.addKeywordResult("using");
4459 
4460       if (SemaRef.getLangOpts().CPlusPlus11)
4461         Consumer.addKeywordResult("static_assert");
4462     }
4463   }
4464 }
4465 
makeTypoCorrectionConsumer(const DeclarationNameInfo & TypoName,Sema::LookupNameKind LookupKind,Scope * S,CXXScopeSpec * SS,std::unique_ptr<CorrectionCandidateCallback> CCC,DeclContext * MemberContext,bool EnteringContext,const ObjCObjectPointerType * OPT,bool ErrorRecovery)4466 std::unique_ptr<TypoCorrectionConsumer> Sema::makeTypoCorrectionConsumer(
4467     const DeclarationNameInfo &TypoName, Sema::LookupNameKind LookupKind,
4468     Scope *S, CXXScopeSpec *SS,
4469     std::unique_ptr<CorrectionCandidateCallback> CCC,
4470     DeclContext *MemberContext, bool EnteringContext,
4471     const ObjCObjectPointerType *OPT, bool ErrorRecovery) {
4472 
4473   if (Diags.hasFatalErrorOccurred() || !getLangOpts().SpellChecking ||
4474       DisableTypoCorrection)
4475     return nullptr;
4476 
4477   // In Microsoft mode, don't perform typo correction in a template member
4478   // function dependent context because it interferes with the "lookup into
4479   // dependent bases of class templates" feature.
4480   if (getLangOpts().MSVCCompat && CurContext->isDependentContext() &&
4481       isa<CXXMethodDecl>(CurContext))
4482     return nullptr;
4483 
4484   // We only attempt to correct typos for identifiers.
4485   IdentifierInfo *Typo = TypoName.getName().getAsIdentifierInfo();
4486   if (!Typo)
4487     return nullptr;
4488 
4489   // If the scope specifier itself was invalid, don't try to correct
4490   // typos.
4491   if (SS && SS->isInvalid())
4492     return nullptr;
4493 
4494   // Never try to correct typos during template deduction or
4495   // instantiation.
4496   if (!ActiveTemplateInstantiations.empty())
4497     return nullptr;
4498 
4499   // Don't try to correct 'super'.
4500   if (S && S->isInObjcMethodScope() && Typo == getSuperIdentifier())
4501     return nullptr;
4502 
4503   // Abort if typo correction already failed for this specific typo.
4504   IdentifierSourceLocations::iterator locs = TypoCorrectionFailures.find(Typo);
4505   if (locs != TypoCorrectionFailures.end() &&
4506       locs->second.count(TypoName.getLoc()))
4507     return nullptr;
4508 
4509   // Don't try to correct the identifier "vector" when in AltiVec mode.
4510   // TODO: Figure out why typo correction misbehaves in this case, fix it, and
4511   // remove this workaround.
4512   if ((getLangOpts().AltiVec || getLangOpts().ZVector) && Typo->isStr("vector"))
4513     return nullptr;
4514 
4515   // Provide a stop gap for files that are just seriously broken.  Trying
4516   // to correct all typos can turn into a HUGE performance penalty, causing
4517   // some files to take minutes to get rejected by the parser.
4518   unsigned Limit = getDiagnostics().getDiagnosticOptions().SpellCheckingLimit;
4519   if (Limit && TyposCorrected >= Limit)
4520     return nullptr;
4521   ++TyposCorrected;
4522 
4523   // If we're handling a missing symbol error, using modules, and the
4524   // special search all modules option is used, look for a missing import.
4525   if (ErrorRecovery && getLangOpts().Modules &&
4526       getLangOpts().ModulesSearchAll) {
4527     // The following has the side effect of loading the missing module.
4528     getModuleLoader().lookupMissingImports(Typo->getName(),
4529                                            TypoName.getLocStart());
4530   }
4531 
4532   CorrectionCandidateCallback &CCCRef = *CCC;
4533   auto Consumer = llvm::make_unique<TypoCorrectionConsumer>(
4534       *this, TypoName, LookupKind, S, SS, std::move(CCC), MemberContext,
4535       EnteringContext);
4536 
4537   // Perform name lookup to find visible, similarly-named entities.
4538   bool IsUnqualifiedLookup = false;
4539   DeclContext *QualifiedDC = MemberContext;
4540   if (MemberContext) {
4541     LookupVisibleDecls(MemberContext, LookupKind, *Consumer);
4542 
4543     // Look in qualified interfaces.
4544     if (OPT) {
4545       for (auto *I : OPT->quals())
4546         LookupVisibleDecls(I, LookupKind, *Consumer);
4547     }
4548   } else if (SS && SS->isSet()) {
4549     QualifiedDC = computeDeclContext(*SS, EnteringContext);
4550     if (!QualifiedDC)
4551       return nullptr;
4552 
4553     LookupVisibleDecls(QualifiedDC, LookupKind, *Consumer);
4554   } else {
4555     IsUnqualifiedLookup = true;
4556   }
4557 
4558   // Determine whether we are going to search in the various namespaces for
4559   // corrections.
4560   bool SearchNamespaces
4561     = getLangOpts().CPlusPlus &&
4562       (IsUnqualifiedLookup || (SS && SS->isSet()));
4563 
4564   if (IsUnqualifiedLookup || SearchNamespaces) {
4565     // For unqualified lookup, look through all of the names that we have
4566     // seen in this translation unit.
4567     // FIXME: Re-add the ability to skip very unlikely potential corrections.
4568     for (const auto &I : Context.Idents)
4569       Consumer->FoundName(I.getKey());
4570 
4571     // Walk through identifiers in external identifier sources.
4572     // FIXME: Re-add the ability to skip very unlikely potential corrections.
4573     if (IdentifierInfoLookup *External
4574                             = Context.Idents.getExternalIdentifierLookup()) {
4575       std::unique_ptr<IdentifierIterator> Iter(External->getIdentifiers());
4576       do {
4577         StringRef Name = Iter->Next();
4578         if (Name.empty())
4579           break;
4580 
4581         Consumer->FoundName(Name);
4582       } while (true);
4583     }
4584   }
4585 
4586   AddKeywordsToConsumer(*this, *Consumer, S, CCCRef, SS && SS->isNotEmpty());
4587 
4588   // Build the NestedNameSpecifiers for the KnownNamespaces, if we're going
4589   // to search those namespaces.
4590   if (SearchNamespaces) {
4591     // Load any externally-known namespaces.
4592     if (ExternalSource && !LoadedExternalKnownNamespaces) {
4593       SmallVector<NamespaceDecl *, 4> ExternalKnownNamespaces;
4594       LoadedExternalKnownNamespaces = true;
4595       ExternalSource->ReadKnownNamespaces(ExternalKnownNamespaces);
4596       for (auto *N : ExternalKnownNamespaces)
4597         KnownNamespaces[N] = true;
4598     }
4599 
4600     Consumer->addNamespaces(KnownNamespaces);
4601   }
4602 
4603   return Consumer;
4604 }
4605 
4606 /// \brief Try to "correct" a typo in the source code by finding
4607 /// visible declarations whose names are similar to the name that was
4608 /// present in the source code.
4609 ///
4610 /// \param TypoName the \c DeclarationNameInfo structure that contains
4611 /// the name that was present in the source code along with its location.
4612 ///
4613 /// \param LookupKind the name-lookup criteria used to search for the name.
4614 ///
4615 /// \param S the scope in which name lookup occurs.
4616 ///
4617 /// \param SS the nested-name-specifier that precedes the name we're
4618 /// looking for, if present.
4619 ///
4620 /// \param CCC A CorrectionCandidateCallback object that provides further
4621 /// validation of typo correction candidates. It also provides flags for
4622 /// determining the set of keywords permitted.
4623 ///
4624 /// \param MemberContext if non-NULL, the context in which to look for
4625 /// a member access expression.
4626 ///
4627 /// \param EnteringContext whether we're entering the context described by
4628 /// the nested-name-specifier SS.
4629 ///
4630 /// \param OPT when non-NULL, the search for visible declarations will
4631 /// also walk the protocols in the qualified interfaces of \p OPT.
4632 ///
4633 /// \returns a \c TypoCorrection containing the corrected name if the typo
4634 /// along with information such as the \c NamedDecl where the corrected name
4635 /// was declared, and any additional \c NestedNameSpecifier needed to access
4636 /// it (C++ only). The \c TypoCorrection is empty if there is no correction.
CorrectTypo(const DeclarationNameInfo & TypoName,Sema::LookupNameKind LookupKind,Scope * S,CXXScopeSpec * SS,std::unique_ptr<CorrectionCandidateCallback> CCC,CorrectTypoKind Mode,DeclContext * MemberContext,bool EnteringContext,const ObjCObjectPointerType * OPT,bool RecordFailure)4637 TypoCorrection Sema::CorrectTypo(const DeclarationNameInfo &TypoName,
4638                                  Sema::LookupNameKind LookupKind,
4639                                  Scope *S, CXXScopeSpec *SS,
4640                                  std::unique_ptr<CorrectionCandidateCallback> CCC,
4641                                  CorrectTypoKind Mode,
4642                                  DeclContext *MemberContext,
4643                                  bool EnteringContext,
4644                                  const ObjCObjectPointerType *OPT,
4645                                  bool RecordFailure) {
4646   assert(CCC && "CorrectTypo requires a CorrectionCandidateCallback");
4647 
4648   // Always let the ExternalSource have the first chance at correction, even
4649   // if we would otherwise have given up.
4650   if (ExternalSource) {
4651     if (TypoCorrection Correction = ExternalSource->CorrectTypo(
4652         TypoName, LookupKind, S, SS, *CCC, MemberContext, EnteringContext, OPT))
4653       return Correction;
4654   }
4655 
4656   // Ugly hack equivalent to CTC == CTC_ObjCMessageReceiver;
4657   // WantObjCSuper is only true for CTC_ObjCMessageReceiver and for
4658   // some instances of CTC_Unknown, while WantRemainingKeywords is true
4659   // for CTC_Unknown but not for CTC_ObjCMessageReceiver.
4660   bool ObjCMessageReceiver = CCC->WantObjCSuper && !CCC->WantRemainingKeywords;
4661 
4662   IdentifierInfo *Typo = TypoName.getName().getAsIdentifierInfo();
4663   auto Consumer = makeTypoCorrectionConsumer(
4664       TypoName, LookupKind, S, SS, std::move(CCC), MemberContext,
4665       EnteringContext, OPT, Mode == CTK_ErrorRecovery);
4666 
4667   if (!Consumer)
4668     return TypoCorrection();
4669 
4670   // If we haven't found anything, we're done.
4671   if (Consumer->empty())
4672     return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
4673 
4674   // Make sure the best edit distance (prior to adding any namespace qualifiers)
4675   // is not more that about a third of the length of the typo's identifier.
4676   unsigned ED = Consumer->getBestEditDistance(true);
4677   unsigned TypoLen = Typo->getName().size();
4678   if (ED > 0 && TypoLen / ED < 3)
4679     return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
4680 
4681   TypoCorrection BestTC = Consumer->getNextCorrection();
4682   TypoCorrection SecondBestTC = Consumer->getNextCorrection();
4683   if (!BestTC)
4684     return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
4685 
4686   ED = BestTC.getEditDistance();
4687 
4688   if (TypoLen >= 3 && ED > 0 && TypoLen / ED < 3) {
4689     // If this was an unqualified lookup and we believe the callback
4690     // object wouldn't have filtered out possible corrections, note
4691     // that no correction was found.
4692     return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
4693   }
4694 
4695   // If only a single name remains, return that result.
4696   if (!SecondBestTC ||
4697       SecondBestTC.getEditDistance(false) > BestTC.getEditDistance(false)) {
4698     const TypoCorrection &Result = BestTC;
4699 
4700     // Don't correct to a keyword that's the same as the typo; the keyword
4701     // wasn't actually in scope.
4702     if (ED == 0 && Result.isKeyword())
4703       return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
4704 
4705     TypoCorrection TC = Result;
4706     TC.setCorrectionRange(SS, TypoName);
4707     checkCorrectionVisibility(*this, TC);
4708     return TC;
4709   } else if (SecondBestTC && ObjCMessageReceiver) {
4710     // Prefer 'super' when we're completing in a message-receiver
4711     // context.
4712 
4713     if (BestTC.getCorrection().getAsString() != "super") {
4714       if (SecondBestTC.getCorrection().getAsString() == "super")
4715         BestTC = SecondBestTC;
4716       else if ((*Consumer)["super"].front().isKeyword())
4717         BestTC = (*Consumer)["super"].front();
4718     }
4719     // Don't correct to a keyword that's the same as the typo; the keyword
4720     // wasn't actually in scope.
4721     if (BestTC.getEditDistance() == 0 ||
4722         BestTC.getCorrection().getAsString() != "super")
4723       return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
4724 
4725     BestTC.setCorrectionRange(SS, TypoName);
4726     return BestTC;
4727   }
4728 
4729   // Record the failure's location if needed and return an empty correction. If
4730   // this was an unqualified lookup and we believe the callback object did not
4731   // filter out possible corrections, also cache the failure for the typo.
4732   return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure && !SecondBestTC);
4733 }
4734 
4735 /// \brief Try to "correct" a typo in the source code by finding
4736 /// visible declarations whose names are similar to the name that was
4737 /// present in the source code.
4738 ///
4739 /// \param TypoName the \c DeclarationNameInfo structure that contains
4740 /// the name that was present in the source code along with its location.
4741 ///
4742 /// \param LookupKind the name-lookup criteria used to search for the name.
4743 ///
4744 /// \param S the scope in which name lookup occurs.
4745 ///
4746 /// \param SS the nested-name-specifier that precedes the name we're
4747 /// looking for, if present.
4748 ///
4749 /// \param CCC A CorrectionCandidateCallback object that provides further
4750 /// validation of typo correction candidates. It also provides flags for
4751 /// determining the set of keywords permitted.
4752 ///
4753 /// \param TDG A TypoDiagnosticGenerator functor that will be used to print
4754 /// diagnostics when the actual typo correction is attempted.
4755 ///
4756 /// \param TRC A TypoRecoveryCallback functor that will be used to build an
4757 /// Expr from a typo correction candidate.
4758 ///
4759 /// \param MemberContext if non-NULL, the context in which to look for
4760 /// a member access expression.
4761 ///
4762 /// \param EnteringContext whether we're entering the context described by
4763 /// the nested-name-specifier SS.
4764 ///
4765 /// \param OPT when non-NULL, the search for visible declarations will
4766 /// also walk the protocols in the qualified interfaces of \p OPT.
4767 ///
4768 /// \returns a new \c TypoExpr that will later be replaced in the AST with an
4769 /// Expr representing the result of performing typo correction, or nullptr if
4770 /// typo correction is not possible. If nullptr is returned, no diagnostics will
4771 /// be emitted and it is the responsibility of the caller to emit any that are
4772 /// needed.
CorrectTypoDelayed(const DeclarationNameInfo & TypoName,Sema::LookupNameKind LookupKind,Scope * S,CXXScopeSpec * SS,std::unique_ptr<CorrectionCandidateCallback> CCC,TypoDiagnosticGenerator TDG,TypoRecoveryCallback TRC,CorrectTypoKind Mode,DeclContext * MemberContext,bool EnteringContext,const ObjCObjectPointerType * OPT)4773 TypoExpr *Sema::CorrectTypoDelayed(
4774     const DeclarationNameInfo &TypoName, Sema::LookupNameKind LookupKind,
4775     Scope *S, CXXScopeSpec *SS,
4776     std::unique_ptr<CorrectionCandidateCallback> CCC,
4777     TypoDiagnosticGenerator TDG, TypoRecoveryCallback TRC, CorrectTypoKind Mode,
4778     DeclContext *MemberContext, bool EnteringContext,
4779     const ObjCObjectPointerType *OPT) {
4780   assert(CCC && "CorrectTypoDelayed requires a CorrectionCandidateCallback");
4781 
4782   auto Consumer = makeTypoCorrectionConsumer(
4783       TypoName, LookupKind, S, SS, std::move(CCC), MemberContext,
4784       EnteringContext, OPT, Mode == CTK_ErrorRecovery);
4785 
4786   // Give the external sema source a chance to correct the typo.
4787   TypoCorrection ExternalTypo;
4788   if (ExternalSource && Consumer) {
4789     ExternalTypo = ExternalSource->CorrectTypo(
4790         TypoName, LookupKind, S, SS, *Consumer->getCorrectionValidator(),
4791         MemberContext, EnteringContext, OPT);
4792     if (ExternalTypo)
4793       Consumer->addCorrection(ExternalTypo);
4794   }
4795 
4796   if (!Consumer || Consumer->empty())
4797     return nullptr;
4798 
4799   // Make sure the best edit distance (prior to adding any namespace qualifiers)
4800   // is not more that about a third of the length of the typo's identifier.
4801   unsigned ED = Consumer->getBestEditDistance(true);
4802   IdentifierInfo *Typo = TypoName.getName().getAsIdentifierInfo();
4803   if (!ExternalTypo && ED > 0 && Typo->getName().size() / ED < 3)
4804     return nullptr;
4805 
4806   ExprEvalContexts.back().NumTypos++;
4807   return createDelayedTypo(std::move(Consumer), std::move(TDG), std::move(TRC));
4808 }
4809 
addCorrectionDecl(NamedDecl * CDecl)4810 void TypoCorrection::addCorrectionDecl(NamedDecl *CDecl) {
4811   if (!CDecl) return;
4812 
4813   if (isKeyword())
4814     CorrectionDecls.clear();
4815 
4816   CorrectionDecls.push_back(CDecl);
4817 
4818   if (!CorrectionName)
4819     CorrectionName = CDecl->getDeclName();
4820 }
4821 
getAsString(const LangOptions & LO) const4822 std::string TypoCorrection::getAsString(const LangOptions &LO) const {
4823   if (CorrectionNameSpec) {
4824     std::string tmpBuffer;
4825     llvm::raw_string_ostream PrefixOStream(tmpBuffer);
4826     CorrectionNameSpec->print(PrefixOStream, PrintingPolicy(LO));
4827     PrefixOStream << CorrectionName;
4828     return PrefixOStream.str();
4829   }
4830 
4831   return CorrectionName.getAsString();
4832 }
4833 
ValidateCandidate(const TypoCorrection & candidate)4834 bool CorrectionCandidateCallback::ValidateCandidate(
4835     const TypoCorrection &candidate) {
4836   if (!candidate.isResolved())
4837     return true;
4838 
4839   if (candidate.isKeyword())
4840     return WantTypeSpecifiers || WantExpressionKeywords || WantCXXNamedCasts ||
4841            WantRemainingKeywords || WantObjCSuper;
4842 
4843   bool HasNonType = false;
4844   bool HasStaticMethod = false;
4845   bool HasNonStaticMethod = false;
4846   for (Decl *D : candidate) {
4847     if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D))
4848       D = FTD->getTemplatedDecl();
4849     if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
4850       if (Method->isStatic())
4851         HasStaticMethod = true;
4852       else
4853         HasNonStaticMethod = true;
4854     }
4855     if (!isa<TypeDecl>(D))
4856       HasNonType = true;
4857   }
4858 
4859   if (IsAddressOfOperand && HasNonStaticMethod && !HasStaticMethod &&
4860       !candidate.getCorrectionSpecifier())
4861     return false;
4862 
4863   return WantTypeSpecifiers || HasNonType;
4864 }
4865 
FunctionCallFilterCCC(Sema & SemaRef,unsigned NumArgs,bool HasExplicitTemplateArgs,MemberExpr * ME)4866 FunctionCallFilterCCC::FunctionCallFilterCCC(Sema &SemaRef, unsigned NumArgs,
4867                                              bool HasExplicitTemplateArgs,
4868                                              MemberExpr *ME)
4869     : NumArgs(NumArgs), HasExplicitTemplateArgs(HasExplicitTemplateArgs),
4870       CurContext(SemaRef.CurContext), MemberFn(ME) {
4871   WantTypeSpecifiers = false;
4872   WantFunctionLikeCasts = SemaRef.getLangOpts().CPlusPlus && NumArgs == 1;
4873   WantRemainingKeywords = false;
4874 }
4875 
ValidateCandidate(const TypoCorrection & candidate)4876 bool FunctionCallFilterCCC::ValidateCandidate(const TypoCorrection &candidate) {
4877   if (!candidate.getCorrectionDecl())
4878     return candidate.isKeyword();
4879 
4880   for (auto *C : candidate) {
4881     FunctionDecl *FD = nullptr;
4882     NamedDecl *ND = C->getUnderlyingDecl();
4883     if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
4884       FD = FTD->getTemplatedDecl();
4885     if (!HasExplicitTemplateArgs && !FD) {
4886       if (!(FD = dyn_cast<FunctionDecl>(ND)) && isa<ValueDecl>(ND)) {
4887         // If the Decl is neither a function nor a template function,
4888         // determine if it is a pointer or reference to a function. If so,
4889         // check against the number of arguments expected for the pointee.
4890         QualType ValType = cast<ValueDecl>(ND)->getType();
4891         if (ValType->isAnyPointerType() || ValType->isReferenceType())
4892           ValType = ValType->getPointeeType();
4893         if (const FunctionProtoType *FPT = ValType->getAs<FunctionProtoType>())
4894           if (FPT->getNumParams() == NumArgs)
4895             return true;
4896       }
4897     }
4898 
4899     // Skip the current candidate if it is not a FunctionDecl or does not accept
4900     // the current number of arguments.
4901     if (!FD || !(FD->getNumParams() >= NumArgs &&
4902                  FD->getMinRequiredArguments() <= NumArgs))
4903       continue;
4904 
4905     // If the current candidate is a non-static C++ method, skip the candidate
4906     // unless the method being corrected--or the current DeclContext, if the
4907     // function being corrected is not a method--is a method in the same class
4908     // or a descendent class of the candidate's parent class.
4909     if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
4910       if (MemberFn || !MD->isStatic()) {
4911         CXXMethodDecl *CurMD =
4912             MemberFn
4913                 ? dyn_cast_or_null<CXXMethodDecl>(MemberFn->getMemberDecl())
4914                 : dyn_cast_or_null<CXXMethodDecl>(CurContext);
4915         CXXRecordDecl *CurRD =
4916             CurMD ? CurMD->getParent()->getCanonicalDecl() : nullptr;
4917         CXXRecordDecl *RD = MD->getParent()->getCanonicalDecl();
4918         if (!CurRD || (CurRD != RD && !CurRD->isDerivedFrom(RD)))
4919           continue;
4920       }
4921     }
4922     return true;
4923   }
4924   return false;
4925 }
4926 
diagnoseTypo(const TypoCorrection & Correction,const PartialDiagnostic & TypoDiag,bool ErrorRecovery)4927 void Sema::diagnoseTypo(const TypoCorrection &Correction,
4928                         const PartialDiagnostic &TypoDiag,
4929                         bool ErrorRecovery) {
4930   diagnoseTypo(Correction, TypoDiag, PDiag(diag::note_previous_decl),
4931                ErrorRecovery);
4932 }
4933 
4934 /// Find which declaration we should import to provide the definition of
4935 /// the given declaration.
getDefinitionToImport(NamedDecl * D)4936 static NamedDecl *getDefinitionToImport(NamedDecl *D) {
4937   if (VarDecl *VD = dyn_cast<VarDecl>(D))
4938     return VD->getDefinition();
4939   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
4940     return FD->getDefinition();
4941   if (TagDecl *TD = dyn_cast<TagDecl>(D))
4942     return TD->getDefinition();
4943   if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D))
4944     return ID->getDefinition();
4945   if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D))
4946     return PD->getDefinition();
4947   if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
4948     return getDefinitionToImport(TD->getTemplatedDecl());
4949   return nullptr;
4950 }
4951 
diagnoseMissingImport(SourceLocation Loc,NamedDecl * Decl,MissingImportKind MIK,bool Recover)4952 void Sema::diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
4953                                  MissingImportKind MIK, bool Recover) {
4954   assert(!isVisible(Decl) && "missing import for non-hidden decl?");
4955 
4956   // Suggest importing a module providing the definition of this entity, if
4957   // possible.
4958   NamedDecl *Def = getDefinitionToImport(Decl);
4959   if (!Def)
4960     Def = Decl;
4961 
4962   Module *Owner = getOwningModule(Decl);
4963   assert(Owner && "definition of hidden declaration is not in a module");
4964 
4965   llvm::SmallVector<Module*, 8> OwningModules;
4966   OwningModules.push_back(Owner);
4967   auto Merged = Context.getModulesWithMergedDefinition(Decl);
4968   OwningModules.insert(OwningModules.end(), Merged.begin(), Merged.end());
4969 
4970   diagnoseMissingImport(Loc, Decl, Decl->getLocation(), OwningModules, MIK,
4971                         Recover);
4972 }
4973 
4974 /// \brief Get a "quoted.h" or <angled.h> include path to use in a diagnostic
4975 /// suggesting the addition of a #include of the specified file.
getIncludeStringForHeader(Preprocessor & PP,const FileEntry * E)4976 static std::string getIncludeStringForHeader(Preprocessor &PP,
4977                                              const FileEntry *E) {
4978   bool IsSystem;
4979   auto Path =
4980       PP.getHeaderSearchInfo().suggestPathToFileForDiagnostics(E, &IsSystem);
4981   return (IsSystem ? '<' : '"') + Path + (IsSystem ? '>' : '"');
4982 }
4983 
diagnoseMissingImport(SourceLocation UseLoc,NamedDecl * Decl,SourceLocation DeclLoc,ArrayRef<Module * > Modules,MissingImportKind MIK,bool Recover)4984 void Sema::diagnoseMissingImport(SourceLocation UseLoc, NamedDecl *Decl,
4985                                  SourceLocation DeclLoc,
4986                                  ArrayRef<Module *> Modules,
4987                                  MissingImportKind MIK, bool Recover) {
4988   assert(!Modules.empty());
4989 
4990   if (Modules.size() > 1) {
4991     std::string ModuleList;
4992     unsigned N = 0;
4993     for (Module *M : Modules) {
4994       ModuleList += "\n        ";
4995       if (++N == 5 && N != Modules.size()) {
4996         ModuleList += "[...]";
4997         break;
4998       }
4999       ModuleList += M->getFullModuleName();
5000     }
5001 
5002     Diag(UseLoc, diag::err_module_unimported_use_multiple)
5003       << (int)MIK << Decl << ModuleList;
5004   } else if (const FileEntry *E =
5005                  PP.getModuleHeaderToIncludeForDiagnostics(UseLoc, DeclLoc)) {
5006     // The right way to make the declaration visible is to include a header;
5007     // suggest doing so.
5008     //
5009     // FIXME: Find a smart place to suggest inserting a #include, and add
5010     // a FixItHint there.
5011     Diag(UseLoc, diag::err_module_unimported_use_header)
5012       << (int)MIK << Decl << Modules[0]->getFullModuleName()
5013       << getIncludeStringForHeader(PP, E);
5014   } else {
5015     // FIXME: Add a FixItHint that imports the corresponding module.
5016     Diag(UseLoc, diag::err_module_unimported_use)
5017       << (int)MIK << Decl << Modules[0]->getFullModuleName();
5018   }
5019 
5020   unsigned DiagID;
5021   switch (MIK) {
5022   case MissingImportKind::Declaration:
5023     DiagID = diag::note_previous_declaration;
5024     break;
5025   case MissingImportKind::Definition:
5026     DiagID = diag::note_previous_definition;
5027     break;
5028   case MissingImportKind::DefaultArgument:
5029     DiagID = diag::note_default_argument_declared_here;
5030     break;
5031   case MissingImportKind::ExplicitSpecialization:
5032     DiagID = diag::note_explicit_specialization_declared_here;
5033     break;
5034   case MissingImportKind::PartialSpecialization:
5035     DiagID = diag::note_partial_specialization_declared_here;
5036     break;
5037   }
5038   Diag(DeclLoc, DiagID);
5039 
5040   // Try to recover by implicitly importing this module.
5041   if (Recover)
5042     createImplicitModuleImportForErrorRecovery(UseLoc, Modules[0]);
5043 }
5044 
5045 /// \brief Diagnose a successfully-corrected typo. Separated from the correction
5046 /// itself to allow external validation of the result, etc.
5047 ///
5048 /// \param Correction The result of performing typo correction.
5049 /// \param TypoDiag The diagnostic to produce. This will have the corrected
5050 ///        string added to it (and usually also a fixit).
5051 /// \param PrevNote A note to use when indicating the location of the entity to
5052 ///        which we are correcting. Will have the correction string added to it.
5053 /// \param ErrorRecovery If \c true (the default), the caller is going to
5054 ///        recover from the typo as if the corrected string had been typed.
5055 ///        In this case, \c PDiag must be an error, and we will attach a fixit
5056 ///        to it.
diagnoseTypo(const TypoCorrection & Correction,const PartialDiagnostic & TypoDiag,const PartialDiagnostic & PrevNote,bool ErrorRecovery)5057 void Sema::diagnoseTypo(const TypoCorrection &Correction,
5058                         const PartialDiagnostic &TypoDiag,
5059                         const PartialDiagnostic &PrevNote,
5060                         bool ErrorRecovery) {
5061   std::string CorrectedStr = Correction.getAsString(getLangOpts());
5062   std::string CorrectedQuotedStr = Correction.getQuoted(getLangOpts());
5063   FixItHint FixTypo = FixItHint::CreateReplacement(
5064       Correction.getCorrectionRange(), CorrectedStr);
5065 
5066   // Maybe we're just missing a module import.
5067   if (Correction.requiresImport()) {
5068     NamedDecl *Decl = Correction.getFoundDecl();
5069     assert(Decl && "import required but no declaration to import");
5070 
5071     diagnoseMissingImport(Correction.getCorrectionRange().getBegin(), Decl,
5072                           MissingImportKind::Declaration, ErrorRecovery);
5073     return;
5074   }
5075 
5076   Diag(Correction.getCorrectionRange().getBegin(), TypoDiag)
5077     << CorrectedQuotedStr << (ErrorRecovery ? FixTypo : FixItHint());
5078 
5079   NamedDecl *ChosenDecl =
5080       Correction.isKeyword() ? nullptr : Correction.getFoundDecl();
5081   if (PrevNote.getDiagID() && ChosenDecl)
5082     Diag(ChosenDecl->getLocation(), PrevNote)
5083       << CorrectedQuotedStr << (ErrorRecovery ? FixItHint() : FixTypo);
5084 }
5085 
createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,TypoDiagnosticGenerator TDG,TypoRecoveryCallback TRC)5086 TypoExpr *Sema::createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,
5087                                   TypoDiagnosticGenerator TDG,
5088                                   TypoRecoveryCallback TRC) {
5089   assert(TCC && "createDelayedTypo requires a valid TypoCorrectionConsumer");
5090   auto TE = new (Context) TypoExpr(Context.DependentTy);
5091   auto &State = DelayedTypos[TE];
5092   State.Consumer = std::move(TCC);
5093   State.DiagHandler = std::move(TDG);
5094   State.RecoveryHandler = std::move(TRC);
5095   return TE;
5096 }
5097 
getTypoExprState(TypoExpr * TE) const5098 const Sema::TypoExprState &Sema::getTypoExprState(TypoExpr *TE) const {
5099   auto Entry = DelayedTypos.find(TE);
5100   assert(Entry != DelayedTypos.end() &&
5101          "Failed to get the state for a TypoExpr!");
5102   return Entry->second;
5103 }
5104 
clearDelayedTypo(TypoExpr * TE)5105 void Sema::clearDelayedTypo(TypoExpr *TE) {
5106   DelayedTypos.erase(TE);
5107 }
5108 
ActOnPragmaDump(Scope * S,SourceLocation IILoc,IdentifierInfo * II)5109 void Sema::ActOnPragmaDump(Scope *S, SourceLocation IILoc, IdentifierInfo *II) {
5110   DeclarationNameInfo Name(II, IILoc);
5111   LookupResult R(*this, Name, LookupAnyName, Sema::NotForRedeclaration);
5112   R.suppressDiagnostics();
5113   R.setHideTags(false);
5114   LookupName(R, S);
5115   R.dump();
5116 }
5117