clang  3.7.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  // Namespace and namespace aliases are fine.
295  if (isa<NamespaceDecl>(SD) || isa<NamespaceAliasDecl>(SD))
296  return true;
297 
298  if (!isa<TypeDecl>(SD))
299  return false;
300 
301  // Determine whether we have a class (or, in C++11, an enum) or
302  // a typedef thereof. If so, build the nested-name-specifier.
303  QualType T = Context.getTypeDeclType(cast<TypeDecl>(SD));
304  if (T->isDependentType())
305  return true;
306  if (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(SD)) {
307  if (TD->getUnderlyingType()->isRecordType())
308  return true;
309  if (TD->getUnderlyingType()->isEnumeralType()) {
310  if (Context.getLangOpts().CPlusPlus11)
311  return true;
312  if (IsExtension)
313  *IsExtension = true;
314  }
315  } else if (isa<RecordDecl>(SD)) {
316  return true;
317  } else if (isa<EnumDecl>(SD)) {
318  if (Context.getLangOpts().CPlusPlus11)
319  return true;
320  if (IsExtension)
321  *IsExtension = true;
322  }
323 
324  return false;
325 }
326 
327 /// \brief If the given nested-name-specifier begins with a bare identifier
328 /// (e.g., Base::), perform name lookup for that identifier as a
329 /// nested-name-specifier within the given scope, and return the result of that
330 /// name lookup.
332  if (!S || !NNS)
333  return nullptr;
334 
335  while (NNS->getPrefix())
336  NNS = NNS->getPrefix();
337 
339  return nullptr;
340 
341  LookupResult Found(*this, NNS->getAsIdentifier(), SourceLocation(),
343  LookupName(Found, S);
344  assert(!Found.isAmbiguous() && "Cannot handle ambiguities here yet");
345 
346  if (!Found.isSingleResult())
347  return nullptr;
348 
349  NamedDecl *Result = Found.getFoundDecl();
351  return Result;
352 
353  return nullptr;
354 }
355 
357  SourceLocation IdLoc,
358  IdentifierInfo &II,
359  ParsedType ObjectTypePtr) {
360  QualType ObjectType = GetTypeFromParser(ObjectTypePtr);
361  LookupResult Found(*this, &II, IdLoc, LookupNestedNameSpecifierName);
362 
363  // Determine where to perform name lookup
364  DeclContext *LookupCtx = nullptr;
365  bool isDependent = false;
366  if (!ObjectType.isNull()) {
367  // This nested-name-specifier occurs in a member access expression, e.g.,
368  // x->B::f, and we are looking into the type of the object.
369  assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
370  LookupCtx = computeDeclContext(ObjectType);
371  isDependent = ObjectType->isDependentType();
372  } else if (SS.isSet()) {
373  // This nested-name-specifier occurs after another nested-name-specifier,
374  // so long into the context associated with the prior nested-name-specifier.
375  LookupCtx = computeDeclContext(SS, false);
376  isDependent = isDependentScopeSpecifier(SS);
377  Found.setContextRange(SS.getRange());
378  }
379 
380  if (LookupCtx) {
381  // Perform "qualified" name lookup into the declaration context we
382  // computed, which is either the type of the base of a member access
383  // expression or the declaration context associated with a prior
384  // nested-name-specifier.
385 
386  // The declaration context must be complete.
387  if (!LookupCtx->isDependentContext() &&
388  RequireCompleteDeclContext(SS, LookupCtx))
389  return false;
390 
391  LookupQualifiedName(Found, LookupCtx);
392  } else if (isDependent) {
393  return false;
394  } else {
395  LookupName(Found, S);
396  }
397  Found.suppressDiagnostics();
398 
399  if (NamedDecl *ND = Found.getAsSingle<NamedDecl>())
400  return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
401 
402  return false;
403 }
404 
405 namespace {
406 
407 // Callback to only accept typo corrections that can be a valid C++ member
408 // intializer: either a non-static field member or a base class.
409 class NestedNameSpecifierValidatorCCC : public CorrectionCandidateCallback {
410  public:
411  explicit NestedNameSpecifierValidatorCCC(Sema &SRef)
412  : SRef(SRef) {}
413 
414  bool ValidateCandidate(const TypoCorrection &candidate) override {
415  return SRef.isAcceptableNestedNameSpecifier(candidate.getCorrectionDecl());
416  }
417 
418  private:
419  Sema &SRef;
420 };
421 
422 }
423 
424 /// \brief Build a new nested-name-specifier for "identifier::", as described
425 /// by ActOnCXXNestedNameSpecifier.
426 ///
427 /// \param S Scope in which the nested-name-specifier occurs.
428 /// \param Identifier Identifier in the sequence "identifier" "::".
429 /// \param IdentifierLoc Location of the \p Identifier.
430 /// \param CCLoc Location of "::" following Identifier.
431 /// \param ObjectType Type of postfix expression if the nested-name-specifier
432 /// occurs in construct like: <tt>ptr->nns::f</tt>.
433 /// \param EnteringContext If true, enter the context specified by the
434 /// nested-name-specifier.
435 /// \param SS Optional nested name specifier preceding the identifier.
436 /// \param ScopeLookupResult Provides the result of name lookup within the
437 /// scope of the nested-name-specifier that was computed at template
438 /// definition time.
439 /// \param ErrorRecoveryLookup Specifies if the method is called to improve
440 /// error recovery and what kind of recovery is performed.
441 /// \param IsCorrectedToColon If not null, suggestion of replace '::' -> ':'
442 /// are allowed. The bool value pointed by this parameter is set to
443 /// 'true' if the identifier is treated as if it was followed by ':',
444 /// not '::'.
445 ///
446 /// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in
447 /// that it contains an extra parameter \p ScopeLookupResult, which provides
448 /// the result of name lookup within the scope of the nested-name-specifier
449 /// that was computed at template definition time.
450 ///
451 /// If ErrorRecoveryLookup is true, then this call is used to improve error
452 /// recovery. This means that it should not emit diagnostics, it should
453 /// just return true on failure. It also means it should only return a valid
454 /// scope if it *knows* that the result is correct. It should not return in a
455 /// dependent context, for example. Nor will it extend \p SS with the scope
456 /// specifier.
458  IdentifierInfo &Identifier,
460  SourceLocation CCLoc,
461  QualType ObjectType,
462  bool EnteringContext,
463  CXXScopeSpec &SS,
464  NamedDecl *ScopeLookupResult,
465  bool ErrorRecoveryLookup,
466  bool *IsCorrectedToColon) {
467  LookupResult Found(*this, &Identifier, IdentifierLoc,
469 
470  // Determine where to perform name lookup
471  DeclContext *LookupCtx = nullptr;
472  bool isDependent = false;
473  if (IsCorrectedToColon)
474  *IsCorrectedToColon = false;
475  if (!ObjectType.isNull()) {
476  // This nested-name-specifier occurs in a member access expression, e.g.,
477  // x->B::f, and we are looking into the type of the object.
478  assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
479  LookupCtx = computeDeclContext(ObjectType);
480  isDependent = ObjectType->isDependentType();
481  } else if (SS.isSet()) {
482  // This nested-name-specifier occurs after another nested-name-specifier,
483  // so look into the context associated with the prior nested-name-specifier.
484  LookupCtx = computeDeclContext(SS, EnteringContext);
485  isDependent = isDependentScopeSpecifier(SS);
486  Found.setContextRange(SS.getRange());
487  }
488 
489  bool ObjectTypeSearchedInScope = false;
490  if (LookupCtx) {
491  // Perform "qualified" name lookup into the declaration context we
492  // computed, which is either the type of the base of a member access
493  // expression or the declaration context associated with a prior
494  // nested-name-specifier.
495 
496  // The declaration context must be complete.
497  if (!LookupCtx->isDependentContext() &&
498  RequireCompleteDeclContext(SS, LookupCtx))
499  return true;
500 
501  LookupQualifiedName(Found, LookupCtx);
502 
503  if (!ObjectType.isNull() && Found.empty()) {
504  // C++ [basic.lookup.classref]p4:
505  // If the id-expression in a class member access is a qualified-id of
506  // the form
507  //
508  // class-name-or-namespace-name::...
509  //
510  // the class-name-or-namespace-name following the . or -> operator is
511  // looked up both in the context of the entire postfix-expression and in
512  // the scope of the class of the object expression. If the name is found
513  // only in the scope of the class of the object expression, the name
514  // shall refer to a class-name. If the name is found only in the
515  // context of the entire postfix-expression, the name shall refer to a
516  // class-name or namespace-name. [...]
517  //
518  // Qualified name lookup into a class will not find a namespace-name,
519  // so we do not need to diagnose that case specifically. However,
520  // this qualified name lookup may find nothing. In that case, perform
521  // unqualified name lookup in the given scope (if available) or
522  // reconstruct the result from when name lookup was performed at template
523  // definition time.
524  if (S)
525  LookupName(Found, S);
526  else if (ScopeLookupResult)
527  Found.addDecl(ScopeLookupResult);
528 
529  ObjectTypeSearchedInScope = true;
530  }
531  } else if (!isDependent) {
532  // Perform unqualified name lookup in the current scope.
533  LookupName(Found, S);
534  }
535 
536  // If we performed lookup into a dependent context and did not find anything,
537  // that's fine: just build a dependent nested-name-specifier.
538  if (Found.empty() && isDependent &&
539  !(LookupCtx && LookupCtx->isRecord() &&
540  (!cast<CXXRecordDecl>(LookupCtx)->hasDefinition() ||
541  !cast<CXXRecordDecl>(LookupCtx)->hasAnyDependentBases()))) {
542  // Don't speculate if we're just trying to improve error recovery.
543  if (ErrorRecoveryLookup)
544  return true;
545 
546  // We were not able to compute the declaration context for a dependent
547  // base object type or prior nested-name-specifier, so this
548  // nested-name-specifier refers to an unknown specialization. Just build
549  // a dependent nested-name-specifier.
550  SS.Extend(Context, &Identifier, IdentifierLoc, CCLoc);
551  return false;
552  }
553 
554  // FIXME: Deal with ambiguities cleanly.
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  // The identifier is found in ordinary lookup. If correction to colon is
566  // allowed, suggest replacement to ':'.
567  if (IsCorrectedToColon) {
568  *IsCorrectedToColon = true;
569  Diag(CCLoc, diag::err_nested_name_spec_is_not_class)
570  << &Identifier << getLangOpts().CPlusPlus
571  << FixItHint::CreateReplacement(CCLoc, ":");
572  if (NamedDecl *ND = R.getAsSingle<NamedDecl>())
573  Diag(ND->getLocation(), diag::note_declared_at);
574  return true;
575  }
576  // Replacement '::' -> ':' is not allowed, just issue respective error.
577  Diag(R.getNameLoc(), diag::err_expected_class_or_namespace)
578  << &Identifier << getLangOpts().CPlusPlus;
579  if (NamedDecl *ND = R.getAsSingle<NamedDecl>())
580  Diag(ND->getLocation(), diag::note_entity_declared_at) << &Identifier;
581  return true;
582  }
583  }
584 
585  if (Found.empty() && !ErrorRecoveryLookup && !getLangOpts().MSVCCompat) {
586  // We haven't found anything, and we're not recovering from a
587  // different kind of error, so look for typos.
588  DeclarationName Name = Found.getLookupName();
589  Found.clear();
590  if (TypoCorrection Corrected = CorrectTypo(
591  Found.getLookupNameInfo(), Found.getLookupKind(), S, &SS,
592  llvm::make_unique<NestedNameSpecifierValidatorCCC>(*this),
593  CTK_ErrorRecovery, LookupCtx, EnteringContext)) {
594  if (LookupCtx) {
595  bool DroppedSpecifier =
596  Corrected.WillReplaceSpecifier() &&
597  Name.getAsString() == Corrected.getAsString(getLangOpts());
598  if (DroppedSpecifier)
599  SS.clear();
600  diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
601  << Name << LookupCtx << DroppedSpecifier
602  << SS.getRange());
603  } else
604  diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest)
605  << Name);
606 
607  if (NamedDecl *ND = Corrected.getCorrectionDecl())
608  Found.addDecl(ND);
609  Found.setLookupName(Corrected.getCorrection());
610  } else {
611  Found.setLookupName(&Identifier);
612  }
613  }
614 
615  NamedDecl *SD = Found.getAsSingle<NamedDecl>();
616  bool IsExtension = false;
617  bool AcceptSpec = isAcceptableNestedNameSpecifier(SD, &IsExtension);
618  if (!AcceptSpec && IsExtension) {
619  AcceptSpec = true;
620  Diag(IdentifierLoc, diag::ext_nested_name_spec_is_enum);
621  }
622  if (AcceptSpec) {
623  if (!ObjectType.isNull() && !ObjectTypeSearchedInScope &&
624  !getLangOpts().CPlusPlus11) {
625  // C++03 [basic.lookup.classref]p4:
626  // [...] If the name is found in both contexts, the
627  // class-name-or-namespace-name shall refer to the same entity.
628  //
629  // We already found the name in the scope of the object. Now, look
630  // into the current scope (the scope of the postfix-expression) to
631  // see if we can find the same name there. As above, if there is no
632  // scope, reconstruct the result from the template instantiation itself.
633  //
634  // Note that C++11 does *not* perform this redundant lookup.
635  NamedDecl *OuterDecl;
636  if (S) {
637  LookupResult FoundOuter(*this, &Identifier, IdentifierLoc,
639  LookupName(FoundOuter, S);
640  OuterDecl = FoundOuter.getAsSingle<NamedDecl>();
641  } else
642  OuterDecl = ScopeLookupResult;
643 
644  if (isAcceptableNestedNameSpecifier(OuterDecl) &&
645  OuterDecl->getCanonicalDecl() != SD->getCanonicalDecl() &&
646  (!isa<TypeDecl>(OuterDecl) || !isa<TypeDecl>(SD) ||
648  Context.getTypeDeclType(cast<TypeDecl>(OuterDecl)),
649  Context.getTypeDeclType(cast<TypeDecl>(SD))))) {
650  if (ErrorRecoveryLookup)
651  return true;
652 
653  Diag(IdentifierLoc,
654  diag::err_nested_name_member_ref_lookup_ambiguous)
655  << &Identifier;
656  Diag(SD->getLocation(), diag::note_ambig_member_ref_object_type)
657  << ObjectType;
658  Diag(OuterDecl->getLocation(), diag::note_ambig_member_ref_scope);
659 
660  // Fall through so that we'll pick the name we found in the object
661  // type, since that's probably what the user wanted anyway.
662  }
663  }
664 
665  if (auto *TD = dyn_cast_or_null<TypedefNameDecl>(SD))
666  MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
667 
668  // If we're just performing this lookup for error-recovery purposes,
669  // don't extend the nested-name-specifier. Just return now.
670  if (ErrorRecoveryLookup)
671  return false;
672 
673  // The use of a nested name specifier may trigger deprecation warnings.
674  DiagnoseUseOfDecl(SD, CCLoc);
675 
676 
677  if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(SD)) {
678  SS.Extend(Context, Namespace, IdentifierLoc, CCLoc);
679  return false;
680  }
681 
682  if (NamespaceAliasDecl *Alias = dyn_cast<NamespaceAliasDecl>(SD)) {
683  SS.Extend(Context, Alias, IdentifierLoc, CCLoc);
684  return false;
685  }
686 
687  QualType T = Context.getTypeDeclType(cast<TypeDecl>(SD));
688  TypeLocBuilder TLB;
689  if (isa<InjectedClassNameType>(T)) {
690  InjectedClassNameTypeLoc InjectedTL
691  = TLB.push<InjectedClassNameTypeLoc>(T);
692  InjectedTL.setNameLoc(IdentifierLoc);
693  } else if (isa<RecordType>(T)) {
694  RecordTypeLoc RecordTL = TLB.push<RecordTypeLoc>(T);
695  RecordTL.setNameLoc(IdentifierLoc);
696  } else if (isa<TypedefType>(T)) {
697  TypedefTypeLoc TypedefTL = TLB.push<TypedefTypeLoc>(T);
698  TypedefTL.setNameLoc(IdentifierLoc);
699  } else if (isa<EnumType>(T)) {
700  EnumTypeLoc EnumTL = TLB.push<EnumTypeLoc>(T);
701  EnumTL.setNameLoc(IdentifierLoc);
702  } else if (isa<TemplateTypeParmType>(T)) {
703  TemplateTypeParmTypeLoc TemplateTypeTL
704  = TLB.push<TemplateTypeParmTypeLoc>(T);
705  TemplateTypeTL.setNameLoc(IdentifierLoc);
706  } else if (isa<UnresolvedUsingType>(T)) {
707  UnresolvedUsingTypeLoc UnresolvedTL
708  = TLB.push<UnresolvedUsingTypeLoc>(T);
709  UnresolvedTL.setNameLoc(IdentifierLoc);
710  } else if (isa<SubstTemplateTypeParmType>(T)) {
713  TL.setNameLoc(IdentifierLoc);
714  } else if (isa<SubstTemplateTypeParmPackType>(T)) {
717  TL.setNameLoc(IdentifierLoc);
718  } else {
719  llvm_unreachable("Unhandled TypeDecl node in nested-name-specifier");
720  }
721 
722  if (T->isEnumeralType())
723  Diag(IdentifierLoc, diag::warn_cxx98_compat_enum_nested_name_spec);
724 
726  CCLoc);
727  return false;
728  }
729 
730  // Otherwise, we have an error case. If we don't want diagnostics, just
731  // return an error now.
732  if (ErrorRecoveryLookup)
733  return true;
734 
735  // If we didn't find anything during our lookup, try again with
736  // ordinary name lookup, which can help us produce better error
737  // messages.
738  if (Found.empty()) {
739  Found.clear(LookupOrdinaryName);
740  LookupName(Found, S);
741  }
742 
743  // In Microsoft mode, if we are within a templated function and we can't
744  // resolve Identifier, then extend the SS with Identifier. This will have
745  // the effect of resolving Identifier during template instantiation.
746  // The goal is to be able to resolve a function call whose
747  // nested-name-specifier is located inside a dependent base class.
748  // Example:
749  //
750  // class C {
751  // public:
752  // static void foo2() { }
753  // };
754  // template <class T> class A { public: typedef C D; };
755  //
756  // template <class T> class B : public A<T> {
757  // public:
758  // void foo() { D::foo2(); }
759  // };
760  if (getLangOpts().MSVCCompat) {
761  DeclContext *DC = LookupCtx ? LookupCtx : CurContext;
762  if (DC->isDependentContext() && DC->isFunctionOrMethod()) {
763  CXXRecordDecl *ContainingClass = dyn_cast<CXXRecordDecl>(DC->getParent());
764  if (ContainingClass && ContainingClass->hasAnyDependentBases()) {
765  Diag(IdentifierLoc, diag::ext_undeclared_unqual_id_with_dependent_base)
766  << &Identifier << ContainingClass;
767  SS.Extend(Context, &Identifier, IdentifierLoc, CCLoc);
768  return false;
769  }
770  }
771  }
772 
773  if (!Found.empty()) {
774  if (TypeDecl *TD = Found.getAsSingle<TypeDecl>())
775  Diag(IdentifierLoc, diag::err_expected_class_or_namespace)
776  << QualType(TD->getTypeForDecl(), 0) << getLangOpts().CPlusPlus;
777  else {
778  Diag(IdentifierLoc, diag::err_expected_class_or_namespace)
779  << &Identifier << getLangOpts().CPlusPlus;
780  if (NamedDecl *ND = Found.getAsSingle<NamedDecl>())
781  Diag(ND->getLocation(), diag::note_entity_declared_at) << &Identifier;
782  }
783  } else if (SS.isSet())
784  Diag(IdentifierLoc, diag::err_no_member) << &Identifier << LookupCtx
785  << SS.getRange();
786  else
787  Diag(IdentifierLoc, diag::err_undeclared_var_use) << &Identifier;
788 
789  return true;
790 }
791 
793  IdentifierInfo &Identifier,
795  SourceLocation CCLoc,
796  ParsedType ObjectType,
797  bool EnteringContext,
798  CXXScopeSpec &SS,
799  bool ErrorRecoveryLookup,
800  bool *IsCorrectedToColon) {
801  if (SS.isInvalid())
802  return true;
803 
804  return BuildCXXNestedNameSpecifier(S, Identifier, IdentifierLoc, CCLoc,
805  GetTypeFromParser(ObjectType),
806  EnteringContext, SS,
807  /*ScopeLookupResult=*/nullptr, false,
808  IsCorrectedToColon);
809 }
810 
812  const DeclSpec &DS,
813  SourceLocation ColonColonLoc) {
814  if (SS.isInvalid() || DS.getTypeSpecType() == DeclSpec::TST_error)
815  return true;
816 
817  assert(DS.getTypeSpecType() == DeclSpec::TST_decltype);
818 
820  if (!T->isDependentType() && !T->getAs<TagType>()) {
821  Diag(DS.getTypeSpecTypeLoc(), diag::err_expected_class_or_namespace)
822  << T << getLangOpts().CPlusPlus;
823  return true;
824  }
825 
826  TypeLocBuilder TLB;
827  DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
828  DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc());
830  ColonColonLoc);
831  return false;
832 }
833 
834 /// IsInvalidUnlessNestedName - This method is used for error recovery
835 /// purposes to determine whether the specified identifier is only valid as
836 /// a nested name specifier, for example a namespace name. It is
837 /// conservatively correct to always return false from this method.
838 ///
839 /// The arguments are the same as those passed to ActOnCXXNestedNameSpecifier.
841  IdentifierInfo &Identifier,
844  ParsedType ObjectType,
845  bool EnteringContext) {
846  if (SS.isInvalid())
847  return false;
848 
849  return !BuildCXXNestedNameSpecifier(S, Identifier, IdentifierLoc, ColonLoc,
850  GetTypeFromParser(ObjectType),
851  EnteringContext, SS,
852  /*ScopeLookupResult=*/nullptr, true);
853 }
854 
856  CXXScopeSpec &SS,
857  SourceLocation TemplateKWLoc,
858  TemplateTy Template,
859  SourceLocation TemplateNameLoc,
860  SourceLocation LAngleLoc,
861  ASTTemplateArgsPtr TemplateArgsIn,
862  SourceLocation RAngleLoc,
863  SourceLocation CCLoc,
864  bool EnteringContext) {
865  if (SS.isInvalid())
866  return true;
867 
868  // Translate the parser's template argument list in our AST format.
869  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
870  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
871 
873  if (DTN && DTN->isIdentifier()) {
874  // Handle a dependent template specialization for which we cannot resolve
875  // the template name.
876  assert(DTN->getQualifier() == SS.getScopeRep());
878  DTN->getQualifier(),
879  DTN->getIdentifier(),
880  TemplateArgs);
881 
882  // Create source-location information for this type.
888  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
889  SpecTL.setTemplateNameLoc(TemplateNameLoc);
890  SpecTL.setLAngleLoc(LAngleLoc);
891  SpecTL.setRAngleLoc(RAngleLoc);
892  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
893  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
894 
895  SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
896  CCLoc);
897  return false;
898  }
899 
900  TemplateDecl *TD = Template.get().getAsTemplateDecl();
901  if (Template.get().getAsOverloadedTemplate() || DTN ||
902  isa<FunctionTemplateDecl>(TD) || isa<VarTemplateDecl>(TD)) {
903  SourceRange R(TemplateNameLoc, RAngleLoc);
904  if (SS.getRange().isValid())
905  R.setBegin(SS.getRange().getBegin());
906 
907  Diag(CCLoc, diag::err_non_type_template_in_nested_name_specifier)
908  << (TD && isa<VarTemplateDecl>(TD)) << Template.get() << R;
909  NoteAllFoundTemplates(Template.get());
910  return true;
911  }
912 
913  // We were able to resolve the template name to an actual template.
914  // Build an appropriate nested-name-specifier.
915  QualType T = CheckTemplateIdType(Template.get(), TemplateNameLoc,
916  TemplateArgs);
917  if (T.isNull())
918  return true;
919 
920  // Alias template specializations can produce types which are not valid
921  // nested name specifiers.
922  if (!T->isDependentType() && !T->getAs<TagType>()) {
923  Diag(TemplateNameLoc, diag::err_nested_name_spec_non_tag) << T;
924  NoteAllFoundTemplates(Template.get());
925  return true;
926  }
927 
928  // Provide source-location information for the template specialization type.
931  = Builder.push<TemplateSpecializationTypeLoc>(T);
932  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
933  SpecTL.setTemplateNameLoc(TemplateNameLoc);
934  SpecTL.setLAngleLoc(LAngleLoc);
935  SpecTL.setRAngleLoc(RAngleLoc);
936  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
937  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
938 
939 
940  SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
941  CCLoc);
942  return false;
943 }
944 
945 namespace {
946  /// \brief A structure that stores a nested-name-specifier annotation,
947  /// including both the nested-name-specifier
948  struct NestedNameSpecifierAnnotation {
949  NestedNameSpecifier *NNS;
950  };
951 }
952 
954  if (SS.isEmpty() || SS.isInvalid())
955  return nullptr;
956 
957  void *Mem = Context.Allocate((sizeof(NestedNameSpecifierAnnotation) +
958  SS.location_size()),
959  llvm::alignOf<NestedNameSpecifierAnnotation>());
960  NestedNameSpecifierAnnotation *Annotation
961  = new (Mem) NestedNameSpecifierAnnotation;
962  Annotation->NNS = SS.getScopeRep();
963  memcpy(Annotation + 1, SS.location_data(), SS.location_size());
964  return Annotation;
965 }
966 
968  SourceRange AnnotationRange,
969  CXXScopeSpec &SS) {
970  if (!AnnotationPtr) {
971  SS.SetInvalid(AnnotationRange);
972  return;
973  }
974 
975  NestedNameSpecifierAnnotation *Annotation
976  = static_cast<NestedNameSpecifierAnnotation *>(AnnotationPtr);
977  SS.Adopt(NestedNameSpecifierLoc(Annotation->NNS, Annotation + 1));
978 }
979 
981  assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
982 
983  NestedNameSpecifier *Qualifier = SS.getScopeRep();
984 
985  // There are only two places a well-formed program may qualify a
986  // declarator: first, when defining a namespace or class member
987  // out-of-line, and second, when naming an explicitly-qualified
988  // friend function. The latter case is governed by
989  // C++03 [basic.lookup.unqual]p10:
990  // In a friend declaration naming a member function, a name used
991  // in the function declarator and not part of a template-argument
992  // in a template-id is first looked up in the scope of the member
993  // function's class. If it is not found, or if the name is part of
994  // a template-argument in a template-id, the look up is as
995  // described for unqualified names in the definition of the class
996  // granting friendship.
997  // i.e. we don't push a scope unless it's a class member.
998 
999  switch (Qualifier->getKind()) {
1003  // These are always namespace scopes. We never want to enter a
1004  // namespace scope from anything but a file context.
1006 
1011  // These are never namespace scopes.
1012  return true;
1013  }
1014 
1015  llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
1016 }
1017 
1018 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
1019 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
1020 /// After this method is called, according to [C++ 3.4.3p3], names should be
1021 /// looked up in the declarator-id's scope, until the declarator is parsed and
1022 /// ActOnCXXExitDeclaratorScope is called.
1023 /// The 'SS' should be a non-empty valid CXXScopeSpec.
1025  assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
1026 
1027  if (SS.isInvalid()) return true;
1028 
1029  DeclContext *DC = computeDeclContext(SS, true);
1030  if (!DC) return true;
1031 
1032  // Before we enter a declarator's context, we need to make sure that
1033  // it is a complete declaration context.
1034  if (!DC->isDependentContext() && RequireCompleteDeclContext(SS, DC))
1035  return true;
1036 
1037  EnterDeclaratorContext(S, DC);
1038 
1039  // Rebuild the nested name specifier for the new scope.
1040  if (DC->isDependentContext())
1042 
1043  return false;
1044 }
1045 
1046 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
1047 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
1048 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
1049 /// Used to indicate that names should revert to being looked up in the
1050 /// defining scope.
1052  assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
1053  if (SS.isInvalid())
1054  return;
1055  assert(!SS.isInvalid() && computeDeclContext(SS, true) &&
1056  "exiting declarator scope we never really entered");
1058 }
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:8979
StringRef getName() const
Definition: Decl.h:168
void MakeSuper(ASTContext &Context, CXXRecordDecl *RD, SourceLocation SuperLoc, SourceLocation ColonColonLoc)
Turns this (empty) nested-name-specifier into '__super' nested-name-specifier.
Definition: DeclSpec.cpp:117
Simple class containing the result of Sema::CorrectTypo.
const LangOptions & getLangOpts() const
Definition: Sema.h:1019
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: 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: Lookup.h:447
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1446
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:1088
Defines the C++ template declaration subclasses.
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
bool isEnumeralType() const
Definition: Type.h:5292
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization...
Definition: Decl.h:3204
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:851
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1862
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:400
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
Wrapper for source info for typedefs.
Definition: TypeLoc.h:612
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:135
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.
A namespace, stored as a NamespaceDecl*.
void setBegin(SourceLocation b)
void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS)
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:194
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
Definition: TemplateName.h:502
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool OdrUse)
Perform marking for a reference to an arbitrary declaration. It marks the declaration referenced...
Definition: SemaExpr.cpp:13367
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS, const DeclSpec &DS, SourceLocation ColonColonLoc)
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
Definition: Decl.cpp:3561
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:440
bool isIdentifier() const
Determine whether this template name refers to an identifier.
Definition: TemplateName.h:499
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Definition: DeclCXX.h:2733
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:1460
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
bool isCompleteDefinition() const
Definition: Decl.h:2838
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:2862
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1871
static const TST TST_error
Definition: DeclSpec.h:306
Wrapper for source info for unresolved typename using decls.
Definition: TypeLoc.h:634
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:1114
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:488
Represents the results of name lookup.
Definition: 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:323
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1883
const LangOptions & getLangOpts() const
Definition: ASTContext.h:533
Wrapper for source info for injected class names of class templates.
Definition: TypeLoc.h:623
unsigned location_size() const
Retrieve the size of the data associated with source-location information.
Definition: DeclSpec.h:226
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template.
Definition: TemplateName.h:241
Wrapper for substituted template type parameters.
Definition: TypeLoc.h:696
char * location_data() const
Retrieve the data associated with the source-location information.
Definition: DeclSpec.h:222
Wrapper for substituted template type parameters.
Definition: TypeLoc.h:689
void SetInvalid(SourceRange R)
Indicate that this nested-name-specifier is invalid.
Definition: DeclSpec.h:204
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:68
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
Definition: TemplateName.h:496
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. Does not test the acceptance criteria...
Definition: Lookup.h:366
QualType getCanonicalTypeInternal() const
Definition: Type.h:1951
bool isInvalid() const
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:733
TyLocType push(QualType T)
EnumDecl * getDecl() const
Definition: Type.h:3550
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
Definition: TemplateName.h:284
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:258
TST getTypeSpecType() const
Definition: DeclSpec.h:474
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: 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:1891
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1869
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:1843
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: 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:812
void NoteAllFoundTemplates(TemplateName Name)
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:6354
A namespace alias, stored as a NamespaceAliasDecl*.
Wrapper for source info for enum types.
Definition: TypeLoc.h:672
const SourceRange & getRange() const
Definition: DeclSpec.h:73
bool isDependentType() const
Definition: Type.h:1727
bool isFunctionOrMethod() const
Definition: DeclBase.h:1223
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1174
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.
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:81
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:146
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1876
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
const Type * getTypePtr() const
Definition: Type.h:5016
Expr * getRepAsExpr() const
Definition: DeclSpec.h:489
void ExitDeclaratorContext(Scope *S)
Definition: SemaDecl.cpp:1132
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2694
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:153
bool isValid() const
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1717
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:199
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1831
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
SourceLocation getBegin() const
bool isFileContext() const
Definition: DeclBase.h:1239
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:1439
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2576
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)
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:311
void setContextRange(SourceRange SR)
Sets a 'context' source range.
Definition: Lookup.h:532
void EnterDeclaratorContext(Scope *S, DeclContext *DC)
Definition: SemaDecl.cpp:1103
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:214
static const TST TST_decltype
Definition: DeclSpec.h:300
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1639
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:503
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1855
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:394
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: Lookup.h:279
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
const T * getAs() const
Definition: Type.h:5555
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)
Definition: SemaType.cpp:6810
DeclContext * getRedeclContext()
Definition: DeclBase.cpp:1466
Wrapper for source info for record types.
Definition: TypeLoc.h:664
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2305
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS)
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:57
Captures information about "declaration specifiers".
Definition: DeclSpec.h:233
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:501
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:481
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:107
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1453
TagDecl * getDecl() const
Definition: Type.cpp:2858
bool isRecord() const
Definition: DeclBase.h:1247
static CXXRecordDecl * getCurrentInstantiationOf(QualType T, DeclContext *CurContext)
Find the current instantiation that associated with the given type.
bool isSet() const
Definition: DeclSpec.h:214
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:3941
void suppressDiagnostics()
Definition: Lookup.h:522
Wrapper for template type parameters.
Definition: TypeLoc.h:680
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:372
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...
Represents a C++ namespace alias.
Definition: DeclCXX.h:2662
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1474
No keyword precedes the qualified type name.
Definition: Type.h:4158
bool isNull() const
isNull - Return true if this QualType doesn't point to a type yet.
Definition: Type.h:633
The global specifier '::'. There is no stored value.
SourceLocation ColonLoc
Location of ':'.
Definition: OpenMPClause.h:260
void clear()
Clears out any current state.
Definition: Lookup.h:494