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