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