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