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