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