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