clang  3.8.0
SemaCXXScopeSpec.cpp
Go to the documentation of this file.
1 //===--- SemaCXXScopeSpec.cpp - Semantic Analysis for C++ scope specifiers-===//
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 C++ semantic analysis for scope specifiers.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "TypeLocBuilder.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/AST/ExprCXX.h"
21 #include "clang/Sema/DeclSpec.h"
22 #include "clang/Sema/Lookup.h"
23 #include "clang/Sema/Template.h"
24 #include "llvm/ADT/STLExtras.h"
25 #include "llvm/Support/raw_ostream.h"
26 using namespace clang;
27 
28 /// \brief Find the current instantiation that associated with the given type.
30  DeclContext *CurContext) {
31  if (T.isNull())
32  return nullptr;
33 
34  const Type *Ty = T->getCanonicalTypeInternal().getTypePtr();
35  if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
36  CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordTy->getDecl());
37  if (!Record->isDependentContext() ||
38  Record->isCurrentInstantiation(CurContext))
39  return Record;
40 
41  return nullptr;
42  } else if (isa<InjectedClassNameType>(Ty))
43  return cast<InjectedClassNameType>(Ty)->getDecl();
44  else
45  return nullptr;
46 }
47 
48 /// \brief Compute the DeclContext that is associated with the given type.
49 ///
50 /// \param T the type for which we are attempting to find a DeclContext.
51 ///
52 /// \returns the declaration context represented by the type T,
53 /// or NULL if the declaration context cannot be computed (e.g., because it is
54 /// dependent and not the current instantiation).
56  if (!T->isDependentType())
57  if (const TagType *Tag = T->getAs<TagType>())
58  return Tag->getDecl();
59 
61 }
62 
63 /// \brief Compute the DeclContext that is associated with the given
64 /// scope specifier.
65 ///
66 /// \param SS the C++ scope specifier as it appears in the source
67 ///
68 /// \param EnteringContext when true, we will be entering the context of
69 /// this scope specifier, so we can retrieve the declaration context of a
70 /// class template or class template partial specialization even if it is
71 /// not the current instantiation.
72 ///
73 /// \returns the declaration context represented by the scope specifier @p SS,
74 /// or NULL if the declaration context cannot be computed (e.g., because it is
75 /// dependent and not the current instantiation).
77  bool EnteringContext) {
78  if (!SS.isSet() || SS.isInvalid())
79  return nullptr;
80 
81  NestedNameSpecifier *NNS = SS.getScopeRep();
82  if (NNS->isDependent()) {
83  // If this nested-name-specifier refers to the current
84  // instantiation, return its DeclContext.
85  if (CXXRecordDecl *Record = getCurrentInstantiationOf(NNS))
86  return Record;
87 
88  if (EnteringContext) {
89  const Type *NNSType = NNS->getAsType();
90  if (!NNSType) {
91  return nullptr;
92  }
93 
94  // Look through type alias templates, per C++0x [temp.dep.type]p1.
95  NNSType = Context.getCanonicalType(NNSType);
96  if (const TemplateSpecializationType *SpecType
97  = NNSType->getAs<TemplateSpecializationType>()) {
98  // We are entering the context of the nested name specifier, so try to
99  // match the nested name specifier to either a primary class template
100  // or a class template partial specialization.
101  if (ClassTemplateDecl *ClassTemplate
102  = dyn_cast_or_null<ClassTemplateDecl>(
103  SpecType->getTemplateName().getAsTemplateDecl())) {
104  QualType ContextType
105  = Context.getCanonicalType(QualType(SpecType, 0));
106 
107  // If the type of the nested name specifier is the same as the
108  // injected class name of the named class template, we're entering
109  // into that class template definition.
110  QualType Injected
111  = ClassTemplate->getInjectedClassNameSpecialization();
112  if (Context.hasSameType(Injected, ContextType))
113  return ClassTemplate->getTemplatedDecl();
114 
115  // If the type of the nested name specifier is the same as the
116  // type of one of the class template's class template partial
117  // specializations, we're entering into the definition of that
118  // class template partial specialization.
120  = ClassTemplate->findPartialSpecialization(ContextType))
121  return PartialSpec;
122  }
123  } else if (const RecordType *RecordT = NNSType->getAs<RecordType>()) {
124  // The nested name specifier refers to a member of a class template.
125  return RecordT->getDecl();
126  }
127  }
128 
129  return nullptr;
130  }
131 
132  switch (NNS->getKind()) {
134  llvm_unreachable("Dependent nested-name-specifier has no DeclContext");
135 
137  return NNS->getAsNamespace();
138 
140  return NNS->getAsNamespaceAlias()->getNamespace();
141 
144  const TagType *Tag = NNS->getAsType()->getAs<TagType>();
145  assert(Tag && "Non-tag type in nested-name-specifier");
146  return Tag->getDecl();
147  }
148 
151 
153  return NNS->getAsRecordDecl();
154  }
155 
156  llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
157 }
158 
160  if (!SS.isSet() || SS.isInvalid())
161  return false;
162 
163  return SS.getScopeRep()->isDependent();
164 }
165 
166 /// \brief If the given nested name specifier refers to the current
167 /// instantiation, return the declaration that corresponds to that
168 /// current instantiation (C++0x [temp.dep.type]p1).
169 ///
170 /// \param NNS a dependent nested name specifier.
172  assert(getLangOpts().CPlusPlus && "Only callable in C++");
173  assert(NNS->isDependent() && "Only dependent nested-name-specifier allowed");
174 
175  if (!NNS->getAsType())
176  return nullptr;
177 
178  QualType T = QualType(NNS->getAsType(), 0);
180 }
181 
182 /// \brief Require that the context specified by SS be complete.
183 ///
184 /// If SS refers to a type, this routine checks whether the type is
185 /// complete enough (or can be made complete enough) for name lookup
186 /// into the DeclContext. A type that is not yet completed can be
187 /// considered "complete enough" if it is a class/struct/union/enum
188 /// that is currently being defined. Or, if we have a type that names
189 /// a class template specialization that is not a complete type, we
190 /// will attempt to instantiate that class template.
192  DeclContext *DC) {
193  assert(DC && "given null context");
194 
195  TagDecl *tag = dyn_cast<TagDecl>(DC);
196 
197  // If this is a dependent type, then we consider it complete.
198  if (!tag || tag->isDependentContext())
199  return false;
200 
201  // If we're currently defining this type, then lookup into the
202  // type is okay: don't complain that it isn't complete yet.
204  const TagType *tagType = type->getAs<TagType>();
205  if (tagType && tagType->isBeingDefined())
206  return false;
207 
209  if (loc.isInvalid()) loc = SS.getRange().getBegin();
210 
211  // The type must be complete.
212  if (RequireCompleteType(loc, type, diag::err_incomplete_nested_name_spec,
213  SS.getRange())) {
214  SS.SetInvalid(SS.getRange());
215  return true;
216  }
217 
218  // Fixed enum types are complete, but they aren't valid as scopes
219  // until we see a definition, so awkwardly pull out this special
220  // case.
221  // FIXME: The definition might not be visible; complain if it is not.
222  const EnumType *enumType = dyn_cast_or_null<EnumType>(tagType);
223  if (!enumType || enumType->getDecl()->isCompleteDefinition())
224  return false;
225 
226  // Try to instantiate the definition, if this is a specialization of an
227  // enumeration temploid.
228  EnumDecl *ED = enumType->getDecl();
229  if (EnumDecl *Pattern = ED->getInstantiatedFromMemberEnum()) {
232  if (InstantiateEnum(loc, ED, Pattern, getTemplateInstantiationArgs(ED),
234  SS.SetInvalid(SS.getRange());
235  return true;
236  }
237  return false;
238  }
239  }
240 
241  Diag(loc, diag::err_incomplete_nested_name_spec)
242  << type << SS.getRange();
243  SS.SetInvalid(SS.getRange());
244  return true;
245 }
246 
248  CXXScopeSpec &SS) {
249  SS.MakeGlobal(Context, CCLoc);
250  return false;
251 }
252 
254  SourceLocation ColonColonLoc,
255  CXXScopeSpec &SS) {
256  CXXRecordDecl *RD = nullptr;
257  for (Scope *S = getCurScope(); S; S = S->getParent()) {
258  if (S->isFunctionScope()) {
259  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(S->getEntity()))
260  RD = MD->getParent();
261  break;
262  }
263  if (S->isClassScope()) {
264  RD = cast<CXXRecordDecl>(S->getEntity());
265  break;
266  }
267  }
268 
269  if (!RD) {
270  Diag(SuperLoc, diag::err_invalid_super_scope);
271  return true;
272  } else if (RD->isLambda()) {
273  Diag(SuperLoc, diag::err_super_in_lambda_unsupported);
274  return true;
275  } else if (RD->getNumBases() == 0) {
276  Diag(SuperLoc, diag::err_no_base_classes) << RD->getName();
277  return true;
278  }
279 
280  SS.MakeSuper(Context, RD, SuperLoc, ColonColonLoc);
281  return false;
282 }
283 
284 /// \brief Determines whether the given declaration is an valid acceptable
285 /// result for name lookup of a nested-name-specifier.
286 /// \param SD Declaration checked for nested-name-specifier.
287 /// \param IsExtension If not null and the declaration is accepted as an
288 /// extension, the pointed variable is assigned true.
290  bool *IsExtension) {
291  if (!SD)
292  return false;
293 
294  SD = SD->getUnderlyingDecl();
295 
296  // Namespace and namespace aliases are fine.
297  if (isa<NamespaceDecl>(SD))
298  return true;
299 
300  if (!isa<TypeDecl>(SD))
301  return false;
302 
303  // Determine whether we have a class (or, in C++11, an enum) or
304  // a typedef thereof. If so, build the nested-name-specifier.
305  QualType T = Context.getTypeDeclType(cast<TypeDecl>(SD));
306  if (T->isDependentType())
307  return true;
308  if (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(SD)) {
309  if (TD->getUnderlyingType()->isRecordType())
310  return true;
311  if (TD->getUnderlyingType()->isEnumeralType()) {
312  if (Context.getLangOpts().CPlusPlus11)
313  return true;
314  if (IsExtension)
315  *IsExtension = true;
316  }
317  } else if (isa<RecordDecl>(SD)) {
318  return true;
319  } else if (isa<EnumDecl>(SD)) {
320  if (Context.getLangOpts().CPlusPlus11)
321  return true;
322  if (IsExtension)
323  *IsExtension = true;
324  }
325 
326  return false;
327 }
328 
329 /// \brief If the given nested-name-specifier begins with a bare identifier
330 /// (e.g., Base::), perform name lookup for that identifier as a
331 /// nested-name-specifier within the given scope, and return the result of that
332 /// name lookup.
334  if (!S || !NNS)
335  return nullptr;
336 
337  while (NNS->getPrefix())
338  NNS = NNS->getPrefix();
339 
341  return nullptr;
342 
343  LookupResult Found(*this, NNS->getAsIdentifier(), SourceLocation(),
345  LookupName(Found, S);
346  assert(!Found.isAmbiguous() && "Cannot handle ambiguities here yet");
347 
348  if (!Found.isSingleResult())
349  return nullptr;
350 
351  NamedDecl *Result = Found.getFoundDecl();
353  return Result;
354 
355  return nullptr;
356 }
357 
359  SourceLocation IdLoc,
360  IdentifierInfo &II,
361  ParsedType ObjectTypePtr) {
362  QualType ObjectType = GetTypeFromParser(ObjectTypePtr);
363  LookupResult Found(*this, &II, IdLoc, LookupNestedNameSpecifierName);
364 
365  // Determine where to perform name lookup
366  DeclContext *LookupCtx = nullptr;
367  bool isDependent = false;
368  if (!ObjectType.isNull()) {
369  // This nested-name-specifier occurs in a member access expression, e.g.,
370  // x->B::f, and we are looking into the type of the object.
371  assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
372  LookupCtx = computeDeclContext(ObjectType);
373  isDependent = ObjectType->isDependentType();
374  } else if (SS.isSet()) {
375  // This nested-name-specifier occurs after another nested-name-specifier,
376  // so long into the context associated with the prior nested-name-specifier.
377  LookupCtx = computeDeclContext(SS, false);
378  isDependent = isDependentScopeSpecifier(SS);
379  Found.setContextRange(SS.getRange());
380  }
381 
382  if (LookupCtx) {
383  // Perform "qualified" name lookup into the declaration context we
384  // computed, which is either the type of the base of a member access
385  // expression or the declaration context associated with a prior
386  // nested-name-specifier.
387 
388  // The declaration context must be complete.
389  if (!LookupCtx->isDependentContext() &&
390  RequireCompleteDeclContext(SS, LookupCtx))
391  return false;
392 
393  LookupQualifiedName(Found, LookupCtx);
394  } else if (isDependent) {
395  return false;
396  } else {
397  LookupName(Found, S);
398  }
399  Found.suppressDiagnostics();
400 
401  return Found.getAsSingle<NamespaceDecl>();
402 }
403 
404 namespace {
405 
406 // Callback to only accept typo corrections that can be a valid C++ member
407 // intializer: either a non-static field member or a base class.
408 class NestedNameSpecifierValidatorCCC : public CorrectionCandidateCallback {
409  public:
410  explicit NestedNameSpecifierValidatorCCC(Sema &SRef)
411  : SRef(SRef) {}
412 
413  bool ValidateCandidate(const TypoCorrection &candidate) override {
414  return SRef.isAcceptableNestedNameSpecifier(candidate.getCorrectionDecl());
415  }
416 
417  private:
418  Sema &SRef;
419 };
420 
421 }
422 
423 /// \brief Build a new nested-name-specifier for "identifier::", as described
424 /// by ActOnCXXNestedNameSpecifier.
425 ///
426 /// \param S Scope in which the nested-name-specifier occurs.
427 /// \param Identifier Identifier in the sequence "identifier" "::".
428 /// \param IdentifierLoc Location of the \p Identifier.
429 /// \param CCLoc Location of "::" following Identifier.
430 /// \param ObjectType Type of postfix expression if the nested-name-specifier
431 /// occurs in construct like: <tt>ptr->nns::f</tt>.
432 /// \param EnteringContext If true, enter the context specified by the
433 /// nested-name-specifier.
434 /// \param SS Optional nested name specifier preceding the identifier.
435 /// \param ScopeLookupResult Provides the result of name lookup within the
436 /// scope of the nested-name-specifier that was computed at template
437 /// definition time.
438 /// \param ErrorRecoveryLookup Specifies if the method is called to improve
439 /// error recovery and what kind of recovery is performed.
440 /// \param IsCorrectedToColon If not null, suggestion of replace '::' -> ':'
441 /// are allowed. The bool value pointed by this parameter is set to
442 /// 'true' if the identifier is treated as if it was followed by ':',
443 /// not '::'.
444 ///
445 /// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in
446 /// that it contains an extra parameter \p ScopeLookupResult, which provides
447 /// the result of name lookup within the scope of the nested-name-specifier
448 /// that was computed at template definition time.
449 ///
450 /// If ErrorRecoveryLookup is true, then this call is used to improve error
451 /// recovery. This means that it should not emit diagnostics, it should
452 /// just return true on failure. It also means it should only return a valid
453 /// scope if it *knows* that the result is correct. It should not return in a
454 /// dependent context, for example. Nor will it extend \p SS with the scope
455 /// specifier.
457  IdentifierInfo &Identifier,
459  SourceLocation CCLoc,
460  QualType ObjectType,
461  bool EnteringContext,
462  CXXScopeSpec &SS,
463  NamedDecl *ScopeLookupResult,
464  bool ErrorRecoveryLookup,
465  bool *IsCorrectedToColon) {
466  LookupResult Found(*this, &Identifier, IdentifierLoc,
468 
469  // Determine where to perform name lookup
470  DeclContext *LookupCtx = nullptr;
471  bool isDependent = false;
472  if (IsCorrectedToColon)
473  *IsCorrectedToColon = false;
474  if (!ObjectType.isNull()) {
475  // This nested-name-specifier occurs in a member access expression, e.g.,
476  // x->B::f, and we are looking into the type of the object.
477  assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
478  LookupCtx = computeDeclContext(ObjectType);
479  isDependent = ObjectType->isDependentType();
480  } else if (SS.isSet()) {
481  // This nested-name-specifier occurs after another nested-name-specifier,
482  // so look into the context associated with the prior nested-name-specifier.
483  LookupCtx = computeDeclContext(SS, EnteringContext);
484  isDependent = isDependentScopeSpecifier(SS);
485  Found.setContextRange(SS.getRange());
486  }
487 
488  bool ObjectTypeSearchedInScope = false;
489  if (LookupCtx) {
490  // Perform "qualified" name lookup into the declaration context we
491  // computed, which is either the type of the base of a member access
492  // expression or the declaration context associated with a prior
493  // nested-name-specifier.
494 
495  // The declaration context must be complete.
496  if (!LookupCtx->isDependentContext() &&
497  RequireCompleteDeclContext(SS, LookupCtx))
498  return true;
499 
500  LookupQualifiedName(Found, LookupCtx);
501 
502  if (!ObjectType.isNull() && Found.empty()) {
503  // C++ [basic.lookup.classref]p4:
504  // If the id-expression in a class member access is a qualified-id of
505  // the form
506  //
507  // class-name-or-namespace-name::...
508  //
509  // the class-name-or-namespace-name following the . or -> operator is
510  // looked up both in the context of the entire postfix-expression and in
511  // the scope of the class of the object expression. If the name is found
512  // only in the scope of the class of the object expression, the name
513  // shall refer to a class-name. If the name is found only in the
514  // context of the entire postfix-expression, the name shall refer to a
515  // class-name or namespace-name. [...]
516  //
517  // Qualified name lookup into a class will not find a namespace-name,
518  // so we do not need to diagnose that case specifically. However,
519  // this qualified name lookup may find nothing. In that case, perform
520  // unqualified name lookup in the given scope (if available) or
521  // reconstruct the result from when name lookup was performed at template
522  // definition time.
523  if (S)
524  LookupName(Found, S);
525  else if (ScopeLookupResult)
526  Found.addDecl(ScopeLookupResult);
527 
528  ObjectTypeSearchedInScope = true;
529  }
530  } else if (!isDependent) {
531  // Perform unqualified name lookup in the current scope.
532  LookupName(Found, S);
533  }
534 
535  if (Found.isAmbiguous())
536  return true;
537 
538  // If we performed lookup into a dependent context and did not find anything,
539  // that's fine: just build a dependent nested-name-specifier.
540  if (Found.empty() && isDependent &&
541  !(LookupCtx && LookupCtx->isRecord() &&
542  (!cast<CXXRecordDecl>(LookupCtx)->hasDefinition() ||
543  !cast<CXXRecordDecl>(LookupCtx)->hasAnyDependentBases()))) {
544  // Don't speculate if we're just trying to improve error recovery.
545  if (ErrorRecoveryLookup)
546  return true;
547 
548  // We were not able to compute the declaration context for a dependent
549  // base object type or prior nested-name-specifier, so this
550  // nested-name-specifier refers to an unknown specialization. Just build
551  // a dependent nested-name-specifier.
552  SS.Extend(Context, &Identifier, IdentifierLoc, CCLoc);
553  return false;
554  }
555 
556  if (Found.empty() && !ErrorRecoveryLookup) {
557  // If identifier is not found as class-name-or-namespace-name, but is found
558  // as other entity, don't look for typos.
560  if (LookupCtx)
561  LookupQualifiedName(R, LookupCtx);
562  else if (S && !isDependent)
563  LookupName(R, S);
564  if (!R.empty()) {
565  // Don't diagnose problems with this speculative lookup.
566  R.suppressDiagnostics();
567  // The identifier is found in ordinary lookup. If correction to colon is
568  // allowed, suggest replacement to ':'.
569  if (IsCorrectedToColon) {
570  *IsCorrectedToColon = true;
571  Diag(CCLoc, diag::err_nested_name_spec_is_not_class)
572  << &Identifier << getLangOpts().CPlusPlus
573  << FixItHint::CreateReplacement(CCLoc, ":");
574  if (NamedDecl *ND = R.getAsSingle<NamedDecl>())
575  Diag(ND->getLocation(), diag::note_declared_at);
576  return true;
577  }
578  // Replacement '::' -> ':' is not allowed, just issue respective error.
579  Diag(R.getNameLoc(), diag::err_expected_class_or_namespace)
580  << &Identifier << getLangOpts().CPlusPlus;
581  if (NamedDecl *ND = R.getAsSingle<NamedDecl>())
582  Diag(ND->getLocation(), diag::note_entity_declared_at) << &Identifier;
583  return true;
584  }
585  }
586 
587  if (Found.empty() && !ErrorRecoveryLookup && !getLangOpts().MSVCCompat) {
588  // We haven't found anything, and we're not recovering from a
589  // different kind of error, so look for typos.
591  Found.clear();
592  if (TypoCorrection Corrected = CorrectTypo(
593  Found.getLookupNameInfo(), Found.getLookupKind(), S, &SS,
594  llvm::make_unique<NestedNameSpecifierValidatorCCC>(*this),
595  CTK_ErrorRecovery, LookupCtx, EnteringContext)) {
596  if (LookupCtx) {
597  bool DroppedSpecifier =
598  Corrected.WillReplaceSpecifier() &&
599  Name.getAsString() == Corrected.getAsString(getLangOpts());
600  if (DroppedSpecifier)
601  SS.clear();
602  diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
603  << Name << LookupCtx << DroppedSpecifier
604  << SS.getRange());
605  } else
606  diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest)
607  << Name);
608 
609  if (NamedDecl *ND = Corrected.getFoundDecl())
610  Found.addDecl(ND);
611  Found.setLookupName(Corrected.getCorrection());
612  } else {
613  Found.setLookupName(&Identifier);
614  }
615  }
616 
617  NamedDecl *SD =
618  Found.isSingleResult() ? Found.getRepresentativeDecl() : nullptr;
619  bool IsExtension = false;
620  bool AcceptSpec = isAcceptableNestedNameSpecifier(SD, &IsExtension);
621  if (!AcceptSpec && IsExtension) {
622  AcceptSpec = true;
623  Diag(IdentifierLoc, diag::ext_nested_name_spec_is_enum);
624  }
625  if (AcceptSpec) {
626  if (!ObjectType.isNull() && !ObjectTypeSearchedInScope &&
627  !getLangOpts().CPlusPlus11) {
628  // C++03 [basic.lookup.classref]p4:
629  // [...] If the name is found in both contexts, the
630  // class-name-or-namespace-name shall refer to the same entity.
631  //
632  // We already found the name in the scope of the object. Now, look
633  // into the current scope (the scope of the postfix-expression) to
634  // see if we can find the same name there. As above, if there is no
635  // scope, reconstruct the result from the template instantiation itself.
636  //
637  // Note that C++11 does *not* perform this redundant lookup.
638  NamedDecl *OuterDecl;
639  if (S) {
640  LookupResult FoundOuter(*this, &Identifier, IdentifierLoc,
642  LookupName(FoundOuter, S);
643  OuterDecl = FoundOuter.getAsSingle<NamedDecl>();
644  } else
645  OuterDecl = ScopeLookupResult;
646 
647  if (isAcceptableNestedNameSpecifier(OuterDecl) &&
648  OuterDecl->getCanonicalDecl() != SD->getCanonicalDecl() &&
649  (!isa<TypeDecl>(OuterDecl) || !isa<TypeDecl>(SD) ||
651  Context.getTypeDeclType(cast<TypeDecl>(OuterDecl)),
652  Context.getTypeDeclType(cast<TypeDecl>(SD))))) {
653  if (ErrorRecoveryLookup)
654  return true;
655 
656  Diag(IdentifierLoc,
657  diag::err_nested_name_member_ref_lookup_ambiguous)
658  << &Identifier;
659  Diag(SD->getLocation(), diag::note_ambig_member_ref_object_type)
660  << ObjectType;
661  Diag(OuterDecl->getLocation(), diag::note_ambig_member_ref_scope);
662 
663  // Fall through so that we'll pick the name we found in the object
664  // type, since that's probably what the user wanted anyway.
665  }
666  }
667 
668  if (auto *TD = dyn_cast_or_null<TypedefNameDecl>(SD))
669  MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
670 
671  // If we're just performing this lookup for error-recovery purposes,
672  // don't extend the nested-name-specifier. Just return now.
673  if (ErrorRecoveryLookup)
674  return false;
675 
676  // The use of a nested name specifier may trigger deprecation warnings.
677  DiagnoseUseOfDecl(SD, CCLoc);
678 
679 
680  if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(SD)) {
681  SS.Extend(Context, Namespace, IdentifierLoc, CCLoc);
682  return false;
683  }
684 
685  if (NamespaceAliasDecl *Alias = dyn_cast<NamespaceAliasDecl>(SD)) {
686  SS.Extend(Context, Alias, IdentifierLoc, CCLoc);
687  return false;
688  }
689 
690  QualType T =
691  Context.getTypeDeclType(cast<TypeDecl>(SD->getUnderlyingDecl()));
692  TypeLocBuilder TLB;
693  if (isa<InjectedClassNameType>(T)) {
694  InjectedClassNameTypeLoc InjectedTL
695  = TLB.push<InjectedClassNameTypeLoc>(T);
696  InjectedTL.setNameLoc(IdentifierLoc);
697  } else if (isa<RecordType>(T)) {
698  RecordTypeLoc RecordTL = TLB.push<RecordTypeLoc>(T);
699  RecordTL.setNameLoc(IdentifierLoc);
700  } else if (isa<TypedefType>(T)) {
701  TypedefTypeLoc TypedefTL = TLB.push<TypedefTypeLoc>(T);
702  TypedefTL.setNameLoc(IdentifierLoc);
703  } else if (isa<EnumType>(T)) {
704  EnumTypeLoc EnumTL = TLB.push<EnumTypeLoc>(T);
705  EnumTL.setNameLoc(IdentifierLoc);
706  } else if (isa<TemplateTypeParmType>(T)) {
707  TemplateTypeParmTypeLoc TemplateTypeTL
708  = TLB.push<TemplateTypeParmTypeLoc>(T);
709  TemplateTypeTL.setNameLoc(IdentifierLoc);
710  } else if (isa<UnresolvedUsingType>(T)) {
711  UnresolvedUsingTypeLoc UnresolvedTL
712  = TLB.push<UnresolvedUsingTypeLoc>(T);
713  UnresolvedTL.setNameLoc(IdentifierLoc);
714  } else if (isa<SubstTemplateTypeParmType>(T)) {
717  TL.setNameLoc(IdentifierLoc);
718  } else if (isa<SubstTemplateTypeParmPackType>(T)) {
721  TL.setNameLoc(IdentifierLoc);
722  } else {
723  llvm_unreachable("Unhandled TypeDecl node in nested-name-specifier");
724  }
725 
726  if (T->isEnumeralType())
727  Diag(IdentifierLoc, diag::warn_cxx98_compat_enum_nested_name_spec);
728 
730  CCLoc);
731  return false;
732  }
733 
734  // Otherwise, we have an error case. If we don't want diagnostics, just
735  // return an error now.
736  if (ErrorRecoveryLookup)
737  return true;
738 
739  // If we didn't find anything during our lookup, try again with
740  // ordinary name lookup, which can help us produce better error
741  // messages.
742  if (Found.empty()) {
743  Found.clear(LookupOrdinaryName);
744  LookupName(Found, S);
745  }
746 
747  // In Microsoft mode, if we are within a templated function and we can't
748  // resolve Identifier, then extend the SS with Identifier. This will have
749  // the effect of resolving Identifier during template instantiation.
750  // The goal is to be able to resolve a function call whose
751  // nested-name-specifier is located inside a dependent base class.
752  // Example:
753  //
754  // class C {
755  // public:
756  // static void foo2() { }
757  // };
758  // template <class T> class A { public: typedef C D; };
759  //
760  // template <class T> class B : public A<T> {
761  // public:
762  // void foo() { D::foo2(); }
763  // };
764  if (getLangOpts().MSVCCompat) {
765  DeclContext *DC = LookupCtx ? LookupCtx : CurContext;
766  if (DC->isDependentContext() && DC->isFunctionOrMethod()) {
767  CXXRecordDecl *ContainingClass = dyn_cast<CXXRecordDecl>(DC->getParent());
768  if (ContainingClass && ContainingClass->hasAnyDependentBases()) {
769  Diag(IdentifierLoc, diag::ext_undeclared_unqual_id_with_dependent_base)
770  << &Identifier << ContainingClass;
771  SS.Extend(Context, &Identifier, IdentifierLoc, CCLoc);
772  return false;
773  }
774  }
775  }
776 
777  if (!Found.empty()) {
778  if (TypeDecl *TD = Found.getAsSingle<TypeDecl>())
779  Diag(IdentifierLoc, diag::err_expected_class_or_namespace)
780  << QualType(TD->getTypeForDecl(), 0) << getLangOpts().CPlusPlus;
781  else {
782  Diag(IdentifierLoc, diag::err_expected_class_or_namespace)
783  << &Identifier << getLangOpts().CPlusPlus;
784  if (NamedDecl *ND = Found.getAsSingle<NamedDecl>())
785  Diag(ND->getLocation(), diag::note_entity_declared_at) << &Identifier;
786  }
787  } else if (SS.isSet())
788  Diag(IdentifierLoc, diag::err_no_member) << &Identifier << LookupCtx
789  << SS.getRange();
790  else
791  Diag(IdentifierLoc, diag::err_undeclared_var_use) << &Identifier;
792 
793  return true;
794 }
795 
797  IdentifierInfo &Identifier,
799  SourceLocation CCLoc,
800  ParsedType ObjectType,
801  bool EnteringContext,
802  CXXScopeSpec &SS,
803  bool ErrorRecoveryLookup,
804  bool *IsCorrectedToColon) {
805  if (SS.isInvalid())
806  return true;
807 
808  return BuildCXXNestedNameSpecifier(S, Identifier, IdentifierLoc, CCLoc,
809  GetTypeFromParser(ObjectType),
810  EnteringContext, SS,
811  /*ScopeLookupResult=*/nullptr, false,
812  IsCorrectedToColon);
813 }
814 
816  const DeclSpec &DS,
817  SourceLocation ColonColonLoc) {
818  if (SS.isInvalid() || DS.getTypeSpecType() == DeclSpec::TST_error)
819  return true;
820 
821  assert(DS.getTypeSpecType() == DeclSpec::TST_decltype);
822 
824  if (!T->isDependentType() && !T->getAs<TagType>()) {
825  Diag(DS.getTypeSpecTypeLoc(), diag::err_expected_class_or_namespace)
826  << T << getLangOpts().CPlusPlus;
827  return true;
828  }
829 
830  TypeLocBuilder TLB;
831  DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
832  DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc());
834  ColonColonLoc);
835  return false;
836 }
837 
838 /// IsInvalidUnlessNestedName - This method is used for error recovery
839 /// purposes to determine whether the specified identifier is only valid as
840 /// a nested name specifier, for example a namespace name. It is
841 /// conservatively correct to always return false from this method.
842 ///
843 /// The arguments are the same as those passed to ActOnCXXNestedNameSpecifier.
845  IdentifierInfo &Identifier,
848  ParsedType ObjectType,
849  bool EnteringContext) {
850  if (SS.isInvalid())
851  return false;
852 
853  return !BuildCXXNestedNameSpecifier(S, Identifier, IdentifierLoc, ColonLoc,
854  GetTypeFromParser(ObjectType),
855  EnteringContext, SS,
856  /*ScopeLookupResult=*/nullptr, true);
857 }
858 
860  CXXScopeSpec &SS,
861  SourceLocation TemplateKWLoc,
862  TemplateTy Template,
863  SourceLocation TemplateNameLoc,
864  SourceLocation LAngleLoc,
865  ASTTemplateArgsPtr TemplateArgsIn,
866  SourceLocation RAngleLoc,
867  SourceLocation CCLoc,
868  bool EnteringContext) {
869  if (SS.isInvalid())
870  return true;
871 
872  // Translate the parser's template argument list in our AST format.
873  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
874  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
875 
877  if (DTN && DTN->isIdentifier()) {
878  // Handle a dependent template specialization for which we cannot resolve
879  // the template name.
880  assert(DTN->getQualifier() == SS.getScopeRep());
882  DTN->getQualifier(),
883  DTN->getIdentifier(),
884  TemplateArgs);
885 
886  // Create source-location information for this type.
892  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
893  SpecTL.setTemplateNameLoc(TemplateNameLoc);
894  SpecTL.setLAngleLoc(LAngleLoc);
895  SpecTL.setRAngleLoc(RAngleLoc);
896  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
897  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
898 
899  SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
900  CCLoc);
901  return false;
902  }
903 
904  TemplateDecl *TD = Template.get().getAsTemplateDecl();
905  if (Template.get().getAsOverloadedTemplate() || DTN ||
906  isa<FunctionTemplateDecl>(TD) || isa<VarTemplateDecl>(TD)) {
907  SourceRange R(TemplateNameLoc, RAngleLoc);
908  if (SS.getRange().isValid())
909  R.setBegin(SS.getRange().getBegin());
910 
911  Diag(CCLoc, diag::err_non_type_template_in_nested_name_specifier)
912  << (TD && isa<VarTemplateDecl>(TD)) << Template.get() << R;
913  NoteAllFoundTemplates(Template.get());
914  return true;
915  }
916 
917  // We were able to resolve the template name to an actual template.
918  // Build an appropriate nested-name-specifier.
919  QualType T = CheckTemplateIdType(Template.get(), TemplateNameLoc,
920  TemplateArgs);
921  if (T.isNull())
922  return true;
923 
924  // Alias template specializations can produce types which are not valid
925  // nested name specifiers.
926  if (!T->isDependentType() && !T->getAs<TagType>()) {
927  Diag(TemplateNameLoc, diag::err_nested_name_spec_non_tag) << T;
928  NoteAllFoundTemplates(Template.get());
929  return true;
930  }
931 
932  // Provide source-location information for the template specialization type.
935  = Builder.push<TemplateSpecializationTypeLoc>(T);
936  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
937  SpecTL.setTemplateNameLoc(TemplateNameLoc);
938  SpecTL.setLAngleLoc(LAngleLoc);
939  SpecTL.setRAngleLoc(RAngleLoc);
940  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
941  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
942 
943 
944  SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
945  CCLoc);
946  return false;
947 }
948 
949 namespace {
950  /// \brief A structure that stores a nested-name-specifier annotation,
951  /// including both the nested-name-specifier
952  struct NestedNameSpecifierAnnotation {
953  NestedNameSpecifier *NNS;
954  };
955 }
956 
958  if (SS.isEmpty() || SS.isInvalid())
959  return nullptr;
960 
961  void *Mem = Context.Allocate((sizeof(NestedNameSpecifierAnnotation) +
962  SS.location_size()),
963  llvm::alignOf<NestedNameSpecifierAnnotation>());
964  NestedNameSpecifierAnnotation *Annotation
965  = new (Mem) NestedNameSpecifierAnnotation;
966  Annotation->NNS = SS.getScopeRep();
967  memcpy(Annotation + 1, SS.location_data(), SS.location_size());
968  return Annotation;
969 }
970 
972  SourceRange AnnotationRange,
973  CXXScopeSpec &SS) {
974  if (!AnnotationPtr) {
975  SS.SetInvalid(AnnotationRange);
976  return;
977  }
978 
979  NestedNameSpecifierAnnotation *Annotation
980  = static_cast<NestedNameSpecifierAnnotation *>(AnnotationPtr);
981  SS.Adopt(NestedNameSpecifierLoc(Annotation->NNS, Annotation + 1));
982 }
983 
985  assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
986 
987  NestedNameSpecifier *Qualifier = SS.getScopeRep();
988 
989  // There are only two places a well-formed program may qualify a
990  // declarator: first, when defining a namespace or class member
991  // out-of-line, and second, when naming an explicitly-qualified
992  // friend function. The latter case is governed by
993  // C++03 [basic.lookup.unqual]p10:
994  // In a friend declaration naming a member function, a name used
995  // in the function declarator and not part of a template-argument
996  // in a template-id is first looked up in the scope of the member
997  // function's class. If it is not found, or if the name is part of
998  // a template-argument in a template-id, the look up is as
999  // described for unqualified names in the definition of the class
1000  // granting friendship.
1001  // i.e. we don't push a scope unless it's a class member.
1002 
1003  switch (Qualifier->getKind()) {
1007  // These are always namespace scopes. We never want to enter a
1008  // namespace scope from anything but a file context.
1010 
1015  // These are never namespace scopes.
1016  return true;
1017  }
1018 
1019  llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
1020 }
1021 
1022 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
1023 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
1024 /// After this method is called, according to [C++ 3.4.3p3], names should be
1025 /// looked up in the declarator-id's scope, until the declarator is parsed and
1026 /// ActOnCXXExitDeclaratorScope is called.
1027 /// The 'SS' should be a non-empty valid CXXScopeSpec.
1029  assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
1030 
1031  if (SS.isInvalid()) return true;
1032 
1033  DeclContext *DC = computeDeclContext(SS, true);
1034  if (!DC) return true;
1035 
1036  // Before we enter a declarator's context, we need to make sure that
1037  // it is a complete declaration context.
1038  if (!DC->isDependentContext() && RequireCompleteDeclContext(SS, DC))
1039  return true;
1040 
1041  EnterDeclaratorContext(S, DC);
1042 
1043  // Rebuild the nested name specifier for the new scope.
1044  if (DC->isDependentContext())
1046 
1047  return false;
1048 }
1049 
1050 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
1051 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
1052 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
1053 /// Used to indicate that names should revert to being looked up in the
1054 /// defining scope.
1056  assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
1057  if (SS.isInvalid())
1058  return;
1059  assert(!SS.isInvalid() && computeDeclContext(SS, true) &&
1060  "exiting declarator scope we never really entered");
1062 }
NamedDecl * FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS)
If the given nested-name-specifier begins with a bare identifier (e.g., Base::), perform name lookup ...
Defines the clang::ASTContext interface.
Scope * getCurScope() const
Retrieve the parser's current scope.
Definition: Sema.h:9197
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:169
void MakeSuper(ASTContext &Context, CXXRecordDecl *RD, SourceLocation SuperLoc, SourceLocation ColonColonLoc)
Turns this (empty) nested-name-specifier into '__super' nested-name-specifier.
Definition: DeclSpec.cpp:107
A (possibly-)qualified type.
Definition: Type.h:575
Simple class containing the result of Sema::CorrectTypo.
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2636
const LangOptions & getLangOpts() const
Definition: Sema.h:1041
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Sema/Lookup.h:209
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
DeclClass * getAsSingle() const
Definition: Sema/Lookup.h:448
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Sema/Lookup.h:465
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1458
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1118
Defines the C++ template declaration subclasses.
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
bool isEnumeralType() const
Definition: Type.h:5365
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization...
Definition: Decl.h:3143
TemplateSpecializationType(TemplateName T, const TemplateArgument *Args, unsigned NumArgs, QualType Canon, QualType Aliased)
Definition: Type.cpp:3118
The base class of the type hierarchy.
Definition: Type.h:1249
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:884
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1874
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:402
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
Wrapper for source info for typedefs.
Definition: TypeLoc.h:620
Look up of a name that precedes the '::' scope resolution operator in C++.
Definition: Sema.h:2652
bool isAcceptableNestedNameSpecifier(const NamedDecl *SD, bool *CanCorrect=nullptr)
Determines whether the given declaration is an valid acceptable result for name lookup of a nested-na...
void * SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS)
Given a C++ nested-name-specifier, produce an annotation value that the parser can use later to recon...
An identifier, stored as an IdentifierInfo*.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:125
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:319
A namespace, stored as a NamespaceDecl*.
void setBegin(SourceLocation b)
void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS)
ActOnCXXExitDeclaratorScope - Called when a declarator that previously invoked ActOnCXXEnterDeclarato...
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
Definition: TemplateName.h:473
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool OdrUse)
Perform marking for a reference to an arbitrary declaration.
Definition: SemaExpr.cpp:13679
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS, const DeclSpec &DS, SourceLocation ColonColonLoc)
One of these records is kept for each identifier that is lexed.
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template.
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
Definition: Decl.cpp:3678
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4381
A C++ nested-name-specifier augmented with source location information.
Represents a dependent template name that cannot be resolved prior to template instantiation.
Definition: TemplateName.h:411
bool isIdentifier() const
Determine whether this template name refers to an identifier.
Definition: TemplateName.h:470
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Definition: DeclCXX.h:2720
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:1472
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:2788
CXXRecordDecl * getCurrentInstantiationOf(NestedNameSpecifier *NNS)
If the given nested name specifier refers to the current instantiation, return the declaration that c...
bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS)
bool isBeingDefined() const
Determines whether this type is in the process of being defined.
Definition: Type.cpp:2965
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1962
static const TST TST_error
Definition: DeclSpec.h:302
Wrapper for source info for unresolved typename using decls.
Definition: TypeLoc.h:642
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:503
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1191
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:496
Represents the results of name lookup.
Definition: Sema/Lookup.h:30
bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:324
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1895
const LangOptions & getLangOpts() const
Definition: ASTContext.h:596
Wrapper for source info for injected class names of class templates.
Definition: TypeLoc.h:631
A convenient class for passing around template argument information.
Definition: TemplateBase.h:517
unsigned location_size() const
Retrieve the size of the data associated with source-location information.
Definition: DeclSpec.h:221
Wrapper for substituted template type parameters.
Definition: TypeLoc.h:704
char * location_data() const
Retrieve the data associated with the source-location information.
Definition: DeclSpec.h:217
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2486
Wrapper for substituted template type parameters.
Definition: TypeLoc.h:697
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:38
void SetInvalid(SourceRange R)
Indicate that this nested-name-specifier is invalid.
Definition: DeclSpec.h:199
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
Definition: TemplateName.h:467
std::string getAsString() const
getNameAsString - Retrieve the human-readable string for this name.
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Sema/Lookup.h:367
detail::InMemoryDirectory::const_iterator I
QualType getCanonicalTypeInternal() const
Definition: Type.h:1973
bool isInvalid() const
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:753
SourceRange getRange() const
Definition: DeclSpec.h:68
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
EnumDecl * getDecl() const
Definition: Type.h:3576
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:259
TST getTypeSpecType() const
Definition: DeclSpec.h:473
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Sema/Lookup.h:194
bool InstantiateEnum(SourceLocation PointOfInstantiation, EnumDecl *Instantiation, EnumDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiate the definition of an enum from a given pattern.
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:1903
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1881
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, const TemplateArgumentListInfo &Args) const
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1855
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(NamedDecl *D, const TemplateArgumentList *Innermost=nullptr, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Sema/Lookup.h:204
bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS)
The parser has parsed a global nested-name-specifier '::'.
This file defines the classes used to store parsed information about declaration-specifiers and decla...
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:875
void NoteAllFoundTemplates(TemplateName Name)
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:6518
A namespace alias, stored as a NamespaceAliasDecl*.
Wrapper for source info for enum types.
Definition: TypeLoc.h:680
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1751
bool isFunctionOrMethod() const
Definition: DeclBase.h:1249
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1200
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:707
Wraps an identifier and optional source location for the identifier.
Definition: AttributeList.h:50
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:144
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
bool isAmbiguous() const
Definition: Sema/Lookup.h:242
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
TypeLoc getTypeLocInContext(ASTContext &Context, QualType T)
Copies the type-location information to the given AST context and returns a TypeLoc referring into th...
SourceLocation getLastQualifierNameLoc() const
Retrieve the location of the name in the last qualifier in this nested name specifier.
Definition: DeclSpec.cpp:136
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1888
Encodes a location in the source.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3570
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5089
Expr * getRepAsExpr() const
Definition: DeclSpec.h:489
void ExitDeclaratorContext(Scope *S)
Definition: SemaDecl.cpp:1133
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2644
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:143
bool isValid() const
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1701
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
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1843
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
SourceLocation getBegin() const
bool isFileContext() const
Definition: DeclBase.h:1265
PtrTy get() const
Definition: Ownership.h:74
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1451
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2526
bool ActOnCXXNestedNameSpecifier(Scope *S, IdentifierInfo &Identifier, SourceLocation IdentifierLoc, SourceLocation CCLoc, ParsedType ObjectType, bool EnteringContext, CXXScopeSpec &SS, bool ErrorRecoveryLookup=false, bool *IsCorrectedToColon=nullptr)
The parser has parsed a nested-name-specifier 'identifier::'.
bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS, IdentifierInfo &Identifier, SourceLocation IdentifierLoc, SourceLocation ColonLoc, ParsedType ObjectType, bool EnteringContext)
IsInvalidUnlessNestedName - This method is used for error recovery purposes to determine whether the ...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1121
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:331
void setContextRange(SourceRange SR)
Sets a 'context' source range.
Definition: Sema/Lookup.h:533
void EnterDeclaratorContext(Scope *S, DeclContext *DC)
EnterDeclaratorContext - Used when we must lookup names in the context of a declarator's nested name ...
Definition: SemaDecl.cpp:1104
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Sema/Lookup.h:214
static const TST TST_decltype
Definition: DeclSpec.h:295
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1723
bool BuildCXXNestedNameSpecifier(Scope *S, IdentifierInfo &Identifier, SourceLocation IdentifierLoc, SourceLocation CCLoc, QualType ObjectType, bool EnteringContext, CXXScopeSpec &SS, NamedDecl *ScopeLookupResult, bool ErrorRecoveryLookup, bool *IsCorrectedToColon=nullptr)
Build a new nested-name-specifier for "identifier::", as described by ActOnCXXNestedNameSpecifier.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:514
DeclarationName - The name of a declaration.
EnumDecl - Represents an enum.
Definition: Decl.h:2930
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Sema/Lookup.h:249
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1946
bool isCurrentInstantiation(const DeclContext *CurContext) const
Determine whether this dependent class is a current instantiation, when viewed from within the given ...
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation...
Definition: DeclCXX.cpp:388
A type that was preceded by the 'template' keyword, stored as a Type*.
bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc, SourceLocation ColonColonLoc, CXXScopeSpec &SS)
The parser has parsed a '__super' nested-name-specifier.
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1022
bool empty() const
Return true if no decls were found.
Definition: Sema/Lookup.h:280
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3544
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5675
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:148
void RestoreNestedNameSpecifierAnnotation(void *Annotation, SourceRange AnnotationRange, CXXScopeSpec &SS)
Given an annotation pointer for a nested-name-specifier, restore the nested-name-specifier structure...
QualType BuildDecltypeType(Expr *E, SourceLocation Loc, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
Definition: SemaType.cpp:7000
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1495
Wrapper for source info for record types.
Definition: TypeLoc.h:672
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2354
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS)
ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global scope or nested-name-specifi...
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL, SourceLocation ColonColonLoc)
Extend the current nested-name-specifier by another nested-name-specifier component of the form 'type...
Definition: DeclSpec.cpp:47
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS, SourceLocation IdLoc, IdentifierInfo &II, ParsedType ObjectType)
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
BoundNodesTreeBuilder *const Builder
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:560
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:492
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:307
Declaration of a class template.
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
void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc)
Turn this (empty) nested-name-specifier into the global nested-name-specifier '::'.
Definition: DeclSpec.cpp:97
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1465
TagDecl * getDecl() const
Definition: Type.cpp:2961
bool isRecord() const
Definition: DeclBase.h:1273
static CXXRecordDecl * getCurrentInstantiationOf(QualType T, DeclContext *CurContext)
Find the current instantiation that associated with the given type.
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Sema/Lookup.h:523
Wrapper for template type parameters.
Definition: TypeLoc.h:688
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:384
ASTContext & Context
Definition: Sema.h:295
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, std::unique_ptr< CorrectionCandidateCallback > CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
NamedDecl - This represents a decl with a name.
Definition: Decl.h:145
Represents a C++ namespace alias.
Definition: DeclCXX.h:2649
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1486
No keyword precedes the qualified type name.
Definition: Type.h:4204
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:642
The global specifier '::'. There is no stored value.
SourceLocation ColonLoc
Location of ':'.
Definition: OpenMPClause.h:266
void clear()
Clears out any current state.
Definition: Sema/Lookup.h:495