39#include "llvm/ADT/SmallBitVector.h"
40#include "llvm/ADT/StringExtras.h"
51 return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc());
59 for (
Scope *TempParamScope = S->getTemplateParamParent(); TempParamScope;
60 TempParamScope = TempParamScope->getParent()->getTemplateParamParent()) {
65 auto ParamsAtDepth = [&](
unsigned D) { Depth = std::max(Depth,
D + 1); };
70 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(FSI)) {
71 if (!LSI->TemplateParams.empty()) {
72 ParamsAtDepth(LSI->AutoTemplateParameterDepth);
75 if (LSI->GLTemplateParameterList) {
76 ParamsAtDepth(LSI->GLTemplateParameterList->getDepth());
86 if (!Info.TemplateParams.empty()) {
87 ParamsAtDepth(Info.AutoTemplateParameterDepth);
102 bool AllowFunctionTemplates,
103 bool AllowDependent) {
104 D =
D->getUnderlyingDecl();
106 if (isa<TemplateDecl>(
D)) {
107 if (!AllowFunctionTemplates && isa<FunctionTemplateDecl>(
D))
113 if (
const auto *
Record = dyn_cast<CXXRecordDecl>(
D)) {
125 if (
Record->isInjectedClassName()) {
127 if (
Record->getDescribedClassTemplate())
128 return Record->getDescribedClassTemplate();
130 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(
Record))
131 return Spec->getSpecializedTemplate();
140 if (AllowDependent && isa<UnresolvedUsingValueDecl>(
D))
147 bool AllowFunctionTemplates,
148 bool AllowDependent) {
159 bool AllowFunctionTemplates,
161 bool AllowNonTemplateFunctions) {
165 if (AllowNonTemplateFunctions &&
166 isa<FunctionDecl>((*I)->getUnderlyingDecl()))
175 bool hasTemplateKeyword,
178 bool EnteringContext,
180 bool &MemberOfUnknownSpecialization,
181 bool Disambiguation) {
185 MemberOfUnknownSpecialization =
false;
187 switch (Name.getKind()) {
194 Name.OperatorFunctionId.Operator);
234 bool AnyFunctionTemplates =
false;
237 if (isa<FunctionTemplateDecl>(FoundTemplate))
238 AnyFunctionTemplates =
true;
241 FoundUsingShadow = dyn_cast<UsingShadowDecl>(FoundD);
249 if (!
D && !AnyFunctionTemplates) {
250 R.suppressDiagnostics();
267 unsigned ResultCount = R.
end() - R.
begin();
268 if (!
D && ResultCount > 1) {
279 assert(
D &&
"unambiguous result is not a template name");
282 if (isa<UnresolvedUsingValueDecl>(
D)) {
284 MemberOfUnknownSpecialization =
true;
291 assert(!FoundUsingShadow || FoundUsingShadow->
getTargetDecl() == TD);
298 if (isa<FunctionTemplateDecl>(TD)) {
304 assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||
305 isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||
306 isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl>(TD));
329 if (R.
empty())
return false;
366 Diag(IILoc, diag::err_template_kw_missing)
376 QualType ObjectType,
bool EnteringContext,
379 bool AllowTypoCorrection) {
386 Found.setTemplateNameLookup(
true);
390 bool IsDependent =
false;
391 if (!ObjectType.
isNull()) {
394 assert(SS.
isEmpty() &&
"ObjectType and scope specifier cannot coexist");
400 "Caller should have completed object type");
432 bool ObjectTypeSearchedInScope =
false;
433 bool AllowFunctionTemplatesInLookup =
true;
449 IsDependent |=
Found.wasNotFoundInCurrentInstantiation();
465 if (!ObjectType.
isNull()) {
469 AllowFunctionTemplatesInLookup =
false;
470 ObjectTypeSearchedInScope =
true;
473 IsDependent |=
Found.wasNotFoundInCurrentInstantiation();
476 if (
Found.isAmbiguous())
493 if (AllFunctions || (
Found.empty() && !IsDependent)) {
497 *ATK = (
Found.empty() &&
Found.getLookupName().isIdentifier())
505 if (
Found.empty() && !IsDependent && AllowTypoCorrection) {
513 FilterCCC.WantExpressionKeywords =
false;
514 FilterCCC.WantRemainingKeywords =
false;
515 FilterCCC.WantCXXNamedCasts =
true;
519 if (
auto *ND = Corrected.getFoundDecl())
522 if (
Found.isAmbiguous()) {
524 }
else if (!
Found.empty()) {
525 Found.setLookupName(Corrected.getCorrection());
527 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
528 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
529 Name.getAsString() == CorrectedStr;
531 << Name << LookupCtx << DroppedSpecifier
541 Found.empty() ? nullptr :
Found.getRepresentativeDecl();
545 Found.setNotFoundInCurrentInstantiation();
551 if (ExampleLookupResult && RequiredTemplate) {
552 Diag(
Found.getNameLoc(), diag::err_template_kw_refers_to_non_template)
557 diag::note_template_kw_refers_to_non_template)
558 <<
Found.getLookupName();
565 if (S && !ObjectType.
isNull() && !ObjectTypeSearchedInScope &&
582 if (FoundOuter.
empty()) {
592 }
else if (!
Found.isSuppressingAmbiguousDiagnostics()) {
596 if (!
Found.isSingleResult() ||
600 diag::ext_nested_name_member_ref_lookup_ambiguous)
601 <<
Found.getLookupName()
603 Diag(
Found.getRepresentativeDecl()->getLocation(),
604 diag::note_ambig_member_ref_object_type)
607 diag::note_ambig_member_ref_scope);
630 bool MissingTemplateKeyword =
false;
633 if (
auto *DRE = dyn_cast<DeclRefExpr>(
TemplateName.get())) {
634 NameInfo = DRE->getNameInfo();
635 SS.
Adopt(DRE->getQualifierLoc());
637 Found = DRE->getFoundDecl();
638 }
else if (
auto *ME = dyn_cast<MemberExpr>(
TemplateName.get())) {
639 NameInfo = ME->getMemberNameInfo();
640 SS.
Adopt(ME->getQualifierLoc());
642 LookupCtx = ME->getBase()->getType()->getAsCXXRecordDecl();
643 Found = ME->getMemberDecl();
644 }
else if (
auto *DSDRE =
645 dyn_cast<DependentScopeDeclRefExpr>(
TemplateName.get())) {
646 NameInfo = DSDRE->getNameInfo();
647 SS.
Adopt(DSDRE->getQualifierLoc());
648 MissingTemplateKeyword =
true;
649 }
else if (
auto *DSME =
650 dyn_cast<CXXDependentScopeMemberExpr>(
TemplateName.get())) {
651 NameInfo = DSME->getMemberNameInfo();
652 SS.
Adopt(DSME->getQualifierLoc());
653 MissingTemplateKeyword =
true;
655 llvm_unreachable(
"unexpected kind of potential template name");
660 if (MissingTemplateKeyword) {
669 TemplateCandidateFilter(
Sema &S) : S(S) {
670 WantTypeSpecifiers =
false;
671 WantExpressionKeywords =
false;
672 WantRemainingKeywords =
false;
673 WantCXXNamedCasts =
true;
675 bool ValidateCandidate(
const TypoCorrection &Candidate)
override {
681 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
682 return std::make_unique<TemplateCandidateFilter>(*
this);
687 TemplateCandidateFilter CCC(*
this);
690 auto *ND = Corrected.getFoundDecl();
693 if (ND || Corrected.isKeyword()) {
695 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
696 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
697 Name.getAsString() == CorrectedStr;
699 PDiag(diag::err_non_template_in_member_template_id_suggest)
700 << Name << LookupCtx << DroppedSpecifier
704 PDiag(diag::err_non_template_in_template_id_suggest)
709 diag::note_non_template_in_template_id_found);
714 Diag(NameInfo.
getLoc(), diag::err_non_template_in_template_id)
717 Diag(
Found->getLocation(), diag::note_non_template_in_template_id_found);
724 bool isAddressOfOperand,
740 nullptr, NameInfo, TemplateArgs);
763 bool InstantiatedFromMember,
768 assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||
769 isa<VarDecl>(Instantiation));
771 bool IsEntityBeingDefined =
false;
772 if (
const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
773 IsEntityBeingDefined = TD->isBeingDefined();
775 if (PatternDef && !IsEntityBeingDefined) {
790 if (!Complain || (PatternDef && PatternDef->
isInvalidDecl()))
794 if (
TagDecl *TD = dyn_cast<TagDecl>(Instantiation))
797 Diag(PointOfInstantiation,
798 diag::err_template_instantiate_within_definition)
804 }
else if (InstantiatedFromMember) {
805 if (isa<FunctionDecl>(Instantiation)) {
806 Diag(PointOfInstantiation,
807 diag::err_explicit_instantiation_undefined_member)
812 assert(isa<TagDecl>(Instantiation) &&
"Must be a TagDecl!");
813 Diag(PointOfInstantiation,
814 diag::err_implicit_instantiate_member_undefined)
819 if (isa<FunctionDecl>(Instantiation)) {
820 Diag(PointOfInstantiation,
821 diag::err_explicit_instantiation_undefined_func_template)
824 }
else if (isa<TagDecl>(Instantiation)) {
825 Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
830 assert(isa<VarDecl>(Instantiation) &&
"Must be a VarDecl!");
831 if (isa<VarTemplateSpecializationDecl>(Instantiation)) {
832 Diag(PointOfInstantiation,
833 diag::err_explicit_instantiation_undefined_var_template)
837 Diag(PointOfInstantiation,
838 diag::err_explicit_instantiation_undefined_member)
855 bool SupportedForCompatibility) {
868 ? diag::ext_template_param_shadow
869 : (SupportedForCompatibility ? diag::ext_compat_template_param_shadow
870 : diag::err_template_param_shadow);
871 const auto *ND = cast<NamedDecl>(PrevDecl);
872 Diag(
Loc, DiagId) << ND->getDeclName();
877 if (
TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(
D)) {
878 D = Temp->getTemplatedDecl();
887 "Only template template arguments can be pack expansions here");
888 assert(
getAsTemplate().get().containsUnexpandedParameterPack() &&
889 "Template template argument pack expansion without packs");
891 Result.EllipsisLoc = EllipsisLoc;
926 llvm_unreachable(
"Unhandled parsed template argument");
931 for (
unsigned I = 0,
Last = TemplateArgsIn.size(); I !=
Last; ++I)
941 RedeclarationKind::ForVisibleRedeclaration);
951 assert(TInfo &&
"template argument with no location");
959 EllipsisLoc = PET.getEllipsisLoc();
960 TL = PET.getPatternLoc();
965 SS.
Adopt(ET.getQualifierLoc());
966 TL = ET.getNamedTypeLoc();
970 TemplateName Name = DTST.getTypePtr()->getTemplateName();
972 DTST.getTemplateNameLoc());
993 unsigned Depth,
unsigned Position,
996 bool HasTypeConstraint) {
997 assert(S->isTemplateParamScope() &&
998 "Template type parameter not in template parameter scope!");
1000 bool IsParameterPack = EllipsisLoc.
isValid();
1003 KeyLoc, ParamNameLoc, Depth, Position,
1004 ParamName,
Typename, IsParameterPack,
1010 CSI->LocalPacks.push_back(Param);
1023 if (DefaultArg && IsParameterPack) {
1024 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1025 DefaultArg =
nullptr;
1033 assert(DefaultTInfo &&
"expected source information for type");
1061 return TemplateArgs;
1074 diag::err_type_constraint_non_type_concept);
1083 if (!WereArgsSpecified &&
1086 diag::err_type_constraint_missing_arguments)
1105 bool AllowUnexpandedPack) {
1122 if (EllipsisLoc.
isInvalid() && !AllowUnexpandedPack) {
1131 ConceptName, CD, USD ? cast<NamedDecl>(USD) : CD,
1137template <
typename ArgumentLocAppender>
1152 Appender(ConstraintArgs);
1161 FoundDecl ? FoundDecl : NamedConcept, NamedConcept,
1164 return ImmediatelyDeclaredConstraint;
1180 ImmediatelyDeclaredConstraint.
get(), BO_LAnd,
1181 EllipsisLoc,
nullptr,
1198 *TemplateArgs) :
nullptr;
1200 QualType ParamAsArgument = ConstrainedType;
1203 *
this,
NS, NameInfo, NamedConcept, FoundDecl,
1206 ParamAsArgument, ConstrainedParameter->
getLocation(),
1209 for (const auto &ArgLoc : TemplateArgs->arguments())
1210 ConstraintArgs.addArgument(ArgLoc);
1213 if (ImmediatelyDeclaredConstraint.
isInvalid())
1223 ImmediatelyDeclaredConstraint.
get());
1234 diag::err_unsupported_placeholder_constraint)
1253 for (unsigned I = 0, C = TL.getNumArgs(); I != C; ++I)
1254 ConstraintArgs.addArgument(TL.getArgLoc(I));
1257 if (ImmediatelyDeclaredConstraint.
isInvalid() ||
1258 !ImmediatelyDeclaredConstraint.
isUsable())
1262 ImmediatelyDeclaredConstraint.
get());
1292 Diag(
Loc, diag::err_template_nontype_parm_rvalue_ref) <<
T;
1302 Diag(
Loc, diag::err_template_nontype_parm_bad_type) <<
T;
1310 Diag(
Loc, diag::err_template_nontype_parm_not_structural) <<
T;
1317 for (
const FieldDecl *FD : RD->fields()) {
1319 Diag(FD->getLocation(), diag::note_not_structural_non_public) <<
T << 0;
1322 if (FD->isMutable()) {
1323 Diag(FD->getLocation(), diag::note_not_structural_mutable_field) <<
T;
1326 if (FD->getType()->isRValueReferenceType()) {
1327 Diag(FD->getLocation(), diag::note_not_structural_rvalue_ref_field)
1334 for (
const auto &BaseSpec : RD->bases()) {
1335 if (BaseSpec.getAccessSpecifier() !=
AS_public) {
1336 Diag(BaseSpec.getBaseTypeLoc(), diag::note_not_structural_non_public)
1347 for (
const FieldDecl *FD : RD->fields()) {
1350 SubLoc = FD->getLocation();
1358 for (
const auto &BaseSpec : RD->bases()) {
1361 SubLoc = BaseSpec.getBaseTypeLoc();
1369 assert(Kind != -1 &&
"couldn't find reason why type is not structural");
1370 Diag(SubLoc, diag::note_not_structural_subobject)
1371 <<
T << Kind << SubType;
1384 Diag(
Loc, diag::err_variably_modified_nontype_template_param)
1408 return T.getUnqualifiedType();
1426 return T.getUnqualifiedType();
1437 Diag(
Loc, diag::err_template_nontype_parm_bad_structural_type) <<
T;
1441 Diag(
Loc, diag::warn_cxx17_compat_template_nontype_parm_type) <<
T;
1442 return T.getUnqualifiedType();
1453 auto CheckValidDeclSpecifiers = [
this, &
D] {
1467 Diag(
Loc, diag::err_invalid_decl_specifier_in_nontype_parm)
1504 CheckValidDeclSpecifiers();
1507 if (isa<AutoType>(
T))
1508 Diag(
D.getIdentifierLoc(),
1509 diag::warn_cxx14_compat_template_nontype_parm_auto_type)
1512 assert(S->isTemplateParamScope() &&
1513 "Non-type template parameter not in template parameter scope!");
1525 bool IsParameterPack =
D.hasEllipsis();
1528 D.getIdentifierLoc(), Depth, Position, ParamName,
T, IsParameterPack,
1533 if (TL.isConstrained()) {
1534 if (
D.getEllipsisLoc().isInvalid() &&
1536 assert(TL.getConceptReference()->getTemplateArgsAsWritten());
1538 TL.getConceptReference()->getTemplateArgsAsWritten()->arguments())
1552 CSI->LocalPacks.push_back(Param);
1566 if (
Default && IsParameterPack) {
1567 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1590 assert(S->isTemplateParamScope() &&
1591 "Template template parameter not in template parameter scope!");
1594 bool IsParameterPack = EllipsisLoc.
isValid();
1597 NameLoc.
isInvalid() ? TmpLoc : NameLoc, Depth, Position, IsParameterPack,
1603 LSI->LocalPacks.push_back(Param);
1614 if (Params->
size() == 0) {
1623 if (IsParameterPack && !
Default.isInvalid()) {
1624 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1639 Diag(DefaultArg.
getLocation(), diag::err_template_arg_not_valid_template)
1657class ConstraintRefersToContainingTemplateChecker
1658 :
public TreeTransform<ConstraintRefersToContainingTemplateChecker> {
1659 bool Result =
false;
1661 unsigned TemplateDepth = 0;
1665 void CheckIfContainingRecord(
const CXXRecordDecl *CheckingRD) {
1671 DC && !DC->isFileContext(); DC = DC->getParent())
1672 if (
const auto *RD = dyn_cast<CXXRecordDecl>(DC))
1673 if (CheckingRD == RD->getMostRecentDecl())
1678 if (
D->getDepth() < TemplateDepth)
1683 TransformType(
D->getType());
1689 ConstraintRefersToContainingTemplateChecker(
Sema &SemaRef,
1691 unsigned TemplateDepth)
1692 : inherited(SemaRef),
Friend(
Friend), TemplateDepth(TemplateDepth) {}
1693 bool getResult()
const {
return Result; }
1699 using inherited::TransformTemplateTypeParmType;
1704 return inherited::TransformTemplateTypeParmType(
1716 if (
auto *TD = dyn_cast<TypedefNameDecl>(
D))
1717 TransformType(TD->getUnderlyingType());
1718 else if (
auto *NTTPD = dyn_cast<NonTypeTemplateParmDecl>(
D))
1719 CheckNonTypeTemplateParmDecl(NTTPD);
1720 else if (
auto *VD = dyn_cast<ValueDecl>(
D))
1721 TransformType(VD->getType());
1722 else if (
auto *TD = dyn_cast<TemplateDecl>(
D))
1723 TransformTemplateParameterList(TD->getTemplateParameters());
1724 else if (
auto *RD = dyn_cast<CXXRecordDecl>(
D))
1725 CheckIfContainingRecord(RD);
1726 else if (isa<NamedDecl>(
D)) {
1729 llvm_unreachable(
"Don't know how to handle this declaration type yet");
1737 const Expr *Constraint) {
1738 assert(
Friend->getFriendObjectKind() &&
"Only works on a friend");
1739 ConstraintRefersToContainingTemplateChecker Checker(*
this,
Friend,
1741 Checker.TransformExpr(
const_cast<Expr *
>(Constraint));
1742 return Checker.getResult();
1752 Expr *RequiresClause) {
1754 Diag(ExportLoc, diag::warn_template_export_unsupported);
1760 Context, TemplateLoc, LAngleLoc,
1761 llvm::ArrayRef(Params.data(), Params.size()), RAngleLoc, RequiresClause);
1796 return cast<TemplateDecl>(
D)->getTemplateParameters();
1806 assert(TemplateParams && TemplateParams->
size() > 0 &&
1807 "No template parameters");
1809 "Can only declare or define class templates");
1818 "can't build template of enumerated type");
1822 Diag(KWLoc, diag::err_template_unnamed_class);
1837 if (!SemanticContext) {
1842 ? diag::warn_template_qualified_friend_ignored
1843 : diag::err_template_qualified_declarator_no_match)
1902 if (S->isTemplateParamScope())
1907 PrevDecl = (*
Previous.begin())->getUnderlyingDecl();
1919 dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
1924 if (!PrevClassTemplate && isa_and_nonnull<CXXRecordDecl>(PrevDecl) &&
1925 cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
1928 = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
1929 if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
1931 = cast<ClassTemplateSpecializationDecl>(PrevDecl)
1932 ->getSpecializedTemplate();
1955 PrevDecl = PrevClassTemplate =
nullptr;
1956 SemanticContext = OutermostContext;
1970 PrevDecl = (*
Previous.begin())->getUnderlyingDecl();
1974 SemanticContext, S, SS.
isValid()))
1975 PrevDecl = PrevClassTemplate =
nullptr;
1977 if (
auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
1978 PrevDecl ?
Previous.getRepresentativeDecl() :
nullptr)) {
1980 !(PrevClassTemplate &&
1983 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
1984 Diag(Shadow->getTargetDecl()->getLocation(),
1985 diag::note_using_decl_target);
1986 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl) << 0;
1988 PrevDecl = PrevClassTemplate =
nullptr;
1992 if (PrevClassTemplate) {
2001 TemplateParams, PrevClassTemplate,
2014 Diag(KWLoc, diag::err_use_with_wrong_tag)
2030 auto *Tmpl = cast<CXXRecordDecl>(Hidden)->getDescribedClassTemplate();
2031 assert(Tmpl &&
"original definition of a class template is not a "
2036 Diag(NameLoc, diag::err_redefinition) << Name;
2037 Diag(Def->getLocation(), diag::note_previous_definition);
2044 }
else if (PrevDecl) {
2050 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
2064 (SS.
isSet() && SemanticContext && SemanticContext->
isRecord() &&
2077 ? diag::err_friend_decl_does_not_match
2078 : diag::err_member_decl_does_not_match)
2079 << Name << SemanticContext <<
true << SS.
getRange();
2089 bool ShouldAddRedecl =
2094 PrevClassTemplate && ShouldAddRedecl ?
2098 if (NumOuterTemplateParamLists > 0)
2101 llvm::ArrayRef(OuterTemplateParamLists, NumOuterTemplateParamLists));
2115 if (ShouldAddRedecl)
2120 if (ModulePrivateLoc.
isValid())
2131 if (PrevClassTemplate &&
2149 if (PrevClassTemplate)
2185 if (PrevClassTemplate)
2226 diag::warn_cxx98_compat_template_parameter_default_in_function_template
2227 : diag::ext_template_parameter_default_in_function_template)
2236 S.
Diag(ParamLoc, diag::err_template_parameter_default_template_member)
2245 S.
Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
2254 llvm_unreachable(
"Invalid TemplateParamListContext!");
2267 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
2272 if (TC->hasExplicitTemplateArgs())
2273 for (
auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
2281 if (!NTTP->isParameterPack() &&
2283 NTTP->getTypeSourceInfo(),
2291 = dyn_cast<TemplateTemplateParmDecl>(
P))
2311 bool SawDefaultArgument =
false;
2317 OldParam = OldParams->
begin();
2319 bool RemoveDefaultArguments =
false;
2321 NewParamEnd = NewParams->
end();
2322 NewParam != NewParamEnd; ++NewParam) {
2325 bool RedundantDefaultArg =
false;
2328 bool InconsistentDefaultArg =
false;
2330 std::string PrevModuleName;
2336 bool MissingDefaultArg =
false;
2339 bool SawParameterPack =
false;
2342 = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
2344 if (NewTypeParm->hasDefaultArgument() &&
2346 *
this, TPC, NewTypeParm->getLocation(),
2347 NewTypeParm->getDefaultArgument().getSourceRange()))
2348 NewTypeParm->removeDefaultArgument();
2352 = OldParams? cast<TemplateTypeParmDecl>(*OldParam) :
nullptr;
2353 if (NewTypeParm->isParameterPack()) {
2354 assert(!NewTypeParm->hasDefaultArgument() &&
2355 "Parameter packs can't have a default argument!");
2356 SawParameterPack =
true;
2358 NewTypeParm->hasDefaultArgument() &&
2361 NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
2362 SawDefaultArgument =
true;
2365 RedundantDefaultArg =
true;
2366 else if (!
getASTContext().isSameDefaultTemplateArgument(OldTypeParm,
2368 InconsistentDefaultArg =
true;
2372 PreviousDefaultArgLoc = NewDefaultLoc;
2376 NewTypeParm->setInheritedDefaultArgument(
Context, OldTypeParm);
2378 }
else if (NewTypeParm->hasDefaultArgument()) {
2379 SawDefaultArgument =
true;
2380 PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
2381 }
else if (SawDefaultArgument)
2382 MissingDefaultArg =
true;
2384 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
2386 if (!NewNonTypeParm->isParameterPack() &&
2388 NewNonTypeParm->getTypeSourceInfo(),
2395 if (NewNonTypeParm->hasDefaultArgument() &&
2397 *
this, TPC, NewNonTypeParm->getLocation(),
2398 NewNonTypeParm->getDefaultArgument().getSourceRange())) {
2399 NewNonTypeParm->removeDefaultArgument();
2404 = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) :
nullptr;
2405 if (NewNonTypeParm->isParameterPack()) {
2406 assert(!NewNonTypeParm->hasDefaultArgument() &&
2407 "Parameter packs can't have a default argument!");
2408 if (!NewNonTypeParm->isPackExpansion())
2409 SawParameterPack =
true;
2411 NewNonTypeParm->hasDefaultArgument() &&
2414 NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
2415 SawDefaultArgument =
true;
2417 RedundantDefaultArg =
true;
2419 OldNonTypeParm, NewNonTypeParm)) {
2420 InconsistentDefaultArg =
true;
2424 PreviousDefaultArgLoc = NewDefaultLoc;
2428 NewNonTypeParm->setInheritedDefaultArgument(
Context, OldNonTypeParm);
2430 }
else if (NewNonTypeParm->hasDefaultArgument()) {
2431 SawDefaultArgument =
true;
2432 PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
2433 }
else if (SawDefaultArgument)
2434 MissingDefaultArg =
true;
2437 = cast<TemplateTemplateParmDecl>(*NewParam);
2454 = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) :
nullptr;
2457 "Parameter packs can't have a default argument!");
2459 SawParameterPack =
true;
2460 }
else if (OldTemplateParm &&
2466 SawDefaultArgument =
true;
2468 RedundantDefaultArg =
true;
2470 OldTemplateParm, NewTemplateParm)) {
2471 InconsistentDefaultArg =
true;
2475 PreviousDefaultArgLoc = NewDefaultLoc;
2480 PreviousDefaultArgLoc
2483 SawDefaultArgument =
true;
2484 PreviousDefaultArgLoc
2486 }
else if (SawDefaultArgument)
2487 MissingDefaultArg =
true;
2493 if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
2496 Diag((*NewParam)->getLocation(),
2497 diag::err_template_param_pack_must_be_last_template_parameter);
2514 if (RedundantDefaultArg) {
2515 Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
2516 Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
2518 }
else if (InconsistentDefaultArg) {
2522 diag::err_template_param_default_arg_inconsistent_redefinition);
2524 diag::note_template_param_prev_default_arg_in_other_module)
2527 }
else if (MissingDefaultArg &&
2535 Diag((*NewParam)->getLocation(),
2536 diag::err_template_param_default_arg_missing);
2537 Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
2539 RemoveDefaultArguments =
true;
2550 if (RemoveDefaultArguments) {
2552 NewParamEnd = NewParams->
end();
2553 NewParam != NewParamEnd; ++NewParam) {
2555 TTP->removeDefaultArgument();
2557 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
2558 NTTP->removeDefaultArgument();
2560 cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
2578 bool IgnoreNonTypeDependent;
2583 DependencyChecker(
unsigned Depth,
bool IgnoreNonTypeDependent)
2584 : Depth(Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),
2588 : IgnoreNonTypeDependent(IgnoreNonTypeDependent), Match(
false) {
2591 Depth = PD->getDepth();
2593 dyn_cast<NonTypeTemplateParmDecl>(ND)) {
2594 Depth = PD->getDepth();
2596 Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
2601 if (ParmDepth >= Depth) {
2609 bool TraverseStmt(
Stmt *S)
override {
2614 if (
auto *
E = dyn_cast_or_null<Expr>(S))
2620 bool TraverseTypeLoc(
TypeLoc TL)
override {
2621 if (IgnoreNonTypeDependent && !TL.
isNull() &&
2633 return IgnoreNonTypeDependent || !Matches(
T->getDepth());
2639 if (Matches(PD->getDepth()))
2646 dyn_cast<NonTypeTemplateParmDecl>(
E->getDecl()))
2649 return DynamicRecursiveASTVisitor::VisitDeclRefExpr(
E);
2653 return TraverseType(
T->getReplacementType());
2656 bool VisitSubstTemplateTypeParmPackType(
2658 return TraverseTemplateArgument(
T->getArgumentPack());
2662 return TraverseType(
T->getInjectedSpecializationType());
2671 if (!Params->
size())
2674 DependencyChecker Checker(Params,
false);
2675 Checker.TraverseType(
T);
2676 return Checker.Match;
2686 if (
const Type *CurType = NNS->getAsType()) {
2702 bool &IsMemberSpecialization,
bool &
Invalid,
bool SuppressDiagnostic) {
2703 IsMemberSpecialization =
false;
2724 while (!
T.isNull()) {
2725 NestedTypes.push_back(
T);
2731 = dyn_cast<ClassTemplateSpecializationDecl>(
Record)) {
2732 if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
2734 ExplicitSpecLoc = Spec->getLocation();
2737 }
else if (
Record->getTemplateSpecializationKind()
2739 ExplicitSpecLoc =
Record->getLocation();
2752 if (
TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
2753 if (
TypeDecl *
Parent = dyn_cast<TypeDecl>(Template->getDeclContext()))
2798 std::reverse(NestedTypes.begin(), NestedTypes.end());
2806 bool SawNonEmptyTemplateParameterList =
false;
2809 if (SawNonEmptyTemplateParameterList) {
2810 if (!SuppressDiagnostic)
2811 Diag(DeclLoc, diag::err_specialize_member_of_template)
2812 << !Recovery <<
Range;
2814 IsMemberSpecialization =
false;
2823 if (CheckExplicitSpecialization(
Range,
true))
2828 if (!ParamLists.empty())
2829 ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
2831 ExpectedTemplateLoc = DeclStartLoc;
2833 if (!SuppressDiagnostic)
2834 Diag(DeclLoc, diag::err_template_spec_needs_header)
2841 for (
unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
2843 T = NestedTypes[TypeIdx];
2846 bool NeedEmptyTemplateHeader =
false;
2849 bool NeedNonemptyTemplateHeader =
false;
2862 = dyn_cast<ClassTemplatePartialSpecializationDecl>(
Record)) {
2863 ExpectedTemplateParams = Partial->getTemplateParameters();
2864 NeedNonemptyTemplateHeader =
true;
2865 }
else if (
Record->isDependentType()) {
2866 if (
Record->getDescribedClassTemplate()) {
2867 ExpectedTemplateParams =
Record->getDescribedClassTemplate()
2868 ->getTemplateParameters();
2869 NeedNonemptyTemplateHeader =
true;
2872 = dyn_cast<ClassTemplateSpecializationDecl>(
Record)) {
2878 NeedEmptyTemplateHeader =
true;
2881 }
else if (
Record->getTemplateSpecializationKind()) {
2882 if (
Record->getTemplateSpecializationKind()
2884 TypeIdx == NumTypes - 1)
2885 IsMemberSpecialization =
true;
2891 if (
TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
2892 ExpectedTemplateParams = Template->getTemplateParameters();
2893 NeedNonemptyTemplateHeader =
true;
2898 NeedNonemptyTemplateHeader =
false;
2908 if (
ParamIdx < ParamLists.size()) {
2909 if (ParamLists[
ParamIdx]->size() == 0) {
2910 if (CheckExplicitSpecialization(ParamLists[
ParamIdx]->getSourceRange(),
2914 SawNonEmptyTemplateParameterList =
true;
2917 if (NeedEmptyTemplateHeader) {
2920 if (TypeIdx == NumTypes - 1)
2921 IsMemberSpecialization =
true;
2923 if (
ParamIdx < ParamLists.size()) {
2924 if (ParamLists[
ParamIdx]->size() > 0) {
2926 if (!SuppressDiagnostic)
2928 diag::err_template_param_list_matches_nontemplate)
2931 ParamLists[
ParamIdx]->getRAngleLoc())
2943 if (DiagnoseMissingExplicitSpecialization(
2950 if (NeedNonemptyTemplateHeader) {
2956 if (
ParamIdx < ParamLists.size() &&
2958 ExpectedTemplateParams =
nullptr;
2963 if (
ParamIdx < ParamLists.size()) {
2965 if (ExpectedTemplateParams &&
2967 ExpectedTemplateParams,
2980 if (!SuppressDiagnostic)
2981 Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
2992 if (
ParamIdx >= ParamLists.size()) {
2993 if (TemplateId && !IsFriend) {
3009 if (
ParamIdx < ParamLists.size() - 1) {
3010 bool HasAnyExplicitSpecHeader =
false;
3011 bool AllExplicitSpecHeaders =
true;
3012 for (
unsigned I =
ParamIdx,
E = ParamLists.size() - 1; I !=
E; ++I) {
3013 if (ParamLists[I]->size() == 0)
3014 HasAnyExplicitSpecHeader =
true;
3016 AllExplicitSpecHeaders =
false;
3019 if (!SuppressDiagnostic)
3021 AllExplicitSpecHeaders ? diag::ext_template_spec_extra_headers
3022 : diag::err_template_spec_extra_headers)
3024 ParamLists[ParamLists.size() - 2]->getRAngleLoc());
3029 if (ExplicitSpecLoc.
isValid() && HasAnyExplicitSpecHeader &&
3030 !SuppressDiagnostic)
3031 Diag(ExplicitSpecLoc,
3032 diag::note_explicit_template_spec_does_not_need_header)
3033 << NestedTypes.back();
3038 if (!AllExplicitSpecHeaders)
3049 if (ParamLists.back()->size() == 0 &&
3050 CheckExplicitSpecialization(ParamLists[
ParamIdx]->getSourceRange(),
3056 return ParamLists.back();
3060 if (
TemplateDecl *Template = Name.getAsTemplateDecl()) {
3061 Diag(Template->getLocation(), diag::note_template_declared_here)
3062 << (isa<FunctionTemplateDecl>(Template)
3064 : isa<ClassTemplateDecl>(Template)
3066 : isa<VarTemplateDecl>(Template)
3068 : isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)
3069 << Template->getDeclName();
3077 Diag((*I)->getLocation(), diag::note_template_declared_here)
3078 << 0 << (*I)->getDeclName();
3111 return BaseTemplateInst;
3116 switch (Ts.size()) {
3126 return lookUpCommonType(Ts[0], Ts[0]);
3140 return lookUpCommonType(D1, D2);
3145 auto CheckConditionalOperands = [&](
bool ConstRefQual) ->
QualType {
3184 if (
auto Res = CheckConditionalOperands(
false); !Res.isNull())
3197 return CheckConditionalOperands(
true);
3208 for (
auto T : llvm::drop_begin(Ts)) {
3230 QualType OrigType = Converted[1].getAsType();
3234 SemaRef.
Diag(TemplateArgs[1].getLocation(),
3235 diag::err_integer_sequence_integral_element_type);
3250 OrigType, TemplateArgs[1].getLocation())));
3252 if (llvm::APSInt NumArgs = NumArgsArg.
getAsIntegral(); NumArgs >= 0) {
3254 for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
3258 TA, OrigType, TemplateArgs[2].getLocation()));
3263 SemaRef.
Diag(TemplateArgs[2].getLocation(),
3264 diag::err_integer_sequence_negative_length);
3271 TemplateLoc, SyntheticTemplateArgs);
3278 assert(Converted.size() == 2 &&
3279 "__type_pack_element should be given an index and a parameter pack");
3287 assert(Index >= 0 &&
"the index used with __type_pack_element should be of "
3288 "type std::size_t, and hence be non-negative");
3290 if (Index >= Ts.pack_size()) {
3291 SemaRef.
Diag(TemplateArgs[0].getLocation(),
3292 diag::err_type_pack_element_out_of_bounds);
3297 int64_t N = Index.getExtValue();
3298 return Ts.getPackAsArray()[N].getAsType();
3302 assert(Converted.size() == 4);
3303 if (llvm::any_of(Converted, [](
auto &
C) {
return C.isDependent(); }))
3307 TemplateName BaseTemplate = Converted[0].getAsTemplate();
3308 TemplateName HasTypeMember = Converted[1].getAsTemplate();
3309 QualType HasNoTypeMember = Converted[2].getAsType();
3316 CT, TemplateArgs[1].getLocation())));
3320 return HasNoTypeMember;
3323 llvm_unreachable(
"unexpected BuiltinTemplateDecl!");
3342 if (BinOp->getOpcode() == BO_LAnd) {
3349 Terms.push_back(Clause);
3358 if (!BinOp)
return Cond;
3360 if (BinOp->getOpcode() != BO_LOr)
return Cond;
3363 Expr *LHS = BinOp->getLHS();
3365 if (!InnerBinOp)
return Cond;
3367 if (InnerBinOp->getOpcode() != BO_EQ ||
3368 !isa<IntegerLiteral>(InnerBinOp->getRHS()))
3378 if (MacroName ==
"CONCEPT_REQUIRES" || MacroName ==
"CONCEPT_REQUIRES_")
3379 return BinOp->getRHS();
3389class FailedBooleanConditionPrinterHelper :
public PrinterHelper {
3394 bool handledStmt(
Stmt *
E, raw_ostream &OS)
override {
3395 const auto *DR = dyn_cast<DeclRefExpr>(
E);
3396 if (DR && DR->getQualifier()) {
3399 DR->getQualifier()->print(OS, Policy,
true);
3403 if (
const auto *IV = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
3406 OS, IV->getTemplateArgs().asArray(), Policy,
3407 IV->getSpecializedTemplate()->getTemplateParameters());
3420std::pair<Expr *, std::string>
3429 Expr *FailedCond =
nullptr;
3430 for (
Expr *Term : Terms) {
3434 if (isa<CXXBoolLiteralExpr>(TermAsWritten) ||
3435 isa<IntegerLiteral>(TermAsWritten))
3444 if (Term->EvaluateAsBooleanCondition(Succeeded,
Context) &&
3446 FailedCond = TermAsWritten;
3453 std::string Description;
3455 llvm::raw_string_ostream Out(Description);
3458 FailedBooleanConditionPrinterHelper Helper(Policy);
3459 FailedCond->
printPretty(Out, &Helper, Policy, 0,
"\n",
nullptr);
3461 return { FailedCond, Description };
3468 Name.getUnderlying().getAsDependentTemplateName();
3478 if (Name.getAsAssumedTemplateName() &&
3482 auto [Template, DefaultArgs] = Name.getTemplateDeclAndDefaultArgs();
3484 if (!Template || isa<FunctionTemplateDecl>(Template) ||
3485 isa<VarTemplateDecl>(Template) || isa<ConceptDecl>(Template)) {
3488 if (Name.getAsSubstTemplateTemplateParmPack())
3492 Diag(TemplateLoc, diag::err_template_id_not_a_type)
3502 DefaultArgs,
false, SugaredConverted,
3510 dyn_cast<TypeAliasTemplateDecl>(Template)) {
3525 Template, SugaredConverted,
3526 !
getLangOpts().RetainSubstTemplateTypeParmTypeAstNodes);
3542 std::optional<ContextRAII> SavedContext;
3544 SavedContext.emplace(*
this,
AliasTemplate->getDeclContext());
3549 if (CanonType.
isNull()) {
3555 if (*DeductionInfo &&
3556 (*DeductionInfo)->hasSFINAEDiagnostic() &&
3557 (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==
3558 diag::err_typename_nested_not_found_enable_if &&
3559 TemplateArgs[0].getArgument().getKind()
3562 std::string FailedDescription;
3563 std::tie(FailedCond, FailedDescription) =
3569 (*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);
3573 (*DeductionInfo)->addSFINAEDiagnostic(
3575 PDiag(diag::err_typename_nested_not_found_requirement)
3576 << FailedDescription
3584 }
else if (
auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
3586 TemplateLoc, TemplateArgs);
3587 }
else if (Name.isDependent() ||
3589 TemplateArgs, CanonicalConverted)) {
3598 Name, CanonicalConverted);
3606 if (isa<ClassTemplateDecl>(Template)) {
3609 if (Ctx->isFileContext())
break;
3617 if (!isa<ClassTemplatePartialSpecializationDecl>(
Record) &&
3618 !
Record->getDescribedClassTemplate())
3624 QualType Injected = cast<InjectedClassNameType>(ICNT)
3625 ->getInjectedSpecializationType();
3638 dyn_cast<ClassTemplateDecl>(Template)) {
3641 void *InsertPos =
nullptr;
3643 ClassTemplate->findSpecialization(CanonicalConverted, InsertPos);
3675 assert(isa<RecordType>(CanonType) &&
3676 "type of non-dependent specialization is not a RecordType");
3678 llvm_unreachable(
"Unhandled template kind");
3695 auto *ATN = Name.getAsAssumedTemplateName();
3696 assert(ATN &&
"not an assumed template name");
3697 II = ATN->getDeclName().getAsIdentifierInfo();
3713 assert(ATN &&
"not an assumed template name");
3721 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
3722 return std::make_unique<CandidateCallback>(*
this);
3748 bool IsCtorOrDtorName,
bool IsClassName,
3753 if (!IsCtorOrDtorName && !IsClassName && SS.
isSet()) {
3779 TemplateD, TemplateII, TemplateIILoc, LAngleLoc,
3780 TemplateArgsIn, RAngleLoc);
3787 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
3788 if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
3791 ? diag::err_out_of_line_qualified_id_type_names_constructor
3792 : diag::ext_out_of_line_qualified_id_type_names_constructor)
3822 for (
unsigned I = 0, N = SpecTL.
getNumArgs(); I != N; ++I)
3839 for (
unsigned i = 0, e = SpecTL.
getNumArgs(); i != e; ++i)
3880 Keyword, DTN->getQualifier(), DTN->getIdentifier(),
3893 for (
unsigned I = 0, N = SpecTL.
getNumArgs(); I != N; ++I)
3904 Diag(TemplateLoc, diag::err_tag_reference_non_tag)
3906 Diag(TAT->getLocation(), diag::note_declared_at);
3918 assert(
Id &&
"templated class must have an identifier");
3922 Diag(TagLoc, diag::err_use_with_wrong_tag)
3937 for (
unsigned i = 0, e = SpecTL.
getNumArgs(); i != e; ++i)
3972 return TPT && !
Type.hasQualifiers() &&
3981 dyn_cast<NonTypeTemplateParmDecl>(DRE->
getDecl());
3987 dyn_cast_or_null<TemplateTemplateParmDecl>(
3991 llvm_unreachable(
"unexpected kind of template argument");
3996 if (Params->
size() != Args.size())
3999 unsigned Depth = Params->
getDepth();
4001 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
4020template<
typename PartialSpecDecl>
4022 if (Partial->getDeclContext()->isDependentContext())
4031 auto *Template = Partial->getSpecializedTemplate();
4032 S.
Diag(Partial->getLocation(),
4033 diag::ext_partial_spec_not_more_specialized_than_primary)
4034 << isa<VarTemplateDecl>(Template);
4043 diag::note_partial_spec_not_more_specialized_than_primary)
4049 Template->getAssociatedConstraints(TemplateAC);
4050 Partial->getAssociatedConstraints(PartialAC);
4057 const llvm::SmallBitVector &DeducibleParams) {
4058 for (
unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
4059 if (!DeducibleParams[I]) {
4072template<
typename PartialSpecDecl>
4074 PartialSpecDecl *Partial) {
4087 auto *TemplateParams = Partial->getTemplateParameters();
4088 llvm::SmallBitVector DeducibleParams(TemplateParams->size());
4090 TemplateParams->getDepth(), DeducibleParams);
4092 if (!DeducibleParams.all()) {
4093 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
4094 S.
Diag(Partial->getLocation(), diag::ext_partial_specs_not_deducible)
4095 << isa<VarTemplatePartialSpecializationDecl>(Partial)
4096 << (NumNonDeducible > 1)
4098 Partial->getTemplateArgsAsWritten()->RAngleLoc);
4119 llvm::SmallBitVector DeducibleParams(TemplateParams->size());
4121 for (
unsigned I = 0; I != TemplateParams->size(); ++I) {
4123 auto *Param = TemplateParams->getParam(I);
4125 DeducibleParams[I] =
true;
4128 if (!DeducibleParams.all()) {
4129 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
4130 Diag(TD->
getLocation(), diag::err_deduction_guide_template_not_deducible)
4131 << (NumNonDeducible > 1);
4142 "Variable template specialization is declared with a template id.");
4155 dyn_cast_or_null<VarTemplateDecl>(Name.getAsTemplateDecl());
4158 if (
auto *OTS = Name.getAsOverloadedTemplate())
4159 FnTemplate = *OTS->begin();
4161 FnTemplate = dyn_cast_or_null<FunctionTemplateDecl>(Name.getAsTemplateDecl());
4163 return Diag(
D.getIdentifierLoc(), diag::err_var_spec_no_template_but_method)
4165 return Diag(
D.getIdentifierLoc(), diag::err_var_spec_no_template)
4169 if (
const auto *DSA =
VarTemplate->getAttr<NoSpecializationsAttr>()) {
4170 auto Message = DSA->getMessage();
4171 Diag(TemplateNameLoc, diag::warn_invalid_specialization)
4173 Diag(DSA->getLoc(), diag::note_marked_here) << DSA;
4177 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
4188 {},
false, SugaredConverted,
4197 TemplateArgs.
size(),
4198 CanonicalConverted))
4203 if (!Name.isDependent() &&
4205 TemplateArgs, CanonicalConverted)) {
4206 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
4212 CanonicalConverted) &&
4219 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
4229 void *InsertPos =
nullptr;
4233 PrevDecl =
VarTemplate->findPartialSpecialization(
4234 CanonicalConverted, TemplateParams, InsertPos);
4236 PrevDecl =
VarTemplate->findSpecialization(CanonicalConverted, InsertPos);
4258 cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
4263 CanonicalConverted);
4267 VarTemplate->AddPartialSpecialization(Partial, InsertPos);
4306 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
4310 diag::note_instantiation_required_here)
4340struct PartialSpecMatchResult {
4350 assert(Template &&
"A variable template id without template?");
4355 Template, TemplateNameLoc,
4357 {},
false, SugaredConverted, CanonicalConverted,
4364 TemplateArgs, CanonicalConverted))
4369 void *InsertPos =
nullptr;
4383 bool AmbiguousPartialSpec =
false;
4409 !Partial->getMostRecentDecl()->isMemberSpecialization())
4424 Matched.push_back(PartialSpecMatchResult());
4425 Matched.back().Partial = Partial;
4430 if (Matched.size() >= 1) {
4432 if (Matched.size() == 1) {
4445 PEnd = Matched.end();
4448 PointOfInstantiation) ==
4456 PEnd = Matched.end();
4459 P->Partial, Best->Partial,
4460 PointOfInstantiation) != Best->Partial) {
4461 AmbiguousPartialSpec =
true;
4468 InstantiationPattern = Best->Partial;
4469 PartialSpecArgs = Best->Args;
4481 Template, InstantiationPattern, PartialSpecArgs, TemplateArgs,
4482 CanonicalConverted, TemplateNameLoc );
4486 if (AmbiguousPartialSpec) {
4489 Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
4494 Diag(
P.Partial->getLocation(), diag::note_partial_spec_match)
4501 dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
4502 Decl->setInstantiationOf(
D, PartialSpecArgs);
4506 assert(
Decl &&
"No variable template specialization?");
4517 if (
Decl.isInvalid())
4534 Diag(
Loc, diag::err_template_missing_args)
4542 bool TemplateKeyword,
4557 assert(NamedConcept &&
"A concept template id without a template?");
4564 NamedConcept, ConceptNameInfo.
getLoc(),
4567 false, SugaredConverted, CanonicalConverted,
4575 CanonicalConverted);
4577 bool AreArgsDependent =
4579 *TemplateArgs, CanonicalConverted);
4587 if (!AreArgsDependent &&
4597 TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,
4600 Context, CL, CSD, AreArgsDependent ?
nullptr : &Satisfaction);
4619 assert(!R.
isAmbiguous() &&
"ambiguous lookup when building templateid");
4623 if (!TemplateArgs && !isa<FunctionTemplateDecl>(TD)) {
4629 bool KnownDependent =
false;
4638 KnownDependent =
true;
4653 R.
begin(), R.
end(), KnownDependent,
4670 assert(TemplateArgs || TemplateKWLoc.
isValid());
4674 false, TemplateKWLoc))
4703 bool EnteringContext,
4705 bool AllowInjectedClassName) {
4706 if (TemplateKWLoc.
isValid() && S && !S->getTemplateParamParent())
4709 diag::warn_cxx98_compat_template_outside_of_template :
4710 diag::ext_template_outside_of_template)
4720 else if (ObjectType)
4739 bool MemberOfUnknownSpecialization;
4741 ObjectType, EnteringContext,
Result,
4742 MemberOfUnknownSpecialization);
4745 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
4746 if (!AllowInjectedClassName && SS.
isNotEmpty() && LookupRD &&
4748 Name.Identifier && LookupRD->getIdentifier() == Name.Identifier) {
4758 Diag(Name.getBeginLoc(),
4759 diag::ext_out_of_line_qualified_id_type_names_constructor)
4767 if (!MemberOfUnknownSpecialization) {
4784 Diag(Name.getBeginLoc(), diag::err_no_member)
4787 Diag(Name.getBeginLoc(), diag::err_undeclared_use)
4795 switch (Name.getKind()) {
4803 Qualifier, Name.OperatorFunctionId.Operator));
4817 Diag(Name.getBeginLoc(),
4818 diag::err_template_kw_refers_to_dependent_non_template)
4820 << TemplateKWLoc.
isValid() << TemplateKWLoc;
4857 dyn_cast<DependentScopeDeclRefExpr>(Arg.
getAsExpr())) {
4858 SS.
Adopt(ArgExpr->getQualifierLoc());
4859 NameInfo = ArgExpr->getNameInfo();
4861 dyn_cast<CXXDependentScopeMemberExpr>(Arg.
getAsExpr())) {
4862 if (ArgExpr->isImplicitAccess()) {
4863 SS.
Adopt(ArgExpr->getQualifierLoc());
4864 NameInfo = ArgExpr->getMemberNameInfo();
4873 Result.wasNotFoundInCurrentInstantiation()) {
4874 assert(SS.
getScopeRep() &&
"dependent scope expr must has a scope!");
4878 ? diag::ext_ms_template_type_arg_missing_typename
4879 : diag::err_template_arg_must_be_type_suggest)
4911 SugaredConverted.push_back(Arg);
4912 CanonicalConverted.push_back(Arg);
4918 Diag(SR.
getBegin(), diag::err_template_arg_must_be_type) << SR;
4940 CanonicalConverted.push_back(
4989 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
4992 bool ForLambdaCallOperator =
false;
4993 if (
const auto *Rec = dyn_cast<CXXRecordDecl>(Template->
getDeclContext()))
4994 ForLambdaCallOperator = Rec->isLambda();
4996 !ForLambdaCallOperator);
5044 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
5051 TemplateArgLists, Output);
5087 SugaredConverted,
SourceRange(TemplateLoc, RAngleLoc));
5094 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
5119 HasDefaultArg =
false;
5125 HasDefaultArg =
true;
5128 TypeParm, SugaredConverted,
5129 CanonicalConverted, Output))
5135 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
5139 HasDefaultArg =
true;
5142 NonTypeParm, SugaredConverted,
5143 CanonicalConverted, Output))
5149 = cast<TemplateTemplateParmDecl>(Param);
5153 HasDefaultArg =
true;
5156 *
this, Template, TemplateLoc, RAngleLoc, TempTempParm, SugaredConverted,
5157 CanonicalConverted, QualifierLoc);
5178 QualLoc = ETLoc.getQualifierLoc();
5179 TLoc = ETLoc.getNamedTypeLoc();
5185 QualLoc, InjLoc.getNameLoc());
5193 dyn_cast<ClassTemplateSpecializationDecl>(RecLoc.getDecl()))
5196 QualLoc, RecLoc.getNameLoc());
5204 unsigned ArgumentPackIndex,
5211 CanonicalConverted);
5218 QualType NTTPType = NTTP->getType();
5219 if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
5220 NTTPType = NTTP->getExpansionType(ArgumentPackIndex);
5223 !isa<TemplateTemplateParmDecl>(Template) &&
5238 NTTPType =
SubstType(PET->getPattern(), MLTAL, NTTP->getLocation(),
5239 NTTP->getDeclName());
5241 NTTPType =
SubstType(NTTPType, MLTAL, NTTP->getLocation(),
5242 NTTP->getDeclName());
5249 NTTP->getLocation());
5256 llvm_unreachable(
"Should never see a NULL template argument here");
5263 CanonicalResult, CTAK);
5272 if (Res.
get() !=
E) {
5277 SugaredConverted.push_back(SugaredResult);
5278 CanonicalConverted.push_back(CanonicalResult);
5289 CanonicalConverted.push_back(
5332 SugaredConverted.push_back(SugaredResult);
5333 CanonicalConverted.push_back(CanonicalResult);
5360 Diag(SR.
getBegin(), diag::err_template_arg_nontype_ambig) << SR <<
T;
5362 Diag(SR.
getBegin(), diag::err_template_arg_must_be_expr) << SR;
5368 llvm_unreachable(
"Caller must expand template argument packs");
5399 Template, SugaredConverted,
true),
5418 llvm_unreachable(
"Should never see a NULL template argument here");
5427 CanonicalConverted.push_back(
5443 llvm_unreachable(
"non-type argument with template template parameter");
5446 llvm_unreachable(
"Caller must expand template argument packs");
5453template<
typename TemplateParmDecl>
5456 const TemplateParmDecl *
D,
5461 ->getTemplateParameters()
5462 ->getParam(
D->getIndex()));
5469 D->getDefaultArgumentLoc(), Modules,
5480 S.
Diag(
Loc, diag::err_template_arg_list_different_arity)
5493 bool PartialTemplateArgs,
5497 bool PartialOrderingTTP) {
5516 bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
5519 unsigned ArgIdx = 0, NumArgs = NewArgs.
size();
5522 ParamEnd = Params->
end(),
5526 if (
size_t ParamIdx = Param - ParamBegin;
5529 assert(ArgIdx == NumArgs &&
"bad default argument deduction");
5532 assert(Param + DefaultArgs.
Args.size() <= ParamEnd);
5535 SugaredConverted.push_back(DefArg);
5536 CanonicalConverted.push_back(
5547 if (*Expansions == SugaredArgumentPack.size()) {
5550 SugaredConverted.push_back(
5552 SugaredArgumentPack.clear();
5554 CanonicalConverted.push_back(
5556 CanonicalArgumentPack.clear();
5561 }
else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
5563 Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5572 if (ArgIdx < NumArgs) {
5575 RAngleLoc, SugaredArgumentPack.size(),
5576 SugaredConverted, CanonicalConverted,
5580 CanonicalConverted.back().setIsDefaulted(
5583 CanonicalConverted, Params->
getDepth()));
5585 bool PackExpansionIntoNonPack =
5586 NewArgs[ArgIdx].getArgument().isPackExpansion() &&
5592 if (PackExpansionIntoNonPack && !PartialOrderingTTP &&
5593 (isa<TypeAliasTemplateDecl>(Template) ||
5594 isa<ConceptDecl>(Template))) {
5600 Diag(NewArgs[ArgIdx].getLocation(),
5601 diag::err_template_expansion_into_fixed_list)
5602 << (isa<ConceptDecl>(Template) ? 1 : 0)
5603 << NewArgs[ArgIdx].getSourceRange();
5611 if ((*Param)->isTemplateParameterPack()) {
5616 SugaredArgumentPack.push_back(SugaredConverted.pop_back_val());
5617 CanonicalArgumentPack.push_back(CanonicalConverted.pop_back_val());
5626 if (PackExpansionIntoNonPack) {
5627 if (!SugaredArgumentPack.empty()) {
5630 SugaredConverted.insert(SugaredConverted.end(),
5631 SugaredArgumentPack.begin(),
5632 SugaredArgumentPack.end());
5633 SugaredArgumentPack.clear();
5635 CanonicalConverted.insert(CanonicalConverted.end(),
5636 CanonicalArgumentPack.begin(),
5637 CanonicalArgumentPack.end());
5638 CanonicalArgumentPack.clear();
5641 while (ArgIdx < NumArgs) {
5643 SugaredConverted.push_back(Arg);
5644 CanonicalConverted.push_back(
5656 if (PartialTemplateArgs) {
5657 if ((*Param)->isTemplateParameterPack() && !SugaredArgumentPack.empty()) {
5658 SugaredConverted.push_back(
5660 CanonicalConverted.push_back(
5668 if ((*Param)->isTemplateParameterPack()) {
5670 "Should have dealt with this already");
5675 if (Param + 1 != ParamEnd) {
5678 "Concept templates must have parameter packs at the end.");
5682 SugaredConverted.push_back(
5684 SugaredArgumentPack.clear();
5686 CanonicalConverted.push_back(
5688 CanonicalArgumentPack.clear();
5703 Template, TemplateLoc, RAngleLoc, *Param, SugaredConverted,
5704 CanonicalConverted, HasDefaultArg);
5707 if (!HasDefaultArg) {
5712 dyn_cast<NonTypeTemplateParmDecl>(*Param))
5716 cast<TemplateTemplateParmDecl>(*Param),
5734 SugaredConverted, CanonicalConverted,
5738 SugaredConverted.back().setIsDefaulted(
true);
5739 CanonicalConverted.back().setIsDefaulted(
true);
5744 if (isTemplateTemplateParameter)
5758 while (ArgIdx < NumArgs &&
5759 NewArgs[ArgIdx].
getArgument().isPackExpansion()) {
5761 SugaredConverted.push_back(Arg);
5768 if (ArgIdx < NumArgs) {
5769 Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5780 if (UpdateArgsWithConversions)
5781 TemplateArgs = std::move(NewArgs);
5783 if (!PartialTemplateArgs) {
5790 if (
auto *TD = dyn_cast<TemplateDecl>(NewContext))
5792 auto *RD = dyn_cast<CXXRecordDecl>(NewContext);
5795 if (
const auto *Method =
5797 ThisQuals = Method->getMethodQualifiers();
5803 Template, NewContext,
false, CanonicalConverted,
5820 class UnnamedLocalNoLinkageFinder
5821 :
public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
5829 UnnamedLocalNoLinkageFinder(
Sema &S,
SourceRange SR) : S(S), SR(SR) { }
5832 return T.isNull() ?
false : inherited::Visit(
T.getTypePtr());
5835#define TYPE(Class, Parent) \
5836 bool Visit##Class##Type(const Class##Type *);
5837#define ABSTRACT_TYPE(Class, Parent) \
5838 bool Visit##Class##Type(const Class##Type *) { return false; }
5839#define NON_CANONICAL_TYPE(Class, Parent) \
5840 bool Visit##Class##Type(const Class##Type *) { return false; }
5841#include "clang/AST/TypeNodes.inc"
5843 bool VisitTagDecl(
const TagDecl *Tag);
5848bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(
const BuiltinType*) {
5852bool UnnamedLocalNoLinkageFinder::VisitComplexType(
const ComplexType*
T) {
5853 return Visit(
T->getElementType());
5856bool UnnamedLocalNoLinkageFinder::VisitPointerType(
const PointerType*
T) {
5860bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
5865bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
5870bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
5875bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
5880bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
5882 return Visit(
T->getElementType());
5885bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
5887 return Visit(
T->getElementType());
5890bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
5892 return Visit(
T->getElementType());
5895bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
5897 return Visit(
T->getElementType());
5900bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
5902 return Visit(
T->getElementType());
5905bool UnnamedLocalNoLinkageFinder::VisitDependentSizedMatrixType(
5907 return Visit(
T->getElementType());
5910bool UnnamedLocalNoLinkageFinder::VisitDependentAddressSpaceType(
5915bool UnnamedLocalNoLinkageFinder::VisitVectorType(
const VectorType*
T) {
5916 return Visit(
T->getElementType());
5919bool UnnamedLocalNoLinkageFinder::VisitDependentVectorType(
5921 return Visit(
T->getElementType());
5924bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(
const ExtVectorType*
T) {
5925 return Visit(
T->getElementType());
5928bool UnnamedLocalNoLinkageFinder::VisitConstantMatrixType(
5930 return Visit(
T->getElementType());
5933bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
5943bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
5948bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
5953bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(
const TypeOfExprType*) {
5957bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(
const TypeOfType*
T) {
5958 return Visit(
T->getUnmodifiedType());
5961bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(
const DecltypeType*) {
5965bool UnnamedLocalNoLinkageFinder::VisitPackIndexingType(
5970bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
5975bool UnnamedLocalNoLinkageFinder::VisitAutoType(
const AutoType *
T) {
5976 return Visit(
T->getDeducedType());
5979bool UnnamedLocalNoLinkageFinder::VisitDeducedTemplateSpecializationType(
5981 return Visit(
T->getDeducedType());
5984bool UnnamedLocalNoLinkageFinder::VisitRecordType(
const RecordType*
T) {
5985 return VisitTagDecl(
T->getDecl());
5988bool UnnamedLocalNoLinkageFinder::VisitEnumType(
const EnumType*
T) {
5989 return VisitTagDecl(
T->getDecl());
5992bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
5997bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
6002bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
6007bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
6009 return VisitTagDecl(
T->getDecl());
6012bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
6014 return VisitNestedNameSpecifier(
T->getQualifier());
6017bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
6019 if (
auto *Q =
T->getQualifier())
6020 return VisitNestedNameSpecifier(Q);
6024bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
6026 return Visit(
T->getPattern());
6029bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(
const ObjCObjectType *) {
6033bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
6038bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
6043bool UnnamedLocalNoLinkageFinder::VisitAtomicType(
const AtomicType*
T) {
6044 return Visit(
T->getValueType());
6047bool UnnamedLocalNoLinkageFinder::VisitPipeType(
const PipeType*
T) {
6051bool UnnamedLocalNoLinkageFinder::VisitBitIntType(
const BitIntType *
T) {
6055bool UnnamedLocalNoLinkageFinder::VisitArrayParameterType(
6057 return VisitConstantArrayType(
T);
6060bool UnnamedLocalNoLinkageFinder::VisitDependentBitIntType(
6065bool UnnamedLocalNoLinkageFinder::VisitTagDecl(
const TagDecl *Tag) {
6066 if (
Tag->getDeclContext()->isFunctionOrMethod()) {
6067 S.
Diag(SR.getBegin(),
6069 diag::warn_cxx98_compat_template_arg_local_type :
6070 diag::ext_template_arg_local_type)
6075 if (!
Tag->hasNameForLinkage()) {
6076 S.
Diag(SR.getBegin(),
6078 diag::warn_cxx98_compat_template_arg_unnamed_type :
6079 diag::ext_template_arg_unnamed_type) << SR;
6080 S.
Diag(
Tag->getLocation(), diag::note_template_unnamed_type_here);
6087bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
6105 llvm_unreachable(
"Invalid NestedNameSpecifier::Kind!");
6108bool UnnamedLocalNoLinkageFinder::VisitHLSLAttributedResourceType(
6110 if (
T->hasContainedType() && Visit(
T->getContainedType()))
6112 return Visit(
T->getWrappedType());
6116 assert(ArgInfo &&
"invalid TypeSourceInfo");
6122 return Diag(SR.
getBegin(), diag::err_variably_modified_template_arg) << Arg;
6124 return Diag(SR.
getBegin(), diag::err_template_arg_overload_type) << SR;
6135 UnnamedLocalNoLinkageFinder Finder(*
this, SR);
6136 (void)Finder.Visit(CanonArg);
6153 Decl *Entity =
nullptr) {
6159 if (Entity && Entity->hasAttr<DLLImportAttr>())
6164 "Incomplete parameter type in isNullPointerValueTemplateArgument!");
6177 EvalResult.
Diag = &Notes;
6185 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
6186 diag::note_invalid_subexpr_in_const_expr) {
6187 DiagLoc = Notes[0].first;
6191 S.
Diag(DiagLoc, diag::err_template_arg_not_address_constant)
6193 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
6194 S.
Diag(Notes[I].first, Notes[I].second);
6212 bool ObjCLifetimeConversion;
6215 ObjCLifetimeConversion))
6220 S.
Diag(Arg->
getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
6239 std::string Code =
"static_cast<" + ParamType.
getAsString() +
">(";
6240 S.
Diag(Arg->
getExprLoc(), diag::err_template_arg_untyped_null_constant)
6259 bool ObjCLifetimeConversion;
6263 ObjCLifetimeConversion)) {
6268 if (!ParamRef->getPointeeType()->isFunctionType()) {
6278 unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
6281 if ((ParamQuals | ArgQuals) != ParamQuals) {
6283 diag::err_template_arg_ref_bind_ignores_quals)
6320 bool AddressTaken =
false;
6327 bool ExtWarnMSTemplateArg =
false;
6330 while (
UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
6332 if (UnOpKind == UO_Deref)
6333 ExtWarnMSTemplateArg =
true;
6334 if (UnOpKind == UO_AddrOf || UnOpKind == UO_Deref) {
6337 FirstOpKind = UnOpKind;
6338 FirstOpLoc = UnOp->getOperatorLoc();
6344 if (ExtWarnMSTemplateArg)
6348 if (FirstOpKind == UO_AddrOf)
6349 AddressTaken =
true;
6353 assert(FirstOpKind == UO_Deref);
6376 bool ExtraParens =
false;
6378 if (!
Invalid && !ExtraParens) {
6381 ? diag::warn_cxx98_compat_template_arg_extra_parens
6382 : diag::ext_template_arg_extra_parens)
6387 Arg =
Parens->getSubExpr();
6391 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
6395 if (UnOp->getOpcode() == UO_AddrOf) {
6396 Arg = UnOp->getSubExpr();
6397 AddressTaken =
true;
6398 AddrOpLoc = UnOp->getOperatorLoc();
6403 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
6408 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg))
6409 Entity = DRE->getDecl();
6411 Entity = CUE->getGuidDecl();
6418 S.
Diag(Arg->
getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
6421 CanonicalConverted =
6438 CanonicalConverted =
6451 if (isa<FieldDecl>(Entity) || isa<IndirectFieldDecl>(Entity)) {
6459 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Entity)) {
6460 if (!Method->isStatic()) {
6469 VarDecl *Var = dyn_cast<VarDecl>(Entity);
6470 MSGuidDecl *Guid = dyn_cast<MSGuidDecl>(Entity);
6473 if (!
Func && !Var && !Guid) {
6485 ? diag::warn_cxx98_compat_template_arg_object_internal
6486 : diag::ext_template_arg_object_internal)
6488 S.
Diag(Entity->
getLocation(), diag::note_template_arg_internal_object)
6493 S.
Diag(Entity->
getLocation(), diag::note_template_arg_internal_object)
6522 S.
Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
6528 S.
Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
6570 CanonicalConverted =
6586 Expr *Arg = ResultArg;
6587 bool ObjCLifetimeConversion;
6599 bool ExtraParens =
false;
6601 if (!
Invalid && !ExtraParens) {
6604 ? diag::warn_cxx98_compat_template_arg_extra_parens
6605 : diag::ext_template_arg_extra_parens)
6610 Arg =
Parens->getSubExpr();
6614 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
6619 if (UnOp->getOpcode() == UO_AddrOf) {
6620 DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());
6626 else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
6629 if (isa<NonTypeTemplateParmDecl>(VD)) {
6632 CanonicalConverted =
6636 CanonicalConverted =
6655 S.
Diag(ResultArg->
getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
6667 ObjCLifetimeConversion)) {
6674 S.
Diag(ResultArg->
getBeginLoc(), diag::err_template_arg_not_convertible)
6682 diag::err_template_arg_not_pointer_to_member_form)
6685 if (isa<FieldDecl>(DRE->
getDecl()) ||
6686 isa<IndirectFieldDecl>(DRE->
getDecl()) ||
6687 isa<CXXMethodDecl>(DRE->
getDecl())) {
6688 assert((isa<FieldDecl>(DRE->
getDecl()) ||
6689 isa<IndirectFieldDecl>(DRE->
getDecl()) ||
6690 cast<CXXMethodDecl>(DRE->
getDecl())
6691 ->isImplicitObjectMemberFunction()) &&
6692 "Only non-static member pointers can make it here");
6698 CanonicalConverted =
6703 CanonicalConverted =
6711 S.
Diag(Arg->
getBeginLoc(), diag::err_template_arg_not_pointer_to_member_form)
6733 auto *AT = dyn_cast<AutoType>(DeducedT);
6734 if (AT && AT->isDecltypeAuto()) {
6745 Expr *DeductionArg = Arg;
6746 if (
auto *PE = dyn_cast<PackExpansionExpr>(DeductionArg))
6747 DeductionArg = PE->getPattern();
6750 if (isa<DeducedTemplateSpecializationType>(DeducedT)) {
6754 DeductionArg->
getBeginLoc(),
false, DeductionArg);
6755 Expr *Inits[1] = {DeductionArg};
6778 diag::err_non_type_template_parm_type_deduction_failure)
6790 if (ParamType.
isNull()) {
6798 "non-type template parameter type cannot be qualified");
6824 Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
6835 auto *PE = dyn_cast<PackExpansionExpr>(Arg);
6837 Arg = PE->getPattern();
6849 PE->getNumExpansions());
6867 if (ParamType->
isRecordType() && isa<DeclRefExpr>(InnerArg) &&
6869 NamedDecl *ND = cast<DeclRefExpr>(InnerArg)->getDecl();
6870 if (
auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
6873 CanonicalConverted =
6877 if (isa<NonTypeTemplateParmDecl>(ND)) {
6879 CanonicalConverted =
6890 bool IsConvertedConstantExpression =
true;
6891 if (isa<InitListExpr>(Arg) || ParamType->
isRecordType()) {
6894 Expr *Inits[1] = {Arg};
6908 IsConvertedConstantExpression =
false;
6917 if (IsConvertedConstantExpression) {
6930 CanonicalConverted =
6938 false, PreNarrowingValue);
6942 if (
Value.isLValue()) {
6955 isa<LifetimeExtendedTemporaryDecl, UnnamedGlobalConstantDecl>(VD))) {
6961 if (
Value.hasLValuePath() &&
Value.getLValuePath().size() == 1 && VD &&
6963 Value.getLValuePath()[0].getAsArrayIndex() == 0 &&
6968 return ArgResult.
get();
6973 if (!
Value.hasLValuePath() ||
Value.getLValuePath().size() ||
6974 Value.isLValueOnePastTheEnd()) {
6975 Diag(StartLoc, diag::err_non_type_template_arg_subobject)
6980 "null reference should not be a constant expression");
6982 "non-null value of type nullptr_t?");
6986 if (
Value.isAddrLabelDiff())
6987 return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
6991 return ArgResult.
get();
7029 CanonicalConverted =
7039 IntegerType =
Enum->getDecl()->getIntegerType();
7045 CanonicalConverted =
7053 Arg = ArgResult.
get();
7066 Diag(Arg->
getBeginLoc(), diag::err_template_arg_not_integral_or_enumeral)
7079 return S.
Diag(
Loc, diag::err_template_arg_not_ice) <<
T;
7081 } Diagnoser(ArgType);
7117 CanonicalConverted =
7124 IntegerType =
Enum->getDecl()->getIntegerType();
7131 if (
Value.getBitWidth() != AllowedBits)
7135 llvm::APSInt OldValue =
Value;
7142 if (
Value.getBitWidth() != AllowedBits)
7148 (OldValue.isSigned() && OldValue.isNegative())) {
7156 unsigned RequiredBits;
7158 RequiredBits = OldValue.getActiveBits();
7159 else if (OldValue.isUnsigned())
7160 RequiredBits = OldValue.getActiveBits() + 1;
7162 RequiredBits = OldValue.getSignificantBits();
7163 if (RequiredBits > AllowedBits) {
7173 CanonicalConverted =
7223 *
this, Param, ParamType, Arg, SugaredConverted,
7224 CanonicalConverted))
7230 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
7241 "Only object pointers allowed here");
7244 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
7256 assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&
7257 "Only object references allowed here");
7261 ParamRefType->getPointeeType(),
7276 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
7285 CanonicalConverted =
7293 << Arg->
getType() << ParamType;
7301 Diag(Arg->
getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
7315 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
7329 auto [Template, DefaultArgs] = Name.getTemplateDeclAndDefaultArgs();
7332 assert(Name.isDependent() &&
"Non-dependent template isn't a declaration?");
7336 if (Template->isInvalidDecl())
7351 if (!isa<ClassTemplateDecl>(Template) &&
7352 !isa<TemplateTemplateParmDecl>(Template) &&
7353 !isa<TypeAliasTemplateDecl>(Template) &&
7354 !isa<BuiltinTemplateDecl>(Template)) {
7355 assert(isa<FunctionTemplateDecl>(Template) &&
7356 "Only function templates are possible here");
7358 Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
7371 Template->getTemplateParameters(), Params,
false,
7376 !Template->hasAssociatedConstraints())
7380 Params, Template, DefaultArgs, Arg.
getLocation(), IsDeduced)) {
7390 if (ParamsAC.empty())
7393 Template->getAssociatedConstraints(TemplateAC);
7395 bool IsParamAtLeastAsConstrained;
7397 IsParamAtLeastAsConstrained))
7399 if (!IsParamAtLeastAsConstrained) {
7401 diag::err_template_template_parameter_not_at_least_as_constrained)
7404 Diag(Template->getLocation(), diag::note_entity_declared_at)
7423 unsigned HereDiagID,
7424 unsigned ExternalDiagID) {
7429 llvm::raw_svector_ostream Out(Str);
7437 std::optional<SourceRange> ParamRange) {
7440 diag::note_template_decl_external);
7441 if (ParamRange && ParamRange->isValid()) {
7443 "Parameter range has location when Decl does not");
7450 diag::note_template_param_external);
7473 ? CK_NullToMemberPointer
7474 : CK_NullToPointer);
7477 "Only declaration template arguments permitted here");
7486 (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD) ||
7487 isa<IndirectFieldDecl>(VD)));
7515 assert(isa<TemplateParamObjectDecl>(VD) &&
7516 "arg for class template param not a template parameter object");
7521 "unexpected type for decl template argument");
7523 dyn_cast_if_present<NonTypeTemplateParmDecl>(
TemplateParam)) {
7524 QualType TemplateParamType = NTTP->getType();
7538 "value kind mismatch for non-type template argument");
7558 "unexpected conversion required for non-type template argument");
7585 T = ET->getDecl()->getIntegerType();
7636 llvm_unreachable(
"unexpected template argument value");
7661 return MakeInitList(
7674 return MakeInitList(Elts);
7679 llvm_unreachable(
"Unexpected APValue kind.");
7695 llvm_unreachable(
"Unhandled APValue::ValueKind enum");
7707 llvm_unreachable(
"not a non-type template argument");
7725 llvm_unreachable(
"Unhandled TemplateArgument::ArgKind enum");
7732 const NamedDecl *OldInstFrom,
bool Complain,
7737 unsigned NextDiag = diag::err_template_param_different_kind;
7738 if (TemplateArgLoc.
isValid()) {
7739 S.
Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
7740 NextDiag = diag::note_template_param_different_kind;
7759 unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
7760 if (TemplateArgLoc.
isValid()) {
7761 S.
Diag(TemplateArgLoc,
7762 diag::err_template_arg_template_params_mismatch);
7763 NextDiag = diag::note_template_parameter_pack_non_pack;
7766 unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0
7767 : isa<NonTypeTemplateParmDecl>(New)? 1
7780 = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
7788 (!OldNTTP->getType()->isDependentType() &&
7798 unsigned NextDiag = diag::err_template_nontype_parm_different_type;
7799 if (TemplateArgLoc.
isValid()) {
7800 S.
Diag(TemplateArgLoc,
7801 diag::err_template_arg_template_params_mismatch);
7802 NextDiag = diag::note_template_nontype_parm_different_type;
7807 S.
Diag(OldNTTP->getLocation(),
7808 diag::note_template_nontype_parm_prev_declaration)
7809 << OldNTTP->getType();
7820 dyn_cast<TemplateTemplateParmDecl>(Old)) {
7824 OldTTP->getTemplateParameters(), Complain,
7834 !isa<TemplateTemplateParmDecl>(Old)) {
7835 const Expr *NewC =
nullptr, *OldC =
nullptr;
7837 if (isa<TemplateTypeParmDecl>(New)) {
7838 if (
const auto *TC = cast<TemplateTypeParmDecl>(New)->getTypeConstraint())
7839 NewC = TC->getImmediatelyDeclaredConstraint();
7840 if (
const auto *TC = cast<TemplateTypeParmDecl>(Old)->getTypeConstraint())
7841 OldC = TC->getImmediatelyDeclaredConstraint();
7842 }
else if (isa<NonTypeTemplateParmDecl>(New)) {
7843 if (
const Expr *
E = cast<NonTypeTemplateParmDecl>(New)
7844 ->getPlaceholderTypeConstraint())
7846 if (
const Expr *
E = cast<NonTypeTemplateParmDecl>(Old)
7847 ->getPlaceholderTypeConstraint())
7850 llvm_unreachable(
"unexpected template parameter type");
7852 auto Diagnose = [&] {
7854 diag::err_template_different_type_constraint);
7856 diag::note_template_prev_declaration) << 0;
7859 if (!NewC != !OldC) {
7886 unsigned NextDiag = diag::err_template_param_list_different_arity;
7887 if (TemplateArgLoc.
isValid()) {
7888 S.
Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
7889 NextDiag = diag::note_template_param_list_different_arity;
7921 OldParmEnd = Old->
end();
7922 OldParm != OldParmEnd; ++OldParm) {
7924 !(*OldParm)->isTemplateParameterPack()) {
7925 if (NewParm == NewParmEnd) {
7934 OldInstFrom, Complain, Kind,
7949 for (; NewParm != NewParmEnd; ++NewParm) {
7951 OldInstFrom, Complain, Kind,
7958 if (NewParm != NewParmEnd) {
7973 diag::err_template_different_requires_clause);
7975 diag::note_template_prev_declaration) << 0;
7978 if (!NewRC != !OldRC) {
8003 S = S->getDeclParent();
8013 Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
8033 if (RD->isLocalClass())
8035 diag::err_template_inside_local_class)
8043 diag::err_template_outside_namespace_or_class_scope)
8054 return Record->getTemplateSpecializationKind();
8056 return Function->getTemplateSpecializationKind();
8057 if (
VarDecl *Var = dyn_cast<VarDecl>(
D))
8058 return Var->getTemplateSpecializationKind();
8095 if (isa<ClassTemplateDecl>(Specialized))
8097 else if (isa<VarTemplateDecl>(Specialized))
8099 else if (isa<FunctionTemplateDecl>(Specialized))
8101 else if (isa<CXXMethodDecl>(Specialized))
8103 else if (isa<VarDecl>(Specialized))
8105 else if (isa<RecordDecl>(Specialized))
8107 else if (isa<EnumDecl>(Specialized) && S.
getLangOpts().CPlusPlus11)
8110 S.
Diag(
Loc, diag::err_template_spec_unknown_kind)
8120 S.
Diag(
Loc, diag::err_template_spec_decl_function_scope)
8135 : DC->
Equals(SpecializedContext))) {
8136 if (isa<TranslationUnitDecl>(SpecializedContext))
8137 S.
Diag(
Loc, diag::err_template_spec_redecl_global_scope)
8138 << EntityKind << Specialized;
8140 auto *ND = cast<NamedDecl>(SpecializedContext);
8141 int Diag = diag::err_template_spec_redecl_out_of_scope;
8143 Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
8145 << ND << isa<CXXRecordDecl>(ND);
8148 S.
Diag(Specialized->getLocation(), diag::note_specialized_entity);
8162 DependencyChecker Checker(Depth,
true);
8163 Checker.TraverseStmt(
E);
8164 if (Checker.MatchLoc.isInvalid())
8166 return Checker.MatchLoc;
8172 DependencyChecker Checker(Depth,
true);
8173 Checker.TraverseTypeLoc(TL);
8174 if (Checker.MatchLoc.isInvalid())
8176 return Checker.MatchLoc;
8184 for (
unsigned I = 0; I != NumArgs; ++I) {
8187 S, TemplateNameLoc, Param, Args[I].pack_begin(),
8188 Args[I].pack_size(), IsDefaultArgument))
8201 ArgExpr = Expansion->getPattern();
8205 ArgExpr = ICE->getSubExpr();
8215 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
8216 if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
8236 if (ParamUseRange.
isValid()) {
8237 if (IsDefaultArgument) {
8238 S.
Diag(TemplateNameLoc,
8239 diag::err_dependent_non_type_arg_in_partial_spec);
8241 diag::note_dependent_non_type_default_arg_in_partial_spec)
8245 diag::err_dependent_non_type_arg_in_partial_spec)
8253 if (ParamUseRange.
isValid()) {
8255 diag::err_dependent_typed_non_type_arg_in_partial_spec)
8275 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
8277 = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->
getParam(I));
8282 Param, &TemplateArgs[I],
8283 1, I >= NumExplicit))
8304 = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());
8307 Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
8308 << (Name.getAsTemplateDecl() &&
8309 isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));
8313 if (
const auto *DSA =
ClassTemplate->getAttr<NoSpecializationsAttr>()) {
8314 auto Message = DSA->getMessage();
8315 Diag(TemplateNameLoc, diag::warn_invalid_specialization)
8317 Diag(DSA->getLoc(), diag::note_marked_here) << DSA;
8320 if (S->isTemplateParamScope())
8325 bool isMemberSpecialization =
false;
8326 bool isPartialSpecialization =
false;
8331 TemplateNameLoc, &TemplateId,
8343 KWLoc, TemplateNameLoc, SS, &TemplateId, TemplateParameterLists,
8358 if (TemplateParams && TemplateParams->
size() > 0) {
8359 isPartialSpecialization =
true;
8362 Diag(KWLoc, diag::err_partial_specialization_friend)
8370 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
8373 if (TTP->hasDefaultArgument()) {
8374 Diag(TTP->getDefaultArgumentLoc(),
8375 diag::err_default_arg_in_partial_spec);
8376 TTP->removeDefaultArgument();
8379 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
8380 if (NTTP->hasDefaultArgument()) {
8381 Diag(NTTP->getDefaultArgumentLoc(),
8382 diag::err_default_arg_in_partial_spec)
8383 << NTTP->getDefaultArgument().getSourceRange();
8384 NTTP->removeDefaultArgument();
8390 diag::err_default_arg_in_partial_spec)
8396 }
else if (TemplateParams) {
8398 Diag(KWLoc, diag::err_template_spec_friend)
8405 "should have a 'template<>' for this decl");
8412 "Invalid enum tag in class template spec!");
8416 Diag(KWLoc, diag::err_use_with_wrong_tag)
8421 diag::note_previous_use);
8430 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
8432 isPartialSpecialization
8442 false, SugaredConverted,
8449 if (isPartialSpecialization) {
8451 TemplateArgs.
size(),
8452 CanonicalConverted))
8457 if (!Name.isDependent() &&
8459 TemplateArgs, CanonicalConverted)) {
8460 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
8462 isPartialSpecialization =
false;
8467 void *InsertPos =
nullptr;
8470 if (isPartialSpecialization)
8472 CanonicalConverted, TemplateParams, InsertPos);
8474 PrevDecl =
ClassTemplate->findSpecialization(CanonicalConverted, InsertPos);
8483 isPartialSpecialization))
8488 if (isPartialSpecialization) {
8493 CanonicalConverted);
8506 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
8514 TemplateParameterLists.data());
8519 = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
8522 Context, Kind, DC, KWLoc, TemplateNameLoc, TemplateParams,
8526 if (TemplateParameterLists.size() > 1 && SS.
isSet()) {
8528 Context, TemplateParameterLists.drop_back(1));
8532 ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
8546 CanonicalConverted, PrevDecl);
8549 if (TemplateParameterLists.size() > 0) {
8551 TemplateParameterLists);
8560 CanonicalConverted);
8584 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
8588 diag::note_instantiation_required_here)
8626 if (ModulePrivateLoc.
isValid())
8628 << (isPartialSpecialization? 1 : 0)
8654 Name, TemplateNameLoc, TemplateArgs, CanonType);
8691 diag::err_concept_decls_may_only_appear_in_global_namespace_scope);
8695 if (TemplateParameterLists.size() > 1) {
8696 Diag(NameLoc, diag::err_concept_extra_headers);
8702 if (Params->
size() == 0) {
8703 Diag(NameLoc, diag::err_concept_no_parameters);
8710 ParamEnd = Params->
end();
8711 ParamIt != ParamEnd; ++ParamIt) {
8712 Decl const *Param = *ParamIt;
8714 if (++ParamIt == ParamEnd)
8717 diag::err_template_param_pack_must_be_last_template_parameter);
8728 Diag(NameLoc, diag::err_concept_no_associated_constraints);
8765 Expr *ConstraintExpr,
8767 assert(!
C->hasDefinition() &&
"Concept already defined");
8770 C->setDefinition(ConstraintExpr);
8781 bool AddToScope =
true;
8785 if (!WasAlreadyAdded && AddToScope)
8798 auto *OldConcept = dyn_cast<ConceptDecl>(
Previous.getRepresentativeDecl()->getUnderlyingDecl());
8800 auto *Old =
Previous.getRepresentativeDecl();
8810 Diag(NewDecl->
getLocation(), diag::err_redefinition_different_concept)
8837 Diag(
Concept->getLocation(), diag::note_declared_at);
8846 if (MinGW || (isa<FunctionDecl>(
D) &&
8847 cast<FunctionDecl>(
D)->isFunctionTemplateSpecialization()))
8848 D->
dropAttrs<DLLImportAttr, DLLExportAttr>();
8851 FD->setInlineSpecified(
false);
8863 Prev = Prev->getPreviousDecl()) {
8864 PrevDiagLoc = Prev->getLocation();
8866 assert(PrevDiagLoc.
isValid() &&
8867 "Explicit instantiation without point of instantiation?");
8877 bool &HasNoEffect) {
8878 HasNoEffect =
false;
8885 "previous declaration must be implicit!");
8898 if (PrevPointOfInstantiation.
isInvalid()) {
8912 PrevPointOfInstantiation.
isValid()) &&
8913 "Explicit instantiation without point of instantiation?");
8927 Diag(NewLoc, diag::err_specialization_after_instantiation)
8929 Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
8934 llvm_unreachable(
"The switch over PrevTSK must be exhaustive.");
8964 diag::err_explicit_instantiation_declaration_after_definition);
8970 diag::note_explicit_instantiation_definition_here);
8974 llvm_unreachable(
"Unexpected TemplateSpecializationKind!");
8990 Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
8993 diag::note_previous_template_specialization);
9024 ? diag::ext_explicit_instantiation_duplicate
9025 : diag::err_explicit_instantiation_duplicate)
9028 diag::note_previous_explicit_instantiation);
9034 llvm_unreachable(
"Missing specialization/instantiation case?");
9044 enum DiscardReason { NotAFunctionTemplate, NotAMemberOfEnclosing };
9048 if (!isa<FunctionTemplateDecl>(
D)) {
9050 DiscardedCandidates.push_back(std::make_pair(NotAFunctionTemplate,
D));
9057 DiscardedCandidates.push_back(std::make_pair(NotAMemberOfEnclosing,
D));
9065 Diag(FD->
getLocation(), diag::err_dependent_function_template_spec_no_match)
9067 for (
auto &
P : DiscardedCandidates)
9068 Diag(
P.second->getLocation(),
9069 diag::note_dependent_function_template_spec_discard_reason)
9070 <<
P.first << IsFriend;
9075 ExplicitTemplateArgs);
9088 llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>
9089 ConvertedTemplateArgs;
9112 if (
auto *NewMD = dyn_cast<CXXMethodDecl>(FD);
9113 !
getLangOpts().CPlusPlus14 && NewMD && NewMD->isConstexpr() &&
9114 !isa<CXXConstructorDecl, CXXDestructorDecl>(NewMD)) {
9115 auto *OldMD = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
9116 if (OldMD && OldMD->isConst()) {
9126 if (ExplicitTemplateArgs)
9127 Args = *ExplicitTemplateArgs;
9139 cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
9140 ExplicitTemplateArgs ? &Args :
nullptr, FT,
Specialization, Info);
9145 I.getPair(), FunTmpl->getTemplatedDecl(),
9161 I.getPair(), FunTmpl->getTemplatedDecl(),
9168 if (ExplicitTemplateArgs)
9177 if (QualifiedFriend && Candidates.
empty()) {
9183 if (
auto *OldFD = dyn_cast<FunctionDecl>(OldND->getUnderlyingDecl()))
9194 PDiag(diag::err_function_template_spec_ambiguous)
9195 << FD->
getDeclName() << (ExplicitTemplateArgs !=
nullptr),
9196 PDiag(diag::note_function_template_spec_matched));
9205 const auto *DSA = PT->getAttr<NoSpecializationsAttr>()) {
9206 auto Message = DSA->getMessage();
9208 << PT << !Message.empty() << Message;
9209 Diag(DSA->getLoc(), diag::note_marked_here) << DSA;
9237 auto *SpecializationFPT =
9248 assert(SpecInfo &&
"Function template specialization info missing?");
9286 bool HasNoEffect =
false;
9312 "This must be the only existing declaration of this specialization");
9327 FD->setFunctionTemplateSpecialization(
9330 ExplicitTemplateArgs ? &ConvertedTemplateArgs[
Specialization] :
nullptr);
9349 assert(!
Member->isTemplateDecl() && !
Member->getDescribedTemplate() &&
9350 "Only for non-template members");
9353 NamedDecl *FoundInstantiation =
nullptr;
9363 auto *Method = dyn_cast<CXXMethodDecl>(Candidate->getUnderlyingDecl());
9381 Method->getTrailingRequiresClause() &&
9385 !Satisfaction.IsSatisfied))
9388 Candidates.
addDecl(Candidate);
9392 if (Candidates.
empty())
9401 auto *Method = cast<CXXMethodDecl>(I->getUnderlyingDecl());
9405 BestMethod = Method;
9409 FoundInstantiation = *Best;
9410 Instantiation = BestMethod;
9415 bool Ambiguous =
false;
9418 auto *Method = cast<CXXMethodDecl>(I->getUnderlyingDecl());
9427 Diag(
Member->getLocation(), diag::err_function_member_spec_ambiguous)
9428 <<
Member << (InstantiatedFrom ? InstantiatedFrom : Instantiation);
9429 for (
NamedDecl *Candidate : Candidates) {
9430 Candidate = Candidate->getUnderlyingDecl();
9431 Diag(Candidate->getLocation(), diag::note_function_member_spec_matched)
9436 }
else if (isa<VarDecl>(
Member)) {
9439 (PrevVar = dyn_cast<VarDecl>(
Previous.getFoundDecl())))
9441 FoundInstantiation =
Previous.getRepresentativeDecl();
9442 Instantiation = PrevVar;
9446 }
else if (isa<RecordDecl>(
Member)) {
9449 (PrevRecord = dyn_cast<CXXRecordDecl>(
Previous.getFoundDecl()))) {
9450 FoundInstantiation =
Previous.getRepresentativeDecl();
9451 Instantiation = PrevRecord;
9455 }
else if (isa<EnumDecl>(
Member)) {
9458 (PrevEnum = dyn_cast<EnumDecl>(
Previous.getFoundDecl()))) {
9459 FoundInstantiation =
Previous.getRepresentativeDecl();
9460 Instantiation = PrevEnum;
9466 if (!Instantiation) {
9480 if (InstantiatedFrom && isa<CXXMethodDecl>(
Member)) {
9481 cast<CXXMethodDecl>(
Member)->setInstantiationOfMemberFunction(
9482 cast<CXXMethodDecl>(InstantiatedFrom),
9484 }
else if (InstantiatedFrom && isa<CXXRecordDecl>(
Member)) {
9485 cast<CXXRecordDecl>(
Member)->setInstantiationOfMemberClass(
9486 cast<CXXRecordDecl>(InstantiatedFrom),
9491 Previous.addDecl(FoundInstantiation);
9496 if (!InstantiatedFrom) {
9497 Diag(
Member->getLocation(), diag::err_spec_member_not_instantiated)
9509 assert(MSInfo &&
"Member specialization info missing?");
9511 bool HasNoEffect =
false;
9523 Instantiation,
Member->getLocation(),
9529 if (
auto *MemberFunction = dyn_cast<FunctionDecl>(
Member)) {
9530 FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation);
9535 if (InstantiationFunction->
isDeleted()) {
9538 InstantiationFunction);
9544 MemberFunction->setInstantiationOfMemberFunction(
9546 }
else if (
auto *MemberVar = dyn_cast<VarDecl>(
Member)) {
9547 MemberVar->setInstantiationOfStaticDataMember(
9549 }
else if (
auto *MemberClass = dyn_cast<CXXRecordDecl>(
Member)) {
9550 MemberClass->setInstantiationOfMemberClass(
9552 }
else if (
auto *MemberEnum = dyn_cast<EnumDecl>(
Member)) {
9553 MemberEnum->setInstantiationOfMemberEnum(
9556 llvm_unreachable(
"unknown member specialization kind");
9562 Previous.addDecl(FoundInstantiation);
9571template<
typename DeclT>
9582 OrigD->setLocation(
Loc);
9587 NamedDecl *Instantiation = cast<NamedDecl>(
Member->getCanonicalDecl());
9588 if (Instantiation ==
Member)
9591 if (
auto *
Function = dyn_cast<CXXMethodDecl>(Instantiation))
9593 else if (
auto *Var = dyn_cast<VarDecl>(Instantiation))
9595 else if (
auto *
Record = dyn_cast<CXXRecordDecl>(Instantiation))
9597 else if (
auto *
Enum = dyn_cast<EnumDecl>(Instantiation))
9600 llvm_unreachable(
"unknown member specialization kind");
9608 bool WasQualifiedName) {
9613 S.
Diag(InstLoc, diag::err_explicit_instantiation_in_class)
9626 if (WasQualifiedName) {
9627 if (CurContext->
Encloses(OrigContext))
9634 if (
NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) {
9635 if (WasQualifiedName)
9638 diag::err_explicit_instantiation_out_of_scope :
9639 diag::warn_explicit_instantiation_out_of_scope_0x)
9644 diag::err_explicit_instantiation_unqualified_wrong_namespace :
9645 diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
9650 diag::err_explicit_instantiation_must_be_global :
9651 diag::warn_explicit_instantiation_must_be_global_0x)
9660 bool WasQualifiedName,
9667 S.
Diag(InstLoc, diag::err_explicit_instantiation_internal_linkage) <<
D;
9695 if (isa<TemplateSpecializationType>(
T))
9705 auto *A = cast_or_null<InheritableAttr>(
getDLLAttr(Def));
9706 assert(A &&
"dllExportImportClassTemplateSpecialization called "
9707 "on Def without dllexport or dllimport");
9712 "delayed exports present at explicit instantiation");
9716 for (
auto &B : Def->
bases()) {
9717 if (
auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
9718 B.getType()->getAsCXXRecordDecl()))
9738 "Invalid enum tag in class template explicit instantiation!");
9744 Diag(TemplateNameLoc, diag::err_tag_reference_non_tag)
9745 << TD << NTK << llvm::to_underlying(Kind);
9753 Diag(KWLoc, diag::err_use_with_wrong_tag)
9758 diag::note_previous_use);
9775 if (AL.getKind() == ParsedAttr::AT_DLLExport) {
9777 diag::warn_attribute_dllexport_explicit_instantiation_decl);
9778 Diag(AL.getLoc(), diag::note_attribute);
9783 if (
auto *A =
ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {
9785 diag::warn_attribute_dllexport_explicit_instantiation_decl);
9786 Diag(A->getLocation(), diag::note_attribute);
9792 bool DLLImportExplicitInstantiationDef =
false;
9797 ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
9799 if (AL.getKind() == ParsedAttr::AT_DLLImport)
9801 if (AL.getKind() == ParsedAttr::AT_DLLExport) {
9809 DLLImportExplicitInstantiationDef =
true;
9821 {},
false, SugaredConverted,
9828 void *InsertPos =
nullptr;
9830 ClassTemplate->findSpecialization(CanonicalConverted, InsertPos);
9840 if (AL.getKind() == ParsedAttr::AT_DLLExport) {
9842 diag::warn_attribute_dllexport_explicit_instantiation_def);
9854 bool HasNoEffect =
false;
9857 PrevDecl, PrevDecl_TSK,
9878 DLLImportExplicitInstantiationDef) {
9880 HasNoEffect =
false;
9895 if (
const auto *A = PrevDecl->
getAttr<MSInheritanceAttr>()) {
9897 Clone->setInherited(
true);
9903 if (!HasNoEffect && !PrevDecl) {
9916 bool PreviouslyDLLExported =
Specialization->hasAttr<DLLExportAttr>();
9941 = cast_or_null<ClassTemplateSpecializationDecl>(
9951 Def = cast_or_null<ClassTemplateSpecializationDecl>(
9959 DLLImportExplicitInstantiationDef)) {
9968 auto *A = cast<InheritableAttr>(
9970 A->setInherited(
true);
9978 bool NewlyDLLExported =
9979 !PreviouslyDLLExported &&
Specialization->hasAttr<DLLExportAttr>();
9995 "Def and Specialization should match for implicit instantiation");
10003 PrevDecl->
hasAttr<DLLExportAttr>()) {
10027 bool Owned =
false;
10028 bool IsDependent =
false;
10036 assert(!IsDependent &&
"explicit instantiation of dependent name not yet handled");
10041 TagDecl *Tag = cast<TagDecl>(TagD);
10042 assert(!Tag->isEnum() &&
"shouldn't see enumerations here");
10044 if (Tag->isInvalidDecl())
10050 Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
10052 Diag(
Record->getLocation(), diag::note_nontemplate_decl_here);
10063 Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
10078 = cast_or_null<CXXRecordDecl>(
Record->getPreviousDecl());
10083 bool HasNoEffect =
false;
10084 assert(MSInfo &&
"No member specialization information?");
10096 = cast_or_null<CXXRecordDecl>(
Record->getDefinition());
10104 Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
10105 << 0 <<
Record->getDeclName() <<
Record->getDeclContext();
10115 RecordDef = cast_or_null<CXXRecordDecl>(
Record->getDefinition());
10144 if (!
D.isInvalidType())
10146 diag::err_explicit_instantiation_requires_name)
10153 S = S->getDeclParent();
10165 Diag(
D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef)
10168 }
else if (
D.getDeclSpec().getStorageClassSpec()
10171 Diag(
D.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class)
10174 D.getMutableDeclSpec().ClearStorageClassSpecs();
10182 if (
D.getDeclSpec().isInlineSpecified())
10183 Diag(
D.getDeclSpec().getInlineSpecLoc(),
10185 diag::err_explicit_instantiation_inline :
10186 diag::warn_explicit_instantiation_inline_0x)
10191 Diag(
D.getDeclSpec().getConstexprSpecLoc(),
10192 diag::err_explicit_instantiation_constexpr);
10197 Diag(
D.getDeclSpec().
getBeginLoc(), diag::err_deduction_guide_specialized)
10228 if (!PrevTemplate) {
10231 Diag(
D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
10235 Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
10241 Diag(
D.getIdentifierLoc(),
10242 diag::err_explicit_instantiation_data_member_not_instantiated)
10257 Diag(
T->getTypeLoc().getBeginLoc(),
10258 diag::err_auto_not_allowed_var_inst);
10266 Diag(
D.getIdentifierLoc(),
10267 diag::err_explicit_instantiation_without_template_id)
10269 Diag(PrevTemplate->getLocation(),
10270 diag::note_explicit_instantiation_here);
10279 D.getIdentifierLoc(), TemplateArgs);
10287 Diag(
D.getIdentifierLoc(), diag::err_explicit_instantiation_dependent);
10293 Prev = cast<VarDecl>(Res.
get());
10307 Diag(
D.getIdentifierLoc(),
10308 diag::ext_explicit_instantiation_without_qualified_id)
10309 << Prev <<
D.getCXXScopeSpec().getRange();
10316 bool HasNoEffect =
false;
10318 PrevTSK, POI, HasNoEffect))
10321 if (!HasNoEffect) {
10324 if (
auto *VTSD = dyn_cast<VarTemplatePartialSpecializationDecl>(Prev)) {
10325 VTSD->setExternKeywordLoc(ExternLoc);
10326 VTSD->setTemplateKeywordLoc(TemplateLoc);
10340 Diag(
T->getTypeLoc().getBeginLoc(),
10341 diag::err_invalid_var_template_spec_type)
10342 << 0 << PrevTemplate << R << Prev->
getType();
10343 Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
10344 << 2 << PrevTemplate->getDeclName();
10349 return (
Decl*)
nullptr;
10354 bool HasExplicitTemplateArgs =
false;
10358 HasExplicitTemplateArgs =
true;
10373 if (!HasExplicitTemplateArgs) {
10374 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) {
10378 if (Method->getPrimaryTemplate()) {
10379 TemplateMatches.
addDecl(Method,
P.getAccess());
10382 C.FoundDecl =
P.getPair();
10383 C.Function = Method;
10386 if (Method->getTrailingRequiresClause() &&
10405 FunTmpl, (HasExplicitTemplateArgs ? &TemplateArgs :
nullptr), R,
10436 if (!NonTemplateMatches.
empty()) {
10447 Msg = diag::err_explicit_instantiation_ambiguous;
10451 Msg = diag::err_explicit_instantiation_no_candidate;
10467 TemplateMatches.
begin(), TemplateMatches.
end(),
10468 FailedTemplateCandidates,
D.getIdentifierLoc(),
10469 PDiag(diag::err_explicit_instantiation_not_known) << Name,
10470 PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
10471 PDiag(diag::note_explicit_instantiation_candidate));
10487 if (FPT->hasExceptionSpec()) {
10489 diag::err_mismatched_exception_spec_explicit_instantiation;
10491 DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;
10494 PDiag(diag::note_explicit_instantiation_here),
10504 Diag(
D.getIdentifierLoc(),
10505 diag::err_explicit_instantiation_member_function_not_instantiated)
10514 if (!PrevDecl &&
Specialization->isThisDeclarationADefinition())
10518 bool HasNoEffect =
false;
10529 return (
Decl*)
nullptr;
10540 if (
auto *RD = dyn_cast<CXXRecordDecl>(
Specialization->getDeclContext()))
10541 if (RD->getIdentifier() && RD->getIdentifier()->isStr(
"valarray") &&
10542 RD->isInStdNamespace())
10543 return (
Decl*)
nullptr;
10556 Specialization->setTemplateSpecializationKind(TSK,
D.getIdentifierLoc());
10574 D.getCXXScopeSpec().isSet() &&
10576 Diag(
D.getIdentifierLoc(),
10577 diag::ext_explicit_instantiation_without_qualified_id)
10584 D.getIdentifierLoc(),
D.getCXXScopeSpec().isSet(), TSK);
10587 return (
Decl*)
nullptr;
10596 assert(Name &&
"Expected a name in a dependent tag");
10605 Diag(NameLoc, diag::err_dependent_tag_decl)
10632 if (TypenameLoc.
isValid() && S && !S->getTemplateParamParent())
10635 diag::warn_cxx98_compat_typename_outside_of_template :
10636 diag::ext_typename_outside_of_template)
10646 TypenameLoc, QualifierLoc, II, IdLoc, &TSI,
10660 if (TypenameLoc.
isValid() && S && !S->getTemplateParamParent())
10663 diag::warn_cxx98_compat_typename_outside_of_template :
10664 diag::ext_typename_outside_of_template)
10672 if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
10673 Diag(TemplateIILoc,
10674 diag::ext_out_of_line_qualified_id_type_names_constructor)
10676 << (TemplateKWLoc.
isValid() ? 1 : 0 );
10687 assert(DTN &&
"dependent template has non-dependent name?");
10690 if (!DTN->isIdentifier()) {
10691 Diag(TemplateIILoc, diag::err_template_id_not_a_type) << Template;
10698 DTN->getIdentifier(), TemplateArgs.
arguments());
10710 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
10727 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
10745 if (!II.
isStr(
"type"))
10754 if (!EnableIfTSTLoc || EnableIfTSTLoc.
getNumArgs() == 0)
10767 if (!EnableIfII || !EnableIfII->
isStr(
"enable_if"))
10795 bool DeducedTSTContext) {
10797 DeducedTSTContext);
10802 if (isa<DependentNameType>(
T)) {
10826 SS.
Adopt(QualifierLoc);
10829 if (QualifierLoc) {
10856 unsigned DiagID = 0;
10857 Decl *Referenced =
nullptr;
10858 switch (
Result.getResultKind()) {
10863 Expr *Cond =
nullptr;
10864 if (Ctx &&
isEnableIf(QualifierLoc, II, CondRange, Cond)) {
10869 std::string FailedDescription;
10870 std::tie(FailedCond, FailedDescription) =
10874 diag::err_typename_nested_not_found_requirement)
10875 << FailedDescription
10881 diag::err_typename_nested_not_found_enable_if)
10882 << Ctx << CondRange;
10886 DiagID = Ctx ? diag::err_typename_nested_not_found
10887 : diag::err_unknown_typename;
10896 Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
10897 << Name << Ctx << FullRange;
10899 = dyn_cast<UnresolvedUsingValueDecl>(
Result.getRepresentativeDecl())){
10901 Diag(
Loc, diag::note_using_value_decl_missing_typename)
10931 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(Ctx);
10932 auto *FoundRD = dyn_cast<CXXRecordDecl>(
Type);
10934 FoundRD->isInjectedClassName() &&
10936 Diag(IILoc, diag::ext_out_of_line_qualified_id_type_names_constructor)
10953 if (!DeducedTSTContext) {
10958 Diag(IILoc, diag::err_dependent_deduced_tst)
10961 Diag(IILoc, diag::err_deduced_tst)
10973 DiagID = Ctx ? diag::err_typename_nested_not_type
10974 : diag::err_typename_not_type;
10975 Referenced =
Result.getFoundDecl();
10979 DiagID = Ctx ? diag::err_typename_nested_not_type
10980 : diag::err_typename_not_type;
10981 Referenced = *
Result.begin();
10993 Diag(IILoc, DiagID) << FullRange << Name << Ctx;
10995 Diag(IILoc, DiagID) << FullRange << Name;
10998 Ctx ? diag::note_typename_member_refers_here
10999 : diag::note_typename_refers_here)
11006 class CurrentInstantiationRebuilder
11014 CurrentInstantiationRebuilder(
Sema &SemaRef,
11018 Loc(
Loc), Entity(Entity) { }
11040 this->Entity = Entity;
11056 CurrentInstantiationRebuilder Rebuilder(*
this,
Loc, Name);
11057 return Rebuilder.TransformType(
T);
11061 CurrentInstantiationRebuilder Rebuilder(*
this,
E->
getExprLoc(),
11063 return Rebuilder.TransformExpr(
E);
11074 = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
11084 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
11088 if (isa<TemplateTypeParmDecl>(Param))
11093 = dyn_cast<TemplateTemplateParmDecl>(Param)) {
11095 TTP->getTemplateParameters()))
11137 unsigned NumArgs) {
11139 llvm::raw_svector_ostream Out(Str);
11141 if (!Params || Params->
size() == 0 || NumArgs == 0)
11142 return std::string();
11144 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
11154 Out <<
Id->getName();
11166 return std::string(Out.str());
11174 auto LPT = std::make_unique<LateParsedTemplate>();
11177 LPT->Toks.swap(Toks);
11224class ExplicitSpecializationVisibilityChecker {
11236 if (
auto *FD = dyn_cast<FunctionDecl>(ND))
11237 return checkImpl(FD);
11238 if (
auto *RD = dyn_cast<CXXRecordDecl>(ND))
11239 return checkImpl(RD);
11240 if (
auto *VD = dyn_cast<VarDecl>(ND))
11241 return checkImpl(VD);
11242 if (
auto *ED = dyn_cast<EnumDecl>(ND))
11243 return checkImpl(ED);
11247 void diagnose(
NamedDecl *
D,
bool IsPartialSpec) {
11248 auto Kind = IsPartialSpec ? Sema::MissingImportKind::PartialSpecialization
11249 : Sema::MissingImportKind::ExplicitSpecialization;
11250 const bool Recover =
true;
11255 if (Modules.empty())
11261 bool CheckMemberSpecialization(
const NamedDecl *
D) {
11262 return Kind == Sema::AcceptableKind::Visible
11267 bool CheckExplicitSpecialization(
const NamedDecl *
D) {
11268 return Kind == Sema::AcceptableKind::Visible
11290 template<
typename SpecDecl>
11291 void checkImpl(SpecDecl *Spec) {
11292 bool IsHiddenExplicitSpecialization =
false;
11294 IsHiddenExplicitSpecialization = Spec->getMemberSpecializationInfo()
11295 ? !CheckMemberSpecialization(Spec)
11296 : !CheckExplicitSpecialization(Spec);
11298 checkInstantiated(Spec);
11301 if (IsHiddenExplicitSpecialization)
11302 diagnose(Spec->getMostRecentDecl(),
false);
11311 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
11315 auto From = SD->getSpecializedTemplateOrPartial();
11318 else if (
auto *TD =
11320 if (!CheckDeclaration(TD))
11321 diagnose(TD,
true);
11326 void checkInstantiated(
VarDecl *RD) {
11327 auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
11331 auto From = SD->getSpecializedTemplateOrPartial();
11334 else if (
auto *TD =
11336 if (!CheckDeclaration(TD))
11337 diagnose(TD,
true);
11342 void checkInstantiated(
EnumDecl *FD) {}
11344 template<
typename TemplDecl>
11345 void checkTemplate(TemplDecl *TD) {
11346 if (TD->isMemberSpecialization()) {
11347 if (!CheckMemberSpecialization(TD))
11348 diagnose(TD->getMostRecentDecl(),
false);
11358 ExplicitSpecializationVisibilityChecker(*
this,
Loc,
11368 ExplicitSpecializationVisibilityChecker(*
this,
Loc,
11376 if (
const auto *FD = dyn_cast<FunctionDecl>(N)) {
11384 if (!CSC.isInstantiationRecord() || CSC.PointOfInstantiation.isInvalid())
11386 return CSC.PointOfInstantiation;
Defines the clang::ASTContext interface.
Defines enum values for all the target-independent builtin functions.
enum clang::sema::@1724::IndirectLocalPathEntry::EntryKind Kind
static Decl::Kind getKind(const Decl *D)
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Record Record
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
MatchFinder::MatchResult MatchResult
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis for CUDA constructs.
static void SetNestedNameSpecifier(Sema &S, DeclaratorDecl *DD, Declarator &D)
static bool DependsOnTemplateParameters(QualType T, TemplateParameterList *Params)
Determines whether a given type depends on the given parameter list.
static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D)
Determine what kind of template specialization the given declaration is.
static Expr * BuildExpressionFromNonTypeTemplateArgumentValue(Sema &S, QualType T, const APValue &Val, SourceLocation Loc)
static void maybeDiagnoseTemplateParameterShadow(Sema &SemaRef, Scope *S, SourceLocation Loc, const IdentifierInfo *Name)
static TemplateArgumentLoc convertTypeTemplateArgumentToTemplate(ASTContext &Context, TypeLoc TLoc)
Convert a template-argument that we parsed as a type into a template, if possible.
static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized, NamedDecl *PrevDecl, SourceLocation Loc, bool IsPartialSpecialization)
Check whether a specialization is well-formed in the current context.
static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS)
Determine whether the given scope specifier has a template-id in it.
static SourceRange findTemplateParameterInType(unsigned Depth, Expr *E)
static Sema::SemaDiagnosticBuilder noteLocation(Sema &S, const NamedDecl &Decl, unsigned HereDiagID, unsigned ExternalDiagID)
static SourceRange getRangeOfTypeInNestedNameSpecifier(ASTContext &Context, QualType T, const CXXScopeSpec &SS)
static Expr * BuildExpressionFromIntegralTemplateArgumentValue(Sema &S, QualType OrigT, const llvm::APSInt &Int, SourceLocation Loc)
Construct a new expression that refers to the given integral template argument with the given source-...
static SourceRange findTemplateParameter(unsigned Depth, TypeLoc TL)
static NullPointerValueKind isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *Arg, Decl *Entity=nullptr)
Determine whether the given template argument is a null pointer value of the appropriate type.
static ExprResult formImmediatelyDeclaredConstraint(Sema &S, NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, SourceLocation LAngleLoc, SourceLocation RAngleLoc, QualType ConstrainedType, SourceLocation ParamNameLoc, ArgumentLocAppender Appender, SourceLocation EllipsisLoc)
static bool SubstDefaultTemplateArgument(Sema &SemaRef, TemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, TemplateTypeParmDecl *Param, ArrayRef< TemplateArgument > SugaredConverted, ArrayRef< TemplateArgument > CanonicalConverted, TemplateArgumentLoc &Output)
Substitute template arguments into the default template argument for the given template type paramete...
static bool CheckNonTypeTemplatePartialSpecializationArgs(Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param, const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument)
Subroutine of Sema::CheckTemplatePartialSpecializationArgs that checks non-type template partial spec...
static void StripImplicitInstantiation(NamedDecl *D, bool MinGW)
Strips various properties off an implicit instantiation that has just been explicitly specialized.
static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II, SourceRange &CondRange, Expr *&Cond)
Determine whether this failed name lookup should be treated as being disabled by a usage of std::enab...
static void DiagnoseTemplateParameterListArityMismatch(Sema &S, TemplateParameterList *New, TemplateParameterList *Old, Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc)
Diagnose a known arity mismatch when comparing template argument lists.
static bool isTemplateArgumentTemplateParameter(const TemplateArgument &Arg, unsigned Depth, unsigned Index)
static QualType builtinCommonTypeImpl(Sema &S, TemplateName BaseTemplate, SourceLocation TemplateLoc, ArrayRef< TemplateArgument > Ts)
static TemplateArgumentListInfo makeTemplateArgumentListInfo(Sema &S, TemplateIdAnnotation &TemplateId)
Convert the parser's template argument list representation into our form.
static bool CheckTemplateArgumentIsCompatibleWithParameter(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn, Expr *Arg, QualType ArgType)
Checks whether the given template argument is compatible with its template parameter.
static bool CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn, TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted)
Checks whether the given template argument is the address of an object or function according to C++ [...
static void collectConjunctionTerms(Expr *Clause, SmallVectorImpl< Expr * > &Terms)
Collect all of the separable terms in the given condition, which might be a conjunction.
static void checkMoreSpecializedThanPrimary(Sema &S, PartialSpecDecl *Partial)
static bool CheckTemplateArgumentPointerToMember(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *&ResultArg, TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted)
Checks whether the given template argument is a pointer to member constant according to C++ [temp....
static SourceLocation DiagLocForExplicitInstantiation(NamedDecl *D, SourceLocation PointOfInstantiation)
Compute the diagnostic location for an explicit instantiation.
static bool RemoveLookupResult(LookupResult &R, NamedDecl *C)
static bool isEnableIfAliasTemplate(TypeAliasTemplateDecl *AliasTemplate)
Determine whether this alias template is "enable_if_t".
static bool DiagnoseUnexpandedParameterPacks(Sema &S, TemplateTemplateParmDecl *TTP)
Check for unexpanded parameter packs within the template parameters of a template template parameter,...
static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D, SourceLocation InstLoc, bool WasQualifiedName)
Check the scope of an explicit instantiation.
static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef, const ParsedTemplateArgument &Arg)
static bool isSameAsPrimaryTemplate(TemplateParameterList *Params, ArrayRef< TemplateArgument > Args)
static void checkTemplatePartialSpecialization(Sema &S, PartialSpecDecl *Partial)
static bool CheckExplicitInstantiation(Sema &S, NamedDecl *D, SourceLocation InstLoc, bool WasQualifiedName, TemplateSpecializationKind TSK)
Common checks for whether an explicit instantiation of D is valid.
static Expr * lookThroughRangesV3Condition(Preprocessor &PP, Expr *Cond)
static bool DiagnoseDefaultTemplateArgument(Sema &S, Sema::TemplateParamListContext TPC, SourceLocation ParamLoc, SourceRange DefArgRange)
Diagnose the presence of a default template argument on a template parameter, which is ill-formed in ...
static QualType checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD, ArrayRef< TemplateArgument > Converted, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
static void noteNonDeducibleParameters(Sema &S, TemplateParameterList *TemplateParams, const llvm::SmallBitVector &DeducibleParams)
static void completeMemberSpecializationImpl(Sema &S, DeclT *OrigD, SourceLocation Loc)
Complete the explicit specialization of a member of a class template by updating the instantiated mem...
static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc, TemplateDecl *TD, const TemplateParmDecl *D, TemplateArgumentListInfo &Args)
Diagnose a missing template argument.
static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, const Sema::TemplateCompareNewDeclInfo &NewInstFrom, NamedDecl *Old, const NamedDecl *OldInstFrom, bool Complain, Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc)
Match two template parameters within template parameter lists.
static void dllExportImportClassTemplateSpecialization(Sema &S, ClassTemplateSpecializationDecl *Def)
Make a dllexport or dllimport attr on a class template specialization take effect.
Defines the clang::SourceLocation class and associated facilities.
static const TemplateArgument & getArgument(const TemplateArgument &A)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
const LValueBase getLValueBase() const
APSInt & getComplexIntImag()
ValueKind getKind() const
APFixedPoint & getFixedPoint()
const ValueDecl * getMemberPointerDecl() const
APValue & getVectorElt(unsigned I)
unsigned getVectorLength() const
bool isMemberPointer() const
std::string getAsString(const ASTContext &Ctx, QualType Ty) const
@ Indeterminate
This object has an indeterminate value (C++ [basic.indet]).
@ None
There is no such object (it's outside its lifetime).
bool isNullPointer() const
APSInt & getComplexIntReal()
APFloat & getComplexFloatImag()
APFloat & getComplexFloatReal()
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
unsigned getIntWidth(QualType T) const
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, ArrayRef< TemplateArgumentLoc > Args) const
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
DeclarationNameTable DeclarationNames
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
TemplateName getCanonicalTemplateName(TemplateName Name, bool IgnoreDeduced=false) const
Retrieves the "canonical" template name that refers to a given template.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
const LangOptions & getLangOpts() const
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
QualType getCanonicalTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args) const
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
CanQualType UnresolvedTemplateTy
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
bool isSameEntity(const NamedDecl *X, const NamedDecl *Y) const
Determine whether the two declarations refer to the same entity.
TypeSourceInfo * getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc, const TemplateArgumentListInfo &Args, QualType Canon=QualType()) const
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS, const IdentifierInfo *Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template apply.
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
bool hasSimilarType(QualType T1, QualType T2) const
Determine if two types are similar, according to the C++ rules.
const TargetInfo & getTargetInfo() const
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
QualType getUnconstrainedType(QualType T) const
Remove any type constraints from a template parameter type, for equivalence comparison of template pa...
void setPrimaryMergedDecl(Decl *D, Decl *Primary)
TemplateName getAssumedTemplateName(DeclarationName Name) const
Retrieve a template name representing an unqualified-id that has been assumed to name a template for ...
Represents a constant array type that does not decay to a pointer when used as a function parameter.
A structure for storing the information associated with a name that has been assumed to be a template...
DeclarationName getDeclName() const
Get the name of the template.
Attr - This represents one attribute.
AutoTypeKeyword getAutoKeyword() const
const NestedNameSpecifierLoc getNestedNameSpecifierLoc() const
SourceLocation getRAngleLoc() const
ConceptDecl * getNamedConcept() const
SourceLocation getLAngleLoc() const
NamedDecl * getFoundDecl() const
DeclarationNameInfo getConceptNameInfo() const
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
bool isDecltypeAuto() const
A fixed int type of a specified bitwidth.
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
BuiltinTemplateKind getBuiltinTemplateKind() const
This class is used for builtin types like 'int'.
static CStyleCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *BasePath, FPOptionsOverride FPO, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R)
static CXXBoolLiteralExpr * Create(const ASTContext &C, bool Val, QualType Ty, SourceLocation Loc)
Represents a C++ member access expression where the actual member referenced could not be resolved be...
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents a static or instance method of a struct/union/class.
The null pointer literal (C++11 [lex.nullptr])
Represents a C++ struct/union/class.
CXXRecordDecl * getMostRecentDecl()
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
CXXRecordDecl * getDefinition() const
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
void setDescribedClassTemplate(ClassTemplateDecl *Template)
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization,...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
CXXRecordDecl * getPreviousDecl()
Represents a C++ nested-name-specifier or a global scope specifier.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
char * location_data() const
Retrieve the data associated with the source-location information.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
SourceRange getRange() const
SourceLocation getBeginLoc() const
bool isSet() const
Deprecated.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
bool isEmpty() const
No scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Declaration of a class template.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a class template node.
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template.
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
static ClassTemplatePartialSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, QualType CanonInjectedType, ClassTemplatePartialSpecializationDecl *PrevDecl)
void setMemberSpecialization()
Note that this member template is a specialization.
Represents a class template specialization, which refers to a class template with a given set of temp...
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)
Set the template argument list as written in the sources.
Complex values, per C99 6.2.5p11.
Declaration of a C++20 concept.
Expr * getConstraintExpr() const
bool isTypeConcept() const
ConceptDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
static ConceptDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, Expr *ConstraintExpr=nullptr)
static ConceptReference * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten)
static ConceptSpecializationExpr * Create(const ASTContext &C, ConceptReference *ConceptRef, ImplicitConceptSpecializationDecl *SpecDecl, const ConstraintSatisfaction *Satisfaction)
const TypeClass * getTypePtr() const
Represents the canonical version of C arrays with a specified constant size.
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
Represents a concrete matrix type with constant number of rows and columns.
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isFileContext() const
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
bool isTransparentContext() const
isTransparentContext - Determines whether this context is a "transparent" context,...
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const
Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...
bool isTranslationUnit() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void addDecl(Decl *D)
Add the declaration D into this context.
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
bool isFunctionOrMethod() const
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
A reference to a declared variable, function, enum, etc.
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
Captures information about "declaration specifiers".
bool isVirtualSpecified() const
bool isNoreturnSpecified() const
SourceLocation getStorageClassSpecLoc() const
SCS getStorageClassSpec() const
SourceLocation getNoreturnSpecLoc() const
SourceLocation getExplicitSpecLoc() const
TSCS getThreadStorageClassSpec() const
bool isInlineSpecified() const
SourceLocation getThreadStorageClassSpecLoc() const
SourceLocation getVirtualSpecLoc() const
SourceLocation getConstexprSpecLoc() const
SourceLocation getInlineSpecLoc() const
bool hasExplicitSpecifier() const
bool hasConstexprSpecifier() const
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
bool isParameterPack() const
Whether this declaration is a parameter pack.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
@ FOK_None
Not a friend object.
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Module * getImportedOwningModule() const
Get the imported owning module, if this decl is from an imported (non-local) module.
static DeclContext * castToDeclContext(const Decl *)
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it's the object of a friend declaration.
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
bool isInvalidDecl() const
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack.
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
SourceLocation getBeginLoc() const LLVM_READONLY
void print(raw_ostream &Out, unsigned Indentation=0, bool PrintInstantiation=false) const
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
void setLexicalDeclContext(DeclContext *DC)
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
The name of a declaration.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
std::string getAsString() const
Retrieve the human-readable string for this name.
void setTypeSourceInfo(TypeSourceInfo *TI)
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
Represents the type decltype(expr) (C++11).
Represents a C++17 deduced template specialization type.
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Represents an extended address space qualifier where the input address space value is dependent.
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Represents a qualified type name for which the type name is dependent.
A qualified reference to a name whose declaration cannot yet be resolved.
static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents an array type in C++ whose size is a value-dependent expression.
Represents an extended vector type where either the type or size is dependent.
Represents a matrix type where the type and the number of rows and columns is dependent on a template...
Represents a dependent template name that cannot be resolved prior to template instantiation.
bool isIdentifier() const
Determine whether this template name refers to an identifier.
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
unsigned getNumArgs() const
void setTemplateKeywordLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void setLAngleLoc(SourceLocation Loc)
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateNameLoc(SourceLocation Loc)
Represents a template specialization type whose template cannot be resolved, e.g.
Represents a vector type where either the type or size is dependent.
Recursive AST visitor that supports extension via dynamic dispatch.
virtual bool TraverseTypeLoc(TypeLoc TL)
Recursively visit a type with location, by dispatching to Traverse*TypeLoc() based on the argument ty...
virtual bool TraverseStmt(Stmt *S)
Recursively visit a statement or expression, by dispatching to Traverse*() based on the argument's dy...
virtual bool TraverseTemplateName(TemplateName Template)
Recursively visit a template name and dispatch to the appropriate method.
void setElaboratedKeywordLoc(SourceLocation Loc)
TypeLoc getNamedTypeLoc() const
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
RAII object that enters a new expression evaluation context.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
This represents one expression.
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
@ NPC_NeverValueDependent
Specifies that the expression should never be value-dependent.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
ExtVectorType - Extended vector type.
Represents a member of a struct/union/class.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
static FixedPointLiteral * CreateFromRawInt(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l, unsigned Scale)
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, SourceLocation EllipsisLoc={}, ArrayRef< TemplateParameterList * > FriendTypeTPLists={})
Represents a function declaration or definition.
ConstexprSpecKind getConstexprKind() const
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
SourceLocation getPointOfInstantiation() const
Retrieve the (first) point of instantiation of a function template specialization or a member of a cl...
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization,...
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isDeleted() const
Whether this function has been deleted.
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
void setDependentTemplateSpecialization(ASTContext &Context, const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo *TemplateArgs)
Specifies that this function declaration is actually a dependent function template specialization.
void setLateTemplateParsed(bool ILT=true)
State that this templated function will be late parsed.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization,...
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
Represents a prototype with parameter type info, e.g.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
ArrayRef< QualType > param_types() const
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Provides information about a function template specialization, which is a FunctionDecl that has been ...
bool isExplicitSpecialization() const
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this function template specialization.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
QualType getReturnType() const
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
StringRef getName() const
Return the actual identifier string.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitConceptSpecializationDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation SL, ArrayRef< TemplateArgument > ConvertedArgs)
Represents a C array with an unspecified size.
const TypeClass * getTypePtr() const
Describes an C or C++ initializer list.
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init)
Create an initialization from an initializer (which, for direct initialization from a parenthesized l...
Describes the sequence of initializations required to initialize a given object or reference with a s...
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
Describes an entity that is being initialized.
static InitializedEntity InitializeTemplateParameter(QualType T, NonTypeTemplateParmDecl *Param)
Create the initialization entity for a template parameter.
Wrapper for source info for injected class names of class templates.
The injected class name of a C++ class template or class template partial specialization.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
An lvalue reference type, per C++11 [dcl.ref].
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Represents a linkage specification.
A stack-allocated class that identifies which local variable declaration instantiations are present i...
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
A class for iterating through a result set and possibly filtering out results.
void erase()
Erase the last element returned from this iterator.
Represents the results of name lookup.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
@ NotFound
No entity found met the criteria.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
@ Found
Name lookup found a single declaration that met the criteria.
bool wasNotFoundInCurrentInstantiation() const
Determine whether no result was found because we could not search into dependent base classes of the ...
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
void setTemplateNameLookup(bool TemplateName)
Sets whether this is a template-name lookup.
DeclClass * getAsSingle() const
bool empty() const
Return true if no decls were found.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Filter makeFilter()
Create a filter for this result set.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
CXXRecordDecl * getNamingClass() const
Returns the 'naming class' for this lookup, i.e.
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
A pointer to member type per C++ 8.3.3 - Pointers to members.
QualType getPointeeType() const
Provides information a specialization of a member of a class template, which may be a member function...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Data structure that captures multiple levels of template argument lists for use in template instantia...
const ArgList & getInnermost() const
Retrieve the innermost template argument list.
void addOuterTemplateArguments(Decl *AssociatedDecl, ArgList Args, bool Final)
Add a new outmost level to the multi-level template argument list.
void addOuterRetainedLevels(unsigned Num)
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
NamedDecl * getMostRecentDecl()
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined.
bool hasLinkage() const
Determine whether this declaration has linkage.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
SourceLocation getDefaultArgumentLoc() const
Retrieve the location of the default argument, if any.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
unsigned getDepth() const
Get the nesting depth of the template parameter.
void setPlaceholderTypeConstraint(Expr *E)
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
Interfaces are the core concept in Objective-C for object oriented design.
Represents a pointer to an Objective C object.
Represents a class type in Objective C.
static OpaquePtr make(TemplateName P)
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
@ CSK_Normal
Normal lookup.
SmallVectorImpl< OverloadCandidate >::iterator iterator
void NoteCandidates(PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
When overload resolution fails, prints diagnostic messages containing the candidates in the candidate...
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
OverloadCandidate & addCandidate(unsigned NumConversions=0, ConversionSequenceList Conversions={})
Add a new candidate with NumConversions conversion sequence slots to the overload set.
A structure for storing the information associated with an overloaded template name.
NamedDecl *const * iterator
Represents a C++11 pack expansion that produces a sequence of expressions.
Represents a pack expansion of types.
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
ParenExpr - This represents a parenthesized expression, e.g.
ParsedAttr - Represents a syntactic attribute.
Represents the parsed form of a C++ template argument.
KindType getKind() const
Determine what kind of template argument we have.
SourceLocation getLocation() const
Retrieve the location of the template argument.
ParsedTemplateTy getAsTemplate() const
Retrieve the template template argument's template name.
ParsedTemplateArgument getTemplatePackExpansion(SourceLocation EllipsisLoc) const
Retrieve a pack expansion of the given template template argument.
ParsedType getAsType() const
Retrieve the template type argument's type.
@ Type
A template type parameter, stored as a type.
@ Template
A template template argument, stored as a template name.
@ NonType
A non-type template parameter, stored as an expression.
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis that makes a template template argument into a pack expansion.
Expr * getAsExpr() const
Retrieve the non-type template argument's expression.
const CXXScopeSpec & getScopeSpec() const
Retrieve the nested-name-specifier that precedes the template name in a template template argument.
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
StringRef getImmediateMacroName(SourceLocation Loc)
Retrieve the name of the immediate macro expansion.
A (possibly-)qualified type.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
void addConst()
Add the const type qualifier to this QualType.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
void * getAsOpaquePtr() const
QualType getNonPackExpansionType() const
Remove an outer pack expansion type (if any) from this type.
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
The collection of all-type qualifiers we support.
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
void setObjCLifetime(ObjCLifetime type)
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
Wrapper for source info for record types.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
void setMemberSpecialization()
Note that this member template is a specialization.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
Scope - A scope is a transient data structure that is used while parsing the program.
unsigned getFlags() const
getFlags - Return the flags for this scope.
const Scope * getParent() const
getParent - Return the scope that this is nested in.
@ TemplateParamScope
This is a scope that corresponds to the template parameters of a C++ template.
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
void inheritTargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD)
Copies target attributes from the template TD to the function FD.
RAII object used to change the argument pack substitution index within a Sema object.
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
Whether and why a template name is required in this lookup.
SourceLocation getTemplateKeywordLoc() const
bool hasTemplateKeyword() const
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Abstract base class used for diagnosing integer constant expression violations.
Sema - This implements semantic analysis and AST building for C.
bool hasReachableDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a reachable definition.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
VarTemplateSpecializationDecl * BuildVarTemplateInstantiation(VarTemplateDecl *VarTemplate, VarDecl *FromVar, const TemplateArgumentList *PartialSpecArgs, const TemplateArgumentListInfo &TemplateArgsInfo, SmallVectorImpl< TemplateArgument > &Converted, SourceLocation PointOfInstantiation, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *StartingScope=nullptr)
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
DeclResult ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, SourceLocation ModulePrivateLoc, CXXScopeSpec &SS, TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr, MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody=nullptr)
ConceptDecl * ActOnStartConceptDefinition(Scope *S, MultiTemplateParamsArg TemplateParameterLists, const IdentifierInfo *Name, SourceLocation NameLoc)
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
sema::CapturingScopeInfo * getEnclosingLambdaOrBlock() const
Get the innermost lambda or block enclosing the current location, if any.
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.
bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false) const
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
LookupNameKind
Describes the kind of name lookup to perform.
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
ExprResult ActOnConstantExpression(ExprResult Res)
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
bool LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, RequiredTemplateKind RequiredTemplate=SourceLocation(), AssumedTemplateKind *ATK=nullptr, bool AllowTypoCorrection=true)
bool SetMemberAccessSpecifier(NamedDecl *MemberDecl, NamedDecl *PrevMemberDecl, AccessSpecifier LexicalAS)
SetMemberAccessSpecifier - Set the access specifier of a member.
bool BuildTypeConstraint(const CXXScopeSpec &SS, TemplateIdAnnotation *TypeConstraint, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc, bool AllowUnexpandedPack)
bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc, TemplateIdAnnotation *TemplateId, bool IsMemberSpecialization)
Diagnose a declaration whose declarator-id has the given nested-name-specifier.
TemplateParameterList * ActOnTemplateParameterList(unsigned Depth, SourceLocation ExportLoc, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
ActOnTemplateParameterList - Builds a TemplateParameterList, optionally constrained by RequiresClause...
TypeResult ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, const IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false, bool IsClassName=false, ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No)
NamedDecl * ActOnTemplateTemplateParameter(Scope *S, SourceLocation TmpLoc, TemplateParameterList *Params, bool Typename, SourceLocation EllipsisLoc, IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth, unsigned Position, SourceLocation EqualLoc, ParsedTemplateArgument DefaultArg)
ActOnTemplateTemplateParameter - Called when a C++ template template parameter (e....
bool ActOnTypeConstraint(const CXXScopeSpec &SS, TemplateIdAnnotation *TypeConstraint, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
bool hasVisibleDeclaration(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine whether any declaration of an entity is visible.
bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info)
DiagnoseClassNameShadow - Implement C++ [class.mem]p13: If T is the name of a class,...
void NoteAllFoundTemplates(TemplateName Name)
bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation, NamedDecl *Instantiation, bool InstantiatedFromMember, const NamedDecl *Pattern, const NamedDecl *PatternDef, TemplateSpecializationKind TSK, bool Complain=true)
Determine whether we would be unable to instantiate this template (because it either has no definitio...
TypeResult ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK, const CXXScopeSpec &SS, const IdentifierInfo *Name, SourceLocation TagLoc, SourceLocation NameLoc)
TemplateDecl * AdjustDeclIfTemplate(Decl *&Decl)
AdjustDeclIfTemplate - If the given decl happens to be a template, reset the parameter D to reference...
void InstantiateClassTemplateSpecializationMembers(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK)
Instantiate the definitions of all of the members of the given class template specialization,...
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
bool TemplateParameterListsAreEqual(const TemplateCompareNewDeclInfo &NewInstFrom, TemplateParameterList *New, const NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
TemplateArgumentLoc SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, Decl *Param, ArrayRef< TemplateArgument > SugaredConverted, ArrayRef< TemplateArgument > CanonicalConverted, bool &HasDefaultArg)
If the given template parameter has a default template argument, substitute into that default templat...
ExprResult RebuildExprInCurrentInstantiation(Expr *E)
DeclResult ActOnVarTemplateSpecialization(Scope *S, Declarator &D, TypeSourceInfo *DI, LookupResult &Previous, SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams, StorageClass SC, bool IsPartialSpecialization)
ClassTemplatePartialSpecializationDecl * getMoreSpecializedPartialSpecialization(ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc)
Returns the more specialized class template partial specialization according to the rules of partial ...
FunctionDecl * getMoreConstrainedFunction(FunctionDecl *FD1, FunctionDecl *FD2)
Returns the more constrained function according to the rules of partial ordering by constraints (C++ ...
void referenceDLLExportedClassMethods()
static NamedDecl * getAsTemplateNameDecl(NamedDecl *D, bool AllowFunctionTemplates=true, bool AllowDependent=true)
Try to interpret the lookup result D as a template-name.
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
TemplateParameterList * MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, ArrayRef< TemplateParameterList * > ParamLists, bool IsFriend, bool &IsMemberSpecialization, bool &Invalid, bool SuppressDiagnostic=false)
Match the given template parameter lists to the given scope specifier, returning the template paramet...
void AddAlignmentAttributesForRecord(RecordDecl *RD)
AddAlignmentAttributesForRecord - Adds any needed alignment attributes to a the record decl,...
bool RequireStructuralType(QualType T, SourceLocation Loc)
Require the given type to be a structural type, and diagnose if it is not.
ExprResult EvaluateConvertedConstantExpression(Expr *E, QualType T, APValue &Value, CCEKind CCE, bool RequireInt, const APValue &PreNarrowingValue)
EvaluateConvertedConstantExpression - Evaluate an Expression That is a converted constant expression ...
ConceptDecl * ActOnFinishConceptDefinition(Scope *S, ConceptDecl *C, Expr *ConstraintExpr, const ParsedAttributesView &Attrs)
FPOptionsOverride CurFPFeatureOverrides()
ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, bool isAddressOfOperand, const TemplateArgumentListInfo *TemplateArgs)
ActOnDependentIdExpression - Handle a dependent id-expression that was just parsed.
bool hasVisibleExplicitSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a visible declaration of D that is an explicit specialization declaration for a...
bool IsInsideALocalClassWithinATemplateFunction()
Decl * ActOnTemplateDeclarator(Scope *S, MultiTemplateParamsArg TemplateParameterLists, Declarator &D)
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Look up a name, looking for a single declaration.
bool CheckConceptUseInDefinition(ConceptDecl *Concept, SourceLocation Loc)
LateParsedTemplateMapT LateParsedTemplateMap
void UnmarkAsLateParsedTemplate(FunctionDecl *FD)
CheckTemplateArgumentKind
Specifies the context in which a particular template argument is being checked.
@ CTAK_Specified
The template argument was specified in the code or was instantiated with some deduced template argume...
@ CTAK_Deduced
The template argument was deduced via template argument deduction.
void CheckTemplatePartialSpecialization(ClassTemplatePartialSpecializationDecl *Partial)
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization, bool Disambiguation=false)
ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType)
Convert a parsed type into a parsed template argument.
bool DiagnoseUnknownTemplateName(const IdentifierInfo &II, SourceLocation IILoc, Scope *S, const CXXScopeSpec *SS, TemplateTy &SuggestedTemplate, TemplateNameKind &SuggestedKind)
bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)
IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...
bool ConstraintExpressionDependsOnEnclosingTemplate(const FunctionDecl *Friend, unsigned TemplateDepth, const Expr *Constraint)
bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc, TemplateDecl *PrimaryTemplate, unsigned NumExplicitArgs, ArrayRef< TemplateArgument > Args)
Check the non-type template arguments of a class template partial specialization according to C++ [te...
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
DiagnosticsEngine & getDiagnostics() const
ExprResult BuildExpressionFromNonTypeTemplateArgument(const TemplateArgument &Arg, SourceLocation Loc)
void propagateDLLAttrToBaseClassTemplate(CXXRecordDecl *Class, Attr *ClassAttr, ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc)
Perform propagation of DLL attributes from a derived class to a templated base class for MS compatibi...
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over....
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
void checkSpecializationReachability(SourceLocation Loc, NamedDecl *Spec)
bool hasVisibleDefaultArgument(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if the template parameter D has a visible default argument.
ASTContext & getASTContext() const
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
UnresolvedSetIterator getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd, TemplateSpecCandidateSet &FailedCandidates, SourceLocation Loc, const PartialDiagnostic &NoneDiag, const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag, bool Complain=true, QualType TargetType=QualType())
Retrieve the most specialized of the given function template specializations.
bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
IsIntegralPromotion - Determines whether the conversion from the expression From (whose potentially-a...
TypeSourceInfo * SubstType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, bool AllowDeducedTST=false)
Perform substitution on the type T with a given set of template arguments.
bool IsRedefinitionInModule(const NamedDecl *New, const NamedDecl *Old) const
Check the redefinition in C++20 Modules.
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param, TemplateParameterList *Params, TemplateArgumentLoc &Arg, bool IsDeduced)
Check a template argument against its corresponding template template parameter.
TemplateParameterList * GetTemplateParameterList(TemplateDecl *TD)
Returns the template parameter list with all default template argument information.
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD, CachedTokens &Toks)
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)
Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
TemplateParameterListEqualKind
Enumeration describing how template parameter lists are compared for equality.
@ TPL_TemplateTemplateParmMatch
We are matching the template parameter lists of two template template parameters as part of matching ...
@ TPL_TemplateTemplateArgumentMatch
We are matching the template parameter lists of a template template argument against the template par...
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
@ TPL_TemplateParamsEquivalent
We are determining whether the template-parameters are equivalent according to C++ [temp....
NamedDecl * ActOnTypeParameter(Scope *S, bool Typename, SourceLocation EllipsisLoc, SourceLocation KeyLoc, IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth, unsigned Position, SourceLocation EqualLoc, ParsedType DefaultArg, bool HasTypeConstraint)
ActOnTypeParameter - Called when a C++ template type parameter (e.g., "typename T") has been parsed.
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend=false)
Perform semantic analysis for the given function template specialization.
@ FoundFunctions
This is assumed to be a template name because lookup found one or more functions (but no function tem...
@ None
This is not assumed to be a template name.
@ FoundNothing
This is assumed to be a template name because lookup found nothing.
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true)
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
ArrayRef< InventedTemplateParameterInfo > getInventedParameterInfos() const
void inferGslOwnerPointerAttribute(CXXRecordDecl *Record)
Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
FPOptions & getCurFPFeatures()
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template, const MultiLevelTemplateArgumentList &TemplateArgs, SourceRange TemplateIDRange)
Ensure that the given template arguments satisfy the constraints associated with the given template,...
@ UPPC_PartialSpecialization
Partial specialization.
@ UPPC_DefaultArgument
A default argument.
@ UPPC_ExplicitSpecialization
Explicit specialization.
@ UPPC_NonTypeTemplateParameterType
The type of a non-type template parameter.
@ UPPC_TypeConstraint
A type constraint.
const LangOptions & getLangOpts() const
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl, bool SupportedForCompatibility=false)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter 'PrevD...
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...
bool RebuildTemplateParamsInCurrentInstantiation(TemplateParameterList *Params)
Rebuild the template parameters now that we know we're in a current instantiation.
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, QualType ConstrainedType, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
void EnterTemplatedContext(Scope *S, DeclContext *DC)
Enter a template parameter scope, after it's been associated with a particular DeclContext.
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, QualType ObjectType, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee, SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, std::optional< unsigned > NumExpansions)
bool isPotentialImplicitMemberAccess(const CXXScopeSpec &SS, LookupResult &R, bool IsAddressOfOperand)
Check whether an expression might be an implicit class member access.
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool hasVisibleMemberSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a visible declaration of D that is a member specialization declaration (as oppo...
void checkClassLevelDLLAttribute(CXXRecordDecl *Class)
Check class-level dllimport/dllexport attribute.
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
const LangOptions & LangOpts
void InstantiateClassMembers(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiates the definitions of all of the member of the given class, which is an instantiation of a ...
std::pair< Expr *, std::string > findFailedBooleanCondition(Expr *Cond)
Find the failed Boolean condition within a given Boolean constant expression, and describe it with a ...
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
bool hasAnyAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true, bool AllowNonTemplateFunctions=false)
ExprResult BuildConvertedConstantExpression(Expr *From, QualType T, CCEKind CCE, NamedDecl *Dest=nullptr)
bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD, const TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous)
Perform semantic analysis for the given dependent function template specialization.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
bool hasExplicitCallingConv(QualType T)
NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK)
Given a non-tag type declaration, returns an enum useful for indicating what kind of non-tag type thi...
bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, TemplateArgumentLoc &Arg, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted)
bool AreConstraintExpressionsEqual(const NamedDecl *Old, const Expr *OldConstr, const TemplateCompareNewDeclInfo &New, const Expr *NewConstr)
void AddPushedVisibilityAttribute(Decl *RD)
AddPushedVisibilityAttribute - If '#pragma GCC visibility' was used, add an appropriate visibility at...
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1, ArrayRef< const Expr * > AC1, NamedDecl *D2, ArrayRef< const Expr * > AC2)
If D1 was not at least as constrained as D2, but would've been if a pair of atomic constraints involv...
ExprResult DefaultLvalueConversion(Expr *E)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
void NoteOverloadCandidate(const NamedDecl *Found, const FunctionDecl *Fn, OverloadCandidateRewriteKind RewriteKind=OverloadCandidateRewriteKind(), QualType DestType=QualType(), bool TakingAddress=false)
bool hasReachableDefaultArgument(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if the template parameter D has a reachable default argument.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false, bool ForDefaultArgumentSubstitution=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
TypeSourceInfo * RebuildTypeInCurrentInstantiation(TypeSourceInfo *T, SourceLocation Loc, DeclarationName Name)
Rebuilds a type within the context of the current instantiation.
QualType BuiltinDecay(QualType BaseType, SourceLocation Loc)
void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)
Check whether the given function decl's trailing requires clause is satisfied, if any.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
void notePreviousDefinition(const NamedDecl *Old, SourceLocation New)
bool CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, TemplateSpecializationKind ActOnExplicitInstantiationNewTSK, NamedDecl *PrevDecl, TemplateSpecializationKind PrevTSK, SourceLocation PrevPtOfInstantiation, bool &SuppressNew)
Diagnose cases where we have an explicit template specialization before/after an explicit template in...
bool CheckTypeConstraint(TemplateIdAnnotation *TypeConstraint)
TemplateNameKind ActOnTemplateName(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool AllowInjectedClassName=false)
Form a template name from a name that is syntactically required to name a template,...
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName, SourceLocation Less, SourceLocation Greater)
ExprResult FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
DeclResult CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation TemplateNameLoc, const TemplateArgumentListInfo &TemplateArgs)
Get the specialization of the given variable template corresponding to the specified argument list,...
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI, SourceLocation Loc)
Check that the type of a non-type template parameter is well-formed.
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
void diagnoseMissingImport(SourceLocation Loc, const 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...
void FilterAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true)
TypeSourceInfo * SubstAutoTypeSourceInfoDependent(TypeSourceInfo *TypeWithAuto)
bool IsAtLeastAsConstrained(NamedDecl *D1, MutableArrayRef< const Expr * > AC1, NamedDecl *D2, MutableArrayRef< const Expr * > AC2, bool &Result)
Check whether the given declaration's associated constraints are at least as constrained than another...
bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams)
Check whether a template can be declared within this scope.
void AddMsStructLayoutForRecord(RecordDecl *RD)
AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
TemplateParameterList * SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs, bool EvaluateConstraints=true)
SourceLocation getTopMostPointOfInstantiation(const NamedDecl *) const
Returns the top most location responsible for the definition of N.
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg, SourceLocation EllipsisLoc)
Invoked when parsing a template argument followed by an ellipsis, which creates a pack expansion.
void ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &Name, TemplateNameKind &TNK, SourceLocation NameLoc, IdentifierInfo *&II)
Try to resolve an undeclared template name as a type template.
bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
Perform semantic analysis for the given non-template member specialization.
TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc, ImplicitTypenameContext IsImplicitTypename=ImplicitTypenameContext::No)
Called when the parser has parsed a C++ typename specifier, e.g., "typename T::type".
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)
Instantiate the definition of a class from a given pattern.
bool hasReachableMemberSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a reachable declaration of D that is a member specialization declaration (as op...
RedeclarationKind forRedeclarationInCurContext() const
bool SubstTemplateArgument(const TemplateArgumentLoc &Input, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentLoc &Output, SourceLocation Loc={}, const DeclarationName &Entity={})
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given function from its template.
@ CCEK_TemplateArg
Value of a non-type template parameter.
void InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
void MarkUnusedFileScopedDecl(const DeclaratorDecl *D)
If it's a file scoped decl that must warn if not used, keep track of it.
ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, bool IsAddressOfOperand)
void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used)
Mark which template parameters are used in a given expression.
DeclResult ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy Template, SourceLocation TemplateNameLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, const ParsedAttributesView &Attr)
QualType CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc)
Note that LHS is not null here, even if this is the gnu "x ?: y" extension.
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
QualType BuildDecltypeType(Expr *E, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
DeclResult ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, OffsetOfKind OOK, SkipBodyInfo *SkipBody=nullptr)
This is invoked when we see 'struct foo' or 'struct {'.
bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, CheckTemplateArgumentKind CTAK)
Check that the given template argument corresponds to the given template parameter.
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, const DefaultArguments &DefaultArgs, bool PartialTemplateArgs, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, bool UpdateArgsWithConversions=true, bool *ConstraintsNotSatisfied=nullptr, bool PartialOrderingTTP=false)
Check that the given template arguments can be provided to the given template, converting the argumen...
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
void makeMergedDefinitionVisible(NamedDecl *ND)
Make a merged definition of an existing hidden definition ND visible at the specified location.
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
bool hasReachableExplicitSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a reachable declaration of D that is an explicit specialization declaration for...
bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name, SourceLocation NameLoc, CXXScopeSpec &SS, ParsedTemplateTy *Template=nullptr)
Determine whether a particular identifier might be the name in a C++1z deduction-guide declaration.
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
NamedDecl * ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, unsigned Depth, unsigned Position, SourceLocation EqualLoc, Expr *DefaultArg)
void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc)
void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D)
Common checks for a parameter-declaration that should apply to both function parameters and non-type ...
TemplateParamListContext
The context in which we are checking a template parameter list.
@ TPC_FriendFunctionTemplate
@ TPC_ClassTemplateMember
@ TPC_FriendClassTemplate
@ TPC_FriendFunctionTemplateDefinition
void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We've found a use of a templated declaration that would trigger an implicit instantiation.
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope.
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, ArrayRef< TemplateArgument > TemplateArgs, sema::TemplateDeductionInfo &Info)
bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name, SourceLocation NameLoc, bool Diagnose=true)
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope.
ExprResult CheckConceptTemplateId(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const TemplateArgumentListInfo *TemplateArgs)
void CheckConceptRedefinition(ConceptDecl *NewDecl, LookupResult &Previous, bool &AddToScope)
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC, SkipBodyInfo *SkipBody=nullptr)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T, sema::TemplateDeductionInfo &Info)
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
bool isTemplateTemplateParameterAtLeastAsSpecializedAs(TemplateParameterList *PParam, TemplateDecl *AArg, const DefaultArguments &DefaultArgs, SourceLocation Loc, bool IsDeduced)
void ProcessAPINotes(Decl *D)
Map any API notes provided for this declaration to attributes on the declaration.
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments.
bool CheckRedeclarationInModule(NamedDecl *New, NamedDecl *Old)
A wrapper function for checking the semantic restrictions of a redeclaration within a module.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
unsigned getTemplateDepth(Scope *S) const
Determine the number of levels of enclosing template parameters.
ExprResult BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, QualType ParamType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Given a non-type template argument that refers to a declaration and the type of its corresponding non...
TemplateDeductionResult DeduceAutoType(TypeLoc AutoTypeLoc, Expr *Initializer, QualType &Result, sema::TemplateDeductionInfo &Info, bool DependentDeduction=false, bool IgnoreConstraints=false, TemplateSpecCandidateSet *FailedTSC=nullptr)
Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, bool AdjustExceptionSpec=false)
Adjust the type ArgFunctionType to match the calling convention, noreturn, and optionally the excepti...
void NoteTemplateParameterLocation(const NamedDecl &Decl)
IdentifierResolver IdResolver
ArrayRef< sema::FunctionScopeInfo * > getFunctionScopes() const
void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD)
bool IsFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy)
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
TypeResult ActOnTagTemplateIdType(TagUseKind TUK, TypeSpecifierType TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy TemplateD, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc)
Parsed an elaborated-type-specifier that refers to a template-id, such as class T::template apply.
bool hasReachableDeclaration(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine whether any declaration of an entity is reachable.
void MarkDeducedTemplateParameters(const FunctionTemplateDecl *FunctionTemplate, llvm::SmallBitVector &Deduced)
bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc, UnexpandedParameterPackContext UPPC, ArrayRef< UnexpandedParameterPack > Unexpanded)
Diagnose unexpanded parameter packs.
void warnOnReservedIdentifier(const NamedDecl *D)
void inferNullableClassAttribute(CXXRecordDecl *CRD)
Add _Nullable attributes for std:: types.
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Represents the result of substituting a set of types for a template type parameter pack.
Represents the result of substituting a type for a template type parameter.
Represents the declaration of a struct/union/class/enum.
StringRef getKindName() const
void startDefinition()
Starts the definition of this tag declaration.
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
TagKind getTagKind() const
bool isBeingDefined() const
Determines whether this type is in the process of being defined.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
A convenient class for passing around template argument information.
SourceLocation getRAngleLoc() const
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void addArgument(const TemplateArgumentLoc &Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
SourceLocation getLAngleLoc() const
A template argument list.
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Location wrapper for a TemplateArgument.
SourceLocation getLocation() const
SourceLocation getTemplateEllipsisLoc() const
const TemplateArgument & getArgument() const
SourceLocation getTemplateNameLoc() const
TypeSourceInfo * getTypeSourceInfo() const
SourceRange getSourceRange() const LLVM_READONLY
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Expr * getSourceExpression() const
Represents a template argument.
QualType getStructuralValueType() const
Get the type of a StructuralValue.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
bool isDependent() const
Whether this template argument is dependent on a template parameter such that its result can change f...
bool isInstantiationDependent() const
Whether this template argument is dependent on a template parameter.
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
QualType getNonTypeTemplateArgumentType() const
If this is a non-type template argument, get its type.
QualType getAsType() const
Retrieve the type for a type template argument.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
static TemplateArgument CreatePackCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument pack by copying the given set of template arguments.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
bool isNull() const
Determine whether this template argument has no value.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
void print(const PrintingPolicy &Policy, raw_ostream &Out, bool IncludeType) const
Print this template argument to the given output stream.
QualType getIntegralType() const
Retrieve the type of the integral value.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion,...
const APValue & getAsStructuralValue() const
Get the value of a StructuralValue.
The base class of all kinds of template declarations (e.g., class, function, etc.).
bool hasAssociatedConstraints() const
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) const
Retrieve the underlying template declaration that this template name refers to, if known.
bool isNull() const
Determine whether this template name is NULL.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
AssumedTemplateStorage * getAsAssumedTemplateName() const
Retrieve information on a name that has been assumed to be a template-name in order to permit a call ...
UsingShadowDecl * getAsUsingShadowDecl() const
Retrieve the using shadow declaration through which the underlying template declaration is introduced...
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
SourceRange getSourceRange() const LLVM_READONLY
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
bool hasAssociatedConstraints() const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
NamedDecl *const * const_iterator
Iterates through the template parameters in this list.
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr * > &AC) const
All associated constraints derived from this template parameter list, including the requires clause a...
static bool shouldIncludeTypeForArgument(const PrintingPolicy &Policy, const TemplateParameterList *TPL, unsigned Idx)
SourceLocation getTemplateLoc() const
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
void NoteCandidates(Sema &S, SourceLocation Loc)
NoteCandidates - When no template specialization match is found, prints diagnostic messages containin...
SourceLocation getLocation() const
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set.
unsigned getNumArgs() const
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateKeywordLoc(SourceLocation Loc)
TemplateArgumentLoc getArgLoc(unsigned i) const
void setTemplateNameLoc(SourceLocation Loc)
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
Represents a type template specialization; the template must be a class template, a type alias templa...
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
static bool anyDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, ArrayRef< TemplateArgument > Converted)
Determine whether any of the given template arguments are dependent.
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
TemplateParameterList * getExpansionTemplateParameters(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
void setInheritedDefaultArgument(const ASTContext &C, TemplateTemplateParmDecl *Prev)
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
unsigned getDepth() const
Get the nesting depth of the template parameter.
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, bool Typename, TemplateParameterList *Params)
void removeDefaultArgument()
Removes the default argument of this template parameter.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Declaration of a template type parameter.
SourceLocation getDefaultArgumentLoc() const
Retrieves the location of the default argument declaration.
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool isParameterPack() const
Returns whether this is a parameter pack.
unsigned getDepth() const
Retrieve the depth of the template parameter.
void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint)
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter.
Wrapper for template type parameters.
TemplateTypeParmDecl * getDecl() const
unsigned getIndex() const
unsigned getDepth() const
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Declaration of an alias template.
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
Represents a declaration of a type.
SourceLocation getBeginLoc() const LLVM_READONLY
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
Base wrapper for a particular "section" of type source info.
QualType getType() const
Get the type for which this source info wrapper provides information.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
AutoTypeLoc getContainedAutoTypeLoc() const
Get the typeloc of an AutoType whose type will be deduced for a variable with an initializer of this ...
SourceLocation getBeginLoc() const
Get the begin source location.
Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expre...
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
A reasonable base class for TypeLocs that correspond to types that are written as a type-specifier.
SourceLocation getNameLoc() const
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
The base class of the type hierarchy.
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBooleanType() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
bool isRValueReferenceType() const
bool isVoidPointerType() const
bool isPointerType() const
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isScalarType() const
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
const Type * getArrayElementTypeNoTypeQual() const
If this is an array type, return the element type of the array, potentially with type qualifiers miss...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
bool isObjCObjectOrInterfaceType() const
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isLValueReferenceType() const
bool isBitIntType() const
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isStructuralType() const
Determine if this type is a structural type, per C++20 [temp.param]p7.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isChar16Type() const
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
QualType getCanonicalTypeInternal() const
bool isMemberPointerType() const
bool isChar32Type() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool hasUnnamedOrLocalType() const
Whether this type is or contains a local or unnamed type.
bool isPointerOrReferenceType() const
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isVectorType() const
bool isWideCharType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isNullPtrType() const
bool isRecordType() const
QualType getUnderlyingType() const
Simple class containing the result of Sema::CorrectTypo.
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
DeclClass * getCorrectionDeclAs() const
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represents a C++ unqualified-id that has been parsed.
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent)
void addDecl(NamedDecl *D)
The iterator over UnresolvedSets.
A set of unresolved declarations.
Represents the dependent type named by a dependently-scoped typename using declaration,...
Represents a dependent using declaration which was not marked with typename.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
Represents a variable declaration or definition.
TLSKind getTLSKind() const
bool isStaticDataMember() const
Determines whether this is a static data member.
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization,...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template,...
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
Declaration of a variable template.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > & getPartialSpecializations() const
Retrieve the set of partial specializations of this class template.
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
VarTemplateDecl * getMostRecentDecl()
static VarTemplatePartialSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
void setMemberSpecialization()
Note that this member template is a specialization.
VarTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member variable template partial specialization from which this particular variable temp...
Represents a variable template specialization, which refers to a variable template with a given set o...
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)
Set the template argument list as written in the sources.
static VarTemplateSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
Represents a C array with a specified size that is not an integer-constant-expression.
Represents a GCC generic vector type.
Retains information about a function, method, or block that is currently being parsed.
Provides information about an attempted template argument deduction, whose success or failure was des...
TemplateArgumentList * takeSugared()
Take ownership of the deduced template argument lists.
bool hasSFINAEDiagnostic() const
Is a SFINAE diagnostic available?
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
Defines the clang::TargetInfo interface.
The JSON file list parser is used to communicate input to InstallAPI.
TypeSpecifierType
Specifies the kind of type.
bool isa(CodeGen::Address addr)
@ OR_Deleted
Succeeded, but refers to a deleted function.
@ OR_Success
Overload resolution succeeded.
@ OR_Ambiguous
Ambiguous candidates found.
@ OR_No_Viable_Function
No viable function found.
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
@ ovl_fail_constraints_not_satisfied
This candidate was not viable because its associated constraints were not satisfied.
OverloadCandidateDisplayKind
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
@ OK_Ordinary
An ordinary object is located at an address in memory.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
@ IK_OperatorFunctionId
An overloaded operator name, e.g., operator+.
StorageClass
Storage classes.
@ CRK_None
Candidate is not a rewritten candidate.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
@ Result
The result type of a method or function.
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
ActionResult< Expr * > ExprResult
TagTypeKind
The kind of a tag type.
@ Enum
The "enum" keyword.
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema's representation of template deduction information to the form used in overload-can...
@ BTK__type_pack_element
This names the __type_pack_element BuiltinTemplateDecl.
@ BTK__builtin_common_type
This names the __builtin_common_type BuiltinTemplateDecl.
@ BTK__make_integer_seq
This names the __make_integer_seq BuiltinTemplateDecl.
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
CastKind
CastKind - The kind of operation required for a conversion.
std::optional< unsigned > getExpandedPackSize(const NamedDecl *Param)
Check whether the template parameter is a pack expansion, and if so, determine the number of paramete...
SourceRange getTemplateParamsRange(TemplateParameterList const *const *Params, unsigned NumParams)
Retrieves the range of the given template parameter lists.
bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg, const NamedDecl *Param, ArrayRef< TemplateArgument > Args, unsigned Depth)
Make a best-effort determination of whether the type T can be produced by substituting Args into the ...
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
@ TNK_Var_template
The name refers to a variable template whose specialization produces a variable.
@ TNK_Type_template
The name refers to a template whose specialization produces a type.
@ TNK_Dependent_template_name
The name refers to a dependent template name:
@ TNK_Function_template
The name refers to a function template or a set of overloaded functions that includes at least one fu...
@ TNK_Concept_template
The name refers to a concept.
@ TNK_Non_template
The name does not refer to a template.
@ TNK_Undeclared_template
Lookup for the name failed, but we're assuming it was a template name anyway.
ActionResult< ParsedType > TypeResult
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
const FunctionProtoType * T
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
TemplateDeductionResult
Describes the result of template argument deduction.
@ ConstraintsNotSatisfied
The deduced arguments did not satisfy the constraints associated with the template.
@ CUDATargetMismatch
CUDA Target attributes do not match.
@ Success
Template argument deduction was successful.
@ AlreadyDiagnosed
Some error which was already diagnosed.
ActionResult< Decl * > DeclResult
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ None
No keyword precedes the qualified type name.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
@ Parens
New-expression has a C++98 paren-delimited initializer.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
SourceLocation getEndLoc() const LLVM_READONLY
ArrayRef< TemplateArgument > Args
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
bool HasSideEffects
Whether the evaluated expression has side effects.
Extra information about a function prototype.
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
Describes how types, statements, expressions, and declarations should be printed.
unsigned PrintCanonicalTypes
Whether to print types as written or canonically.
unsigned TerseOutput
Provide a 'terse' output.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
@ BuildingDeductionGuides
We are building deduction guides for a class.
A stack object to be created when performing template instantiation.
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
Location information for a TemplateArgument.
Information about a template-id annotation token.
const IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
unsigned NumArgs
NumArgs - The number of template arguments.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info)
Contains all information for a given match.