42#include "llvm/ADT/SmallBitVector.h"
43#include "llvm/ADT/StringExtras.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/SaveAndRestore.h"
56 return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc());
70 auto ParamsAtDepth = [&](
unsigned D) { Depth = std::max(Depth, D + 1); };
75 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(FSI)) {
76 if (!LSI->TemplateParams.empty()) {
77 ParamsAtDepth(LSI->AutoTemplateParameterDepth);
80 if (LSI->GLTemplateParameterList) {
81 ParamsAtDepth(LSI->GLTemplateParameterList->getDepth());
91 if (!Info.TemplateParams.empty()) {
92 ParamsAtDepth(Info.AutoTemplateParameterDepth);
107 bool AllowFunctionTemplates,
108 bool AllowDependent) {
118 if (
const auto *
Record = dyn_cast<CXXRecordDecl>(D)) {
130 if (
Record->isInjectedClassName()) {
132 if (
Record->getDescribedClassTemplate())
133 return Record->getDescribedClassTemplate();
135 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(
Record))
136 return Spec->getSpecializedTemplate();
152 bool AllowFunctionTemplates,
153 bool AllowDependent) {
164 bool AllowFunctionTemplates,
166 bool AllowNonTemplateFunctions) {
170 if (AllowNonTemplateFunctions &&
180 bool hasTemplateKeyword,
183 bool EnteringContext,
185 bool &MemberOfUnknownSpecialization,
186 bool Disambiguation) {
190 MemberOfUnknownSpecialization =
false;
198 TName =
Context.DeclarationNames.getCXXOperatorName(
239 bool AnyFunctionTemplates =
false;
243 AnyFunctionTemplates =
true;
246 FoundUsingShadow = dyn_cast<UsingShadowDecl>(FoundD);
254 if (!D && !AnyFunctionTemplates) {
255 R.suppressDiagnostics();
272 unsigned ResultCount = R.
end() - R.
begin();
273 if (!D && ResultCount > 1) {
284 assert(D &&
"unambiguous result is not a template name");
289 MemberOfUnknownSpecialization =
true;
296 assert(!FoundUsingShadow || FoundUsingShadow->
getTargetDecl() == TD);
299 Template =
Context.getQualifiedTemplateName(Qualifier, hasTemplateKeyword,
314 ? dyn_cast<TemplateTemplateParmDecl>(TD)->templateParameterKind()
323 Diag(Name.
getBeginLoc(), diag::err_builtin_pack_outside_template) << TName;
342 if (R.
empty())
return false;
379 {SS->getScopeRep(), &II, false}));
380 Diag(IILoc, diag::err_template_kw_missing)
381 << SuggestedTemplate.
get()
388 QualType ObjectType,
bool EnteringContext,
391 bool AllowTypoCorrection) {
398 Found.setTemplateNameLookup(
true);
402 bool IsDependent =
false;
403 if (!ObjectType.
isNull()) {
406 assert(SS.
isEmpty() &&
"ObjectType and scope specifier cannot coexist");
410 !ObjectType->
getAs<TagType>() ||
411 ObjectType->
castAs<TagType>()
413 ->isEntityBeingDefined()) &&
414 "Caller should have completed object type");
446 bool ObjectTypeSearchedInScope =
false;
447 bool AllowFunctionTemplatesInLookup =
true;
463 IsDependent |=
Found.wasNotFoundInCurrentInstantiation();
479 if (!ObjectType.
isNull()) {
483 AllowFunctionTemplatesInLookup =
false;
484 ObjectTypeSearchedInScope =
true;
487 IsDependent |=
Found.wasNotFoundInCurrentInstantiation();
490 if (
Found.isAmbiguous())
507 if (AllFunctions || (
Found.empty() && !IsDependent)) {
511 *ATK = (
Found.empty() &&
Found.getLookupName().isIdentifier())
519 if (
Found.empty() && !IsDependent && AllowTypoCorrection) {
531 Found.getLookupNameInfo(),
Found.getLookupKind(), S, &SS, FilterCCC,
533 if (
auto *ND = Corrected.getFoundDecl())
536 if (
Found.isAmbiguous()) {
538 }
else if (!
Found.empty()) {
541 AllowFunctionTemplatesInLookup =
true;
542 Found.setLookupName(Corrected.getCorrection());
544 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
545 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
548 << Name << LookupCtx << DroppedSpecifier
562 Found.setNotFoundInCurrentInstantiation();
568 if (ExampleLookupResult && RequiredTemplate) {
569 Diag(
Found.getNameLoc(), diag::err_template_kw_refers_to_non_template)
574 diag::note_template_kw_refers_to_non_template)
575 <<
Found.getLookupName();
582 if (S && !ObjectType.
isNull() && !ObjectTypeSearchedInScope &&
599 if (FoundOuter.
empty()) {
609 }
else if (!
Found.isSuppressingAmbiguousDiagnostics()) {
613 if (!
Found.isSingleResult() ||
617 diag::ext_nested_name_member_ref_lookup_ambiguous)
618 <<
Found.getLookupName()
620 Diag(
Found.getRepresentativeDecl()->getLocation(),
621 diag::note_ambig_member_ref_object_type)
624 diag::note_ambig_member_ref_scope);
647 bool MissingTemplateKeyword =
false;
650 if (
auto *DRE = dyn_cast<DeclRefExpr>(
TemplateName.get())) {
651 NameInfo = DRE->getNameInfo();
652 SS.
Adopt(DRE->getQualifierLoc());
654 Found = DRE->getFoundDecl();
655 }
else if (
auto *ME = dyn_cast<MemberExpr>(
TemplateName.get())) {
656 NameInfo = ME->getMemberNameInfo();
657 SS.
Adopt(ME->getQualifierLoc());
659 LookupCtx = ME->getBase()->getType()->getAsCXXRecordDecl();
660 Found = ME->getMemberDecl();
661 }
else if (
auto *DSDRE =
662 dyn_cast<DependentScopeDeclRefExpr>(
TemplateName.get())) {
663 NameInfo = DSDRE->getNameInfo();
664 SS.
Adopt(DSDRE->getQualifierLoc());
665 MissingTemplateKeyword =
true;
666 }
else if (
auto *DSME =
667 dyn_cast<CXXDependentScopeMemberExpr>(
TemplateName.get())) {
668 NameInfo = DSME->getMemberNameInfo();
669 SS.
Adopt(DSME->getQualifierLoc());
670 MissingTemplateKeyword =
true;
672 llvm_unreachable(
"unexpected kind of potential template name");
677 if (MissingTemplateKeyword) {
686 TemplateCandidateFilter(
Sema &S) : S(S) {
687 WantTypeSpecifiers =
false;
688 WantExpressionKeywords =
false;
689 WantRemainingKeywords =
false;
690 WantCXXNamedCasts =
true;
692 bool ValidateCandidate(
const TypoCorrection &Candidate)
override {
698 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
699 return std::make_unique<TemplateCandidateFilter>(*
this);
704 TemplateCandidateFilter CCC(*
this);
708 auto *ND = Corrected.getFoundDecl();
711 if (ND || Corrected.isKeyword()) {
713 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
714 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
717 PDiag(diag::err_non_template_in_member_template_id_suggest)
718 << Name << LookupCtx << DroppedSpecifier
722 PDiag(diag::err_non_template_in_template_id_suggest)
727 diag::note_non_template_in_template_id_found);
732 Diag(NameInfo.
getLoc(), diag::err_non_template_in_template_id)
735 Diag(
Found->getLocation(), diag::note_non_template_in_template_id_found);
742 bool isAddressOfOperand,
758 nullptr, NameInfo, TemplateArgs);
787 bool refParam =
true;
790 refParam = Replacement->isLValue();
791 if (refParam && Replacement->getType()->isRecordType()) {
796 if (
const auto *PET = dyn_cast<PackExpansionType>(ParamType))
797 ParamType = PET->getPattern();
802 SemaRef.BuildExpressionFromNonTypeTemplateArgument(Arg, Loc);
805 Replacement = result.
get();
809 Replacement->getType(), Replacement->getValueKind(), Loc, Replacement,
810 AssociatedDecl, NTTP->
getIndex(), PackIndex, refParam, Final);
815 bool InstantiatedFromMember,
819 bool Complain,
bool *Unreachable) {
823 bool IsEntityBeingDefined =
false;
824 if (
const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
825 IsEntityBeingDefined = TD->isBeingDefined();
827 if (PatternDef && !IsEntityBeingDefined) {
844 if (!Complain || (PatternDef && PatternDef->
isInvalidDecl()))
848 if (
TagDecl *TD = dyn_cast<TagDecl>(Instantiation))
849 InstantiationTy =
Context.getCanonicalTagType(TD);
851 Diag(PointOfInstantiation,
852 diag::err_template_instantiate_within_definition)
858 }
else if (InstantiatedFromMember) {
860 Diag(PointOfInstantiation,
861 diag::err_explicit_instantiation_undefined_member)
866 assert(
isa<TagDecl>(Instantiation) &&
"Must be a TagDecl!");
867 Diag(PointOfInstantiation,
868 diag::err_implicit_instantiate_member_undefined)
874 Diag(PointOfInstantiation,
875 diag::err_explicit_instantiation_undefined_func_template)
879 Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
884 assert(
isa<VarDecl>(Instantiation) &&
"Must be a VarDecl!");
886 Diag(PointOfInstantiation,
887 diag::err_explicit_instantiation_undefined_var_template)
891 Diag(PointOfInstantiation,
892 diag::err_explicit_instantiation_undefined_member)
909 bool SupportedForCompatibility) {
922 ? diag::ext_template_param_shadow
923 : (SupportedForCompatibility ? diag::ext_compat_template_param_shadow
924 : diag::err_template_param_shadow);
926 Diag(Loc, DiagId) << ND->getDeclName();
931 if (
TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) {
932 D = Temp->getTemplatedDecl();
941 "Only template template arguments can be pack expansions here");
942 assert(
getAsTemplate().get().containsUnexpandedParameterPack() &&
943 "Template template argument pack expansion without packs");
945 Result.EllipsisLoc = EllipsisLoc;
980 llvm_unreachable(
"Unhandled parsed template argument");
985 for (
unsigned I = 0,
Last = TemplateArgsIn.size(); I !=
Last; ++I)
1005 assert(TInfo &&
"template argument with no location");
1013 EllipsisLoc = PET.getEllipsisLoc();
1014 TL = PET.getPatternLoc();
1018 TemplateName Name = DTST.getTypePtr()->getTemplateName();
1020 SS.
Adopt(DTST.getQualifierLoc());
1023 DTST.getTemplateNameLoc());
1044 unsigned Depth,
unsigned Position,
1047 bool HasTypeConstraint) {
1049 "Template type parameter not in template parameter scope!");
1051 bool IsParameterPack = EllipsisLoc.
isValid();
1054 KeyLoc, ParamNameLoc, Depth, Position,
1055 ParamName,
Typename, IsParameterPack,
1059 if (Param->isParameterPack())
1061 CSI->LocalPacks.push_back(Param);
1074 if (DefaultArg && IsParameterPack) {
1075 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1076 DefaultArg =
nullptr;
1084 assert(DefaultTInfo &&
"expected source information for type");
1093 Param->setInvalidDecl();
1097 Param->setDefaultArgument(
1112 return TemplateArgs;
1119 bool IsTypeConcept =
false;
1120 bool RequiresArguments =
false;
1122 IsTypeConcept = TTP->isTypeConceptTemplateParam();
1124 TTP->getTemplateParameters()->getMinRequiredArguments() > 1;
1130 ->getTemplateParameters()
1131 ->getMinRequiredArguments() > 1;
1137 if (!IsTypeConcept) {
1139 diag::err_type_constraint_non_type_concept);
1148 if (!WereArgsSpecified && RequiresArguments) {
1150 diag::err_type_constraint_missing_arguments)
1169 bool AllowUnexpandedPack) {
1186 if (EllipsisLoc.
isInvalid() && !AllowUnexpandedPack) {
1197 ConstrainedParameter, EllipsisLoc);
1200template <
typename ArgumentLocAppender>
1215 Appender(ConstraintArgs);
1223 if (
auto *CD = dyn_cast<ConceptDecl>(NamedConcept)) {
1226 FoundDecl ? FoundDecl : CD, CD, &ConstraintArgs,
1232 auto *CDT = dyn_cast<TemplateTemplateParmDecl>(NamedConcept);
1237 return ImmediatelyDeclaredConstraint;
1253 ImmediatelyDeclaredConstraint.
get(), BO_LAnd,
1254 EllipsisLoc,
nullptr,
1271 *TemplateArgs) :
nullptr;
1276 *
this,
NS, NameInfo, NamedConcept, FoundDecl,
1279 ParamAsArgument, ConstrainedParameter->
getLocation(),
1282 for (const auto &ArgLoc : TemplateArgs->arguments())
1283 ConstraintArgs.addArgument(ArgLoc);
1286 if (ImmediatelyDeclaredConstraint.
isInvalid())
1296 CL, ImmediatelyDeclaredConstraint.
get(), std::nullopt);
1307 diag::err_unsupported_placeholder_constraint)
1326 for (unsigned I = 0, C = TL.getNumArgs(); I != C; ++I)
1327 ConstraintArgs.addArgument(TL.getArgLoc(I));
1330 if (ImmediatelyDeclaredConstraint.
isInvalid() ||
1331 !ImmediatelyDeclaredConstraint.
isUsable())
1335 ImmediatelyDeclaredConstraint.
get());
1354 if (
T->isDependentType())
1360 if (
T->isStructuralType())
1364 if (
T->isRValueReferenceType()) {
1365 Diag(Loc, diag::err_template_nontype_parm_rvalue_ref) <<
T;
1374 (!
T->isScalarType() && !
T->isRecordType())) {
1375 Diag(Loc, diag::err_template_nontype_parm_bad_type) <<
T;
1383 Diag(Loc, diag::err_template_nontype_parm_not_structural) <<
T;
1390 for (
const FieldDecl *FD : RD->fields()) {
1392 Diag(FD->getLocation(), diag::note_not_structural_non_public) <<
T << 0;
1395 if (FD->isMutable()) {
1396 Diag(FD->getLocation(), diag::note_not_structural_mutable_field) <<
T;
1399 if (FD->getType()->isRValueReferenceType()) {
1400 Diag(FD->getLocation(), diag::note_not_structural_rvalue_ref_field)
1407 for (
const auto &BaseSpec : RD->bases()) {
1408 if (BaseSpec.getAccessSpecifier() !=
AS_public) {
1409 Diag(BaseSpec.getBaseTypeLoc(), diag::note_not_structural_non_public)
1420 for (
const FieldDecl *FD : RD->fields()) {
1422 if (!
T->isStructuralType()) {
1423 SubLoc = FD->getLocation();
1431 for (
const auto &BaseSpec : RD->bases()) {
1433 if (!
T->isStructuralType()) {
1434 SubLoc = BaseSpec.getBaseTypeLoc();
1442 assert(Kind != -1 &&
"couldn't find reason why type is not structural");
1443 Diag(SubLoc, diag::note_not_structural_subobject)
1444 <<
T << Kind << SubType;
1446 RD =
T->getAsCXXRecordDecl();
1456 if (
T->isVariablyModifiedType()) {
1457 Diag(Loc, diag::err_variably_modified_nontype_template_param)
1468 if (
T->isIntegralOrEnumerationType() ||
1470 T->isPointerType() ||
1472 T->isLValueReferenceType() ||
1474 T->isMemberPointerType() ||
1476 T->isNullPtrType() ||
1478 T->isUndeducedType()) {
1481 return T.getUnqualifiedType();
1489 if (
T->isArrayType() ||
T->isFunctionType())
1498 if (
T->isDependentType())
1499 return T.getUnqualifiedType();
1510 Diag(Loc, diag::err_template_nontype_parm_bad_structural_type) <<
T;
1514 Diag(Loc, diag::warn_cxx17_compat_template_nontype_parm_type) <<
T;
1515 return T.getUnqualifiedType();
1526 auto CheckValidDeclSpecifiers = [
this, &D] {
1540 Diag(Loc, diag::err_invalid_decl_specifier_in_nontype_parm)
1577 CheckValidDeclSpecifiers();
1582 diag::warn_cxx14_compat_template_nontype_parm_auto_type)
1586 "Non-type template parameter not in template parameter scope!");
1606 if (TL.isConstrained()) {
1608 T->containsUnexpandedParameterPack()) {
1609 assert(TL.getConceptReference()->getTemplateArgsAsWritten());
1611 TL.getConceptReference()->getTemplateArgsAsWritten()->arguments())
1621 Param->setInvalidDecl();
1623 if (Param->isParameterPack())
1625 CSI->LocalPacks.push_back(Param);
1639 if (
Default && IsParameterPack) {
1640 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1650 Param->setDefaultArgument(
1669 "Template template parameter not in template parameter scope!");
1671 bool IsParameterPack = EllipsisLoc.
isValid();
1683 NameLoc.
isInvalid() ? TmpLoc : NameLoc, Depth, Position, IsParameterPack,
1687 if (Param->isParameterPack())
1689 LSI->LocalPacks.push_back(Param);
1700 if (Params->
size() == 0) {
1701 Diag(Param->getLocation(), diag::err_template_template_parm_no_parms)
1707 Param->setInvalidDecl();
1712 if (IsParameterPack && !
Default.isInvalid()) {
1713 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1728 Diag(DefaultArg.
getLocation(), diag::err_template_arg_not_valid_template)
1747 Param->setDefaultArgument(
Context, DefaultArg);
1754class ConstraintRefersToContainingTemplateChecker
1759 unsigned TemplateDepth = 0;
1763 bool CheckIfContainingRecord(
const CXXRecordDecl *CheckingRD) {
1769 DC && !DC->isFileContext(); DC = DC->getParent())
1770 if (
const auto *RD = dyn_cast<CXXRecordDecl>(DC))
1771 if (CheckingRD == RD->getMostRecentDecl()) {
1779 bool CheckNonTypeTemplateParmDecl(
const NonTypeTemplateParmDecl *D) {
1785 return TraverseType(D->
getType());
1789 ConstraintRefersToContainingTemplateChecker(
const FunctionDecl *
Friend,
1790 unsigned TemplateDepth)
1793 bool getResult()
const {
return Result; }
1799 bool VisitTemplateTypeParmType(
const TemplateTypeParmType *
Type)
override {
1800 if (
Type->getDecl()->getDepth() < TemplateDepth) {
1807 bool TraverseDeclRefExpr(
const DeclRefExpr *E)
override {
1808 return TraverseDecl(E->
getDecl());
1811 bool TraverseTypedefType(
const TypedefType *TT,
1813 return TraverseType(TT->
desugar());
1816 bool TraverseTypeLoc(TypeLoc TL,
bool TraverseQualifier)
override {
1818 return TraverseType(TL.
getType(), TraverseQualifier);
1821 bool VisitTagType(
const TagType *
T)
override {
1822 return TraverseDecl(
T->getOriginalDecl());
1825 bool TraverseDecl(
const Decl *D)
override {
1831 if (
auto *TD = dyn_cast<TypedefNameDecl>(D))
1832 return TraverseType(TD->getUnderlyingType());
1833 if (
auto *NTTPD = dyn_cast<NonTypeTemplateParmDecl>(D))
1834 return CheckNonTypeTemplateParmDecl(NTTPD);
1835 if (
auto *VD = dyn_cast<ValueDecl>(D))
1836 return TraverseType(VD->getType());
1839 if (
auto *RD = dyn_cast<CXXRecordDecl>(D))
1840 return CheckIfContainingRecord(RD);
1845 llvm_unreachable(
"Don't know how to handle this declaration type yet");
1853 const Expr *Constraint) {
1854 assert(
Friend->getFriendObjectKind() &&
"Only works on a friend");
1855 ConstraintRefersToContainingTemplateChecker Checker(
Friend, TemplateDepth);
1856 Checker.TraverseStmt(Constraint);
1857 return Checker.getResult();
1867 Expr *RequiresClause) {
1869 Diag(ExportLoc, diag::warn_template_export_unsupported);
1921 assert(TemplateParams && TemplateParams->
size() > 0 &&
1922 "No template parameters");
1924 "Can only declare or define class templates");
1933 "can't build template of enumerated type");
1937 Diag(KWLoc, diag::err_template_unnamed_class);
1952 if (!SemanticContext) {
1957 ? diag::warn_template_qualified_friend_ignored
1958 : diag::err_template_qualified_declarator_no_match)
2034 dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
2039 if (!PrevClassTemplate && isa_and_nonnull<CXXRecordDecl>(PrevDecl) &&
2047 ->getSpecializedTemplate();
2070 PrevDecl = PrevClassTemplate =
nullptr;
2071 SemanticContext = OutermostContext;
2089 SemanticContext, S, SS.
isValid()))
2090 PrevDecl = PrevClassTemplate =
nullptr;
2092 if (
auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
2093 PrevDecl ?
Previous.getRepresentativeDecl() :
nullptr)) {
2095 !(PrevClassTemplate &&
2098 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
2099 Diag(Shadow->getTargetDecl()->getLocation(),
2100 diag::note_using_decl_target);
2101 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl) << 0;
2103 PrevDecl = PrevClassTemplate =
nullptr;
2107 if (PrevClassTemplate) {
2116 TemplateParams, PrevClassTemplate,
2129 Diag(KWLoc, diag::err_use_with_wrong_tag)
2142 bool HiddenDefVisible =
false;
2147 if (!HiddenDefVisible && Hidden) {
2150 assert(Tmpl &&
"original definition of a class template is not a "
2156 Diag(NameLoc, diag::err_redefinition) << Name;
2157 Diag(Def->getLocation(), diag::note_previous_definition);
2164 }
else if (PrevDecl) {
2170 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
2184 (SS.
isSet() && SemanticContext && SemanticContext->
isRecord() &&
2197 ? diag::err_friend_decl_does_not_match
2198 : diag::err_member_decl_does_not_match)
2199 << Name << SemanticContext <<
true << SS.
getRange();
2209 bool ShouldAddRedecl =
2213 Context, Kind, SemanticContext, KWLoc, NameLoc, Name,
2214 PrevClassTemplate && ShouldAddRedecl
2218 if (NumOuterTemplateParamLists > 0)
2221 llvm::ArrayRef(OuterTemplateParamLists, NumOuterTemplateParamLists));
2237 if (ShouldAddRedecl)
2242 if (ModulePrivateLoc.
isValid())
2247 if (PrevClassTemplate &&
2265 if (PrevClassTemplate)
2301 if (PrevClassTemplate)
2340 S.
DiagCompat(ParamLoc, diag_compat::templ_default_in_function_templ)
2349 S.
Diag(ParamLoc, diag::err_template_parameter_default_template_member)
2358 S.
Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
2367 llvm_unreachable(
"Invalid TemplateParamListContext!");
2380 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
2385 if (TC->hasExplicitTemplateArgs())
2386 for (
auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
2394 if (!NTTP->isParameterPack() &&
2396 NTTP->getTypeSourceInfo(),
2404 = dyn_cast<TemplateTemplateParmDecl>(P))
2424 bool SawDefaultArgument =
false;
2430 OldParam = OldParams->
begin();
2432 bool RemoveDefaultArguments =
false;
2434 NewParamEnd = NewParams->
end();
2435 NewParam != NewParamEnd; ++NewParam) {
2438 bool RedundantDefaultArg =
false;
2441 bool InconsistentDefaultArg =
false;
2443 std::string PrevModuleName;
2449 bool MissingDefaultArg =
false;
2452 bool SawParameterPack =
false;
2455 = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
2457 if (NewTypeParm->hasDefaultArgument() &&
2459 *
this, TPC, NewTypeParm->getLocation(),
2460 NewTypeParm->getDefaultArgument().getSourceRange()))
2461 NewTypeParm->removeDefaultArgument();
2466 if (NewTypeParm->isParameterPack()) {
2467 assert(!NewTypeParm->hasDefaultArgument() &&
2468 "Parameter packs can't have a default argument!");
2469 SawParameterPack =
true;
2471 NewTypeParm->hasDefaultArgument() &&
2474 NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
2475 SawDefaultArgument =
true;
2478 RedundantDefaultArg =
true;
2479 else if (!
getASTContext().isSameDefaultTemplateArgument(OldTypeParm,
2481 InconsistentDefaultArg =
true;
2485 PreviousDefaultArgLoc = NewDefaultLoc;
2489 NewTypeParm->setInheritedDefaultArgument(
Context, OldTypeParm);
2491 }
else if (NewTypeParm->hasDefaultArgument()) {
2492 SawDefaultArgument =
true;
2493 PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
2494 }
else if (SawDefaultArgument)
2495 MissingDefaultArg =
true;
2497 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
2502 !NewNonTypeParm->isParameterPack() &&
2504 NewNonTypeParm->getTypeSourceInfo(),
2511 if (NewNonTypeParm->hasDefaultArgument() &&
2513 *
this, TPC, NewNonTypeParm->getLocation(),
2514 NewNonTypeParm->getDefaultArgument().getSourceRange())) {
2515 NewNonTypeParm->removeDefaultArgument();
2521 if (NewNonTypeParm->isParameterPack()) {
2522 assert(!NewNonTypeParm->hasDefaultArgument() &&
2523 "Parameter packs can't have a default argument!");
2524 if (!NewNonTypeParm->isPackExpansion())
2525 SawParameterPack =
true;
2527 NewNonTypeParm->hasDefaultArgument() &&
2530 NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
2531 SawDefaultArgument =
true;
2533 RedundantDefaultArg =
true;
2535 OldNonTypeParm, NewNonTypeParm)) {
2536 InconsistentDefaultArg =
true;
2540 PreviousDefaultArgLoc = NewDefaultLoc;
2544 NewNonTypeParm->setInheritedDefaultArgument(
Context, OldNonTypeParm);
2546 }
else if (NewNonTypeParm->hasDefaultArgument()) {
2547 SawDefaultArgument =
true;
2548 PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
2549 }
else if (SawDefaultArgument)
2550 MissingDefaultArg =
true;
2573 "Parameter packs can't have a default argument!");
2575 SawParameterPack =
true;
2576 }
else if (OldTemplateParm &&
2582 SawDefaultArgument =
true;
2584 RedundantDefaultArg =
true;
2586 OldTemplateParm, NewTemplateParm)) {
2587 InconsistentDefaultArg =
true;
2591 PreviousDefaultArgLoc = NewDefaultLoc;
2596 PreviousDefaultArgLoc
2599 SawDefaultArgument =
true;
2600 PreviousDefaultArgLoc
2602 }
else if (SawDefaultArgument)
2603 MissingDefaultArg =
true;
2609 if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
2611 Diag((*NewParam)->getLocation(),
2612 diag::err_template_param_pack_must_be_last_template_parameter);
2629 if (RedundantDefaultArg) {
2630 Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
2631 Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
2633 }
else if (InconsistentDefaultArg) {
2637 diag::err_template_param_default_arg_inconsistent_redefinition);
2639 diag::note_template_param_prev_default_arg_in_other_module)
2642 }
else if (MissingDefaultArg &&
2650 Diag((*NewParam)->getLocation(),
2651 diag::err_template_param_default_arg_missing);
2652 Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
2654 RemoveDefaultArguments =
true;
2665 if (RemoveDefaultArguments) {
2667 NewParamEnd = NewParams->
end();
2668 NewParam != NewParamEnd; ++NewParam) {
2670 TTP->removeDefaultArgument();
2672 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
2673 NTTP->removeDefaultArgument();
2693 bool IgnoreNonTypeDependent;
2698 DependencyChecker(
unsigned Depth,
bool IgnoreNonTypeDependent)
2699 : Depth(Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),
2703 : IgnoreNonTypeDependent(IgnoreNonTypeDependent),
Match(
false) {
2706 Depth = PD->getDepth();
2707 }
else if (NonTypeTemplateParmDecl *PD =
2708 dyn_cast<NonTypeTemplateParmDecl>(ND)) {
2709 Depth = PD->getDepth();
2715 bool Matches(
unsigned ParmDepth, SourceLocation Loc = SourceLocation()) {
2716 if (ParmDepth >= Depth) {
2724 bool TraverseStmt(Stmt *S)
override {
2729 if (
auto *E = dyn_cast_or_null<Expr>(S))
2730 if (IgnoreNonTypeDependent && !E->isTypeDependent())
2735 bool TraverseTypeLoc(TypeLoc TL,
bool TraverseQualifier =
true)
override {
2736 if (IgnoreNonTypeDependent && !TL.
isNull() &&
2742 bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL)
override {
2746 bool VisitTemplateTypeParmType(TemplateTypeParmType *
T)
override {
2748 return IgnoreNonTypeDependent || !Matches(
T->getDepth());
2752 if (TemplateTemplateParmDecl *PD =
2754 if (Matches(PD->getDepth()))
2759 bool VisitDeclRefExpr(DeclRefExpr *E)
override {
2760 if (NonTypeTemplateParmDecl *PD =
2761 dyn_cast<NonTypeTemplateParmDecl>(E->
getDecl()))
2762 if (Matches(PD->getDepth(), E->
getExprLoc()))
2764 return DynamicRecursiveASTVisitor::VisitDeclRefExpr(E);
2767 bool VisitUnresolvedLookupExpr(UnresolvedLookupExpr *ULE)
override {
2770 if (Matches(TTP->getDepth(), ULE->
getExprLoc()))
2776 return DynamicRecursiveASTVisitor::VisitUnresolvedLookupExpr(ULE);
2779 bool VisitSubstTemplateTypeParmType(SubstTemplateTypeParmType *
T)
override {
2780 return TraverseType(
T->getReplacementType());
2783 bool VisitSubstTemplateTypeParmPackType(
2784 SubstTemplateTypeParmPackType *
T)
override {
2785 return TraverseTemplateArgument(
T->getArgumentPack());
2788 bool TraverseInjectedClassNameType(InjectedClassNameType *
T,
2789 bool TraverseQualifier)
override {
2792 return TraverseTemplateArguments(
2793 T->getTemplateArgs(
T->getOriginalDecl()->getASTContext()));
2802 if (!Params->
size())
2805 DependencyChecker Checker(Params,
false);
2806 Checker.TraverseType(
T);
2807 return Checker.Match;
2833 bool &IsMemberSpecialization,
bool &
Invalid,
bool SuppressDiagnostic) {
2834 IsMemberSpecialization =
false;
2856 while (!
T.isNull()) {
2857 NestedTypes.push_back(
T);
2863 = dyn_cast<ClassTemplateSpecializationDecl>(
Record)) {
2866 ExplicitSpecLoc = Spec->getLocation();
2869 }
else if (
Record->getTemplateSpecializationKind()
2871 ExplicitSpecLoc =
Record->getLocation();
2876 T =
Context.getTypeDeclType(Parent);
2882 if (
const TemplateSpecializationType *TST
2883 =
T->getAs<TemplateSpecializationType>()) {
2896 T =
Context.getTypeDeclType(Parent);
2904 if (
const DependentNameType *DependentName =
T->getAs<DependentNameType>()){
2914 if (
const EnumType *EnumT =
T->getAsCanonical<EnumType>()) {
2920 if (
TypeDecl *Parent = dyn_cast<TypeDecl>(
Enum->getParent()))
2921 T =
Context.getCanonicalTypeDeclType(Parent);
2931 std::reverse(NestedTypes.begin(), NestedTypes.end());
2939 bool SawNonEmptyTemplateParameterList =
false;
2941 auto CheckExplicitSpecialization = [&](
SourceRange Range,
bool Recovery) {
2942 if (SawNonEmptyTemplateParameterList) {
2943 if (!SuppressDiagnostic)
2944 Diag(DeclLoc, diag::err_specialize_member_of_template)
2945 << !Recovery << Range;
2947 IsMemberSpecialization =
false;
2954 auto DiagnoseMissingExplicitSpecialization = [&] (
SourceRange Range) {
2956 if (CheckExplicitSpecialization(Range,
true))
2961 if (!ParamLists.empty())
2962 ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
2964 ExpectedTemplateLoc = DeclStartLoc;
2966 if (!SuppressDiagnostic)
2967 Diag(DeclLoc, diag::err_template_spec_needs_header)
2974 for (
unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
2976 T = NestedTypes[TypeIdx];
2979 bool NeedEmptyTemplateHeader =
false;
2982 bool NeedNonemptyTemplateHeader =
false;
2995 = dyn_cast<ClassTemplatePartialSpecializationDecl>(
Record)) {
2996 ExpectedTemplateParams = Partial->getTemplateParameters();
2997 NeedNonemptyTemplateHeader =
true;
2998 }
else if (
Record->isDependentType()) {
2999 if (
Record->getDescribedClassTemplate()) {
3000 ExpectedTemplateParams =
Record->getDescribedClassTemplate()
3001 ->getTemplateParameters();
3002 NeedNonemptyTemplateHeader =
true;
3005 = dyn_cast<ClassTemplateSpecializationDecl>(
Record)) {
3011 NeedEmptyTemplateHeader =
true;
3014 }
else if (
Record->getTemplateSpecializationKind()) {
3015 if (
Record->getTemplateSpecializationKind()
3017 TypeIdx == NumTypes - 1)
3018 IsMemberSpecialization =
true;
3022 }
else if (
const auto *TST =
T->getAs<TemplateSpecializationType>()) {
3025 ExpectedTemplateParams =
Template->getTemplateParameters();
3026 NeedNonemptyTemplateHeader =
true;
3030 NeedNonemptyTemplateHeader =
false;
3041 if (
ParamIdx < ParamLists.size()) {
3042 if (ParamLists[
ParamIdx]->size() == 0) {
3043 if (CheckExplicitSpecialization(ParamLists[
ParamIdx]->getSourceRange(),
3047 SawNonEmptyTemplateParameterList =
true;
3050 if (NeedEmptyTemplateHeader) {
3053 if (TypeIdx == NumTypes - 1)
3054 IsMemberSpecialization =
true;
3056 if (
ParamIdx < ParamLists.size()) {
3057 if (ParamLists[
ParamIdx]->size() > 0) {
3059 if (!SuppressDiagnostic)
3061 diag::err_template_param_list_matches_nontemplate)
3064 ParamLists[
ParamIdx]->getRAngleLoc())
3076 if (DiagnoseMissingExplicitSpecialization(
3083 if (NeedNonemptyTemplateHeader) {
3088 if (IsFriend &&
T->isDependentType()) {
3089 if (
ParamIdx < ParamLists.size() &&
3091 ExpectedTemplateParams =
nullptr;
3096 if (
ParamIdx < ParamLists.size()) {
3098 if (ExpectedTemplateParams &&
3100 ExpectedTemplateParams,
3113 if (!SuppressDiagnostic)
3114 Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
3125 if (
ParamIdx >= ParamLists.size()) {
3126 if (TemplateId && !IsFriend) {
3142 if (
ParamIdx < ParamLists.size() - 1) {
3143 bool HasAnyExplicitSpecHeader =
false;
3144 bool AllExplicitSpecHeaders =
true;
3145 for (
unsigned I =
ParamIdx, E = ParamLists.size() - 1; I != E; ++I) {
3146 if (ParamLists[I]->size() == 0)
3147 HasAnyExplicitSpecHeader =
true;
3149 AllExplicitSpecHeaders =
false;
3152 if (!SuppressDiagnostic)
3154 AllExplicitSpecHeaders ? diag::ext_template_spec_extra_headers
3155 : diag::err_template_spec_extra_headers)
3157 ParamLists[ParamLists.size() - 2]->getRAngleLoc());
3162 if (ExplicitSpecLoc.
isValid() && HasAnyExplicitSpecHeader &&
3163 !SuppressDiagnostic)
3164 Diag(ExplicitSpecLoc,
3165 diag::note_explicit_template_spec_does_not_need_header)
3166 << NestedTypes.back();
3171 if (!AllExplicitSpecHeaders)
3182 if (ParamLists.back()->size() == 0 &&
3183 CheckExplicitSpecialization(ParamLists[
ParamIdx]->getSourceRange(),
3189 return ParamLists.back();
3194 Diag(
Template->getLocation(), diag::note_template_declared_here)
3210 Diag((*I)->getLocation(), diag::note_template_declared_here)
3211 << 0 << (*I)->getDeclName();
3241 Keyword, BaseTemplate, TemplateLoc, Args,
3247 return BaseTemplateInst;
3252 switch (Ts.size()) {
3262 return lookUpCommonType(Ts[0], Ts[0]);
3276 return lookUpCommonType(D1, D2);
3281 auto CheckConditionalOperands = [&](
bool ConstRefQual) ->
QualType {
3320 if (
auto Res = CheckConditionalOperands(
false); !Res.isNull())
3333 return CheckConditionalOperands(
true);
3343 QualType Result = Ts.front().getAsType();
3344 for (
auto T : llvm::drop_begin(Ts)) {
3345 Result = lookUpCommonType(Result,
T.getAsType());
3346 if (Result.isNull())
3355 DeclContext *DC = RT->getOriginalDecl()->getDeclContext();
3370 bool Literal =
false;
3372 if (
isInVkNamespace(RT) && RT->getOriginalDecl()->getName() ==
"Literal") {
3374 dyn_cast<ClassTemplateSpecializationDecl>(RT->getOriginalDecl());
3378 QualType ConstantType = LiteralArgs[0].getAsType();
3381 LiteralLoc = SpecDecl->getSourceRange().getBegin();
3385 RT->getOriginalDecl()->getName() ==
"integral_constant") {
3387 dyn_cast<ClassTemplateSpecializationDecl>(RT->getOriginalDecl());
3392 QualType ConstantType = ConstantArgs[0].getAsType();
3393 llvm::APInt
Value = ConstantArgs[1].getAsIntegral();
3396 return SpirvOperand::createLiteral(
Value);
3397 return SpirvOperand::createConstant(ConstantType,
Value);
3398 }
else if (Literal) {
3399 SemaRef.
Diag(LiteralLoc, diag::err_hlsl_vk_literal_must_contain_constant);
3400 return SpirvOperand();
3404 diag::err_call_incomplete_argument))
3405 return SpirvOperand();
3406 return SpirvOperand::createType(OperandArg);
3416 case BTK__make_integer_seq: {
3420 QualType OrigType = Converted[1].getAsType();
3424 SemaRef.
Diag(TemplateArgs[1].getLocation(),
3425 diag::err_integer_sequence_integral_element_type);
3439 OrigType, TemplateArgs[1].getLocation())));
3441 if (llvm::APSInt NumArgs = NumArgsArg.
getAsIntegral(); NumArgs >= 0) {
3443 for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
3447 TA, OrigType, TemplateArgs[2].getLocation()));
3452 SemaRef.
Diag(TemplateArgs[2].getLocation(),
3453 diag::err_integer_sequence_negative_length);
3460 TemplateLoc, SyntheticTemplateArgs,
3465 case BTK__type_pack_element: {
3469 assert(Converted.size() == 2 &&
3470 "__type_pack_element should be given an index and a parameter pack");
3477 assert(Index >= 0 &&
"the index used with __type_pack_element should be of "
3478 "type std::size_t, and hence be non-negative");
3480 if (Index >= Ts.pack_size()) {
3481 SemaRef.
Diag(TemplateArgs[0].getLocation(),
3482 diag::err_type_pack_element_out_of_bounds);
3487 int64_t N = Index.getExtValue();
3488 return Ts.getPackAsArray()[N].getAsType();
3491 case BTK__builtin_common_type: {
3492 assert(Converted.size() == 4);
3493 if (llvm::any_of(Converted, [](
auto &
C) {
return C.isDependent(); }))
3496 TemplateName BaseTemplate = Converted[0].getAsTemplate();
3504 CT, TemplateArgs[1].getLocation())));
3505 TemplateName HasTypeMember = Converted[1].getAsTemplate();
3510 QualType HasNoTypeMember = Converted[2].getAsType();
3511 return HasNoTypeMember;
3514 case BTK__hlsl_spirv_type: {
3515 assert(Converted.size() == 4);
3517 if (!Context.getTargetInfo().getTriple().isSPIRV()) {
3518 SemaRef.
Diag(TemplateLoc, diag::err_hlsl_spirv_only) << BTD;
3521 if (llvm::any_of(Converted, [](
auto &
C) {
return C.isDependent(); }))
3524 uint64_t Opcode = Converted[0].getAsIntegral().getZExtValue();
3525 uint64_t Size = Converted[1].getAsIntegral().getZExtValue();
3526 uint64_t Alignment = Converted[2].getAsIntegral().getZExtValue();
3532 for (
auto &OperandTA : OperandArgs) {
3533 QualType OperandArg = OperandTA.getAsType();
3535 TemplateArgs[3].getLocation());
3536 if (!Operand.isValid())
3538 Operands.push_back(Operand);
3541 return Context.getHLSLInlineSpirvType(Opcode, Size, Alignment, Operands);
3543 case BTK__builtin_dedup_pack: {
3544 assert(Converted.size() == 1 &&
"__builtin_dedup_pack should be given "
3545 "a parameter pack");
3554 llvm::SmallDenseSet<QualType> Seen;
3558 if (!Seen.insert(
T.getAsType().getCanonicalType()).second)
3560 OutArgs.push_back(
T);
3562 return Context.getSubstBuiltinTemplatePack(
3566 llvm_unreachable(
"unexpected BuiltinTemplateDecl!");
3584 if (
auto BinOp = dyn_cast<BinaryOperator>(Clause->IgnoreParenImpCasts())) {
3585 if (BinOp->getOpcode() == BO_LAnd) {
3592 Terms.push_back(Clause);
3600 auto *BinOp = dyn_cast<BinaryOperator>(
Cond->IgnoreParenImpCasts());
3601 if (!BinOp)
return Cond;
3603 if (BinOp->getOpcode() != BO_LOr)
return Cond;
3606 Expr *LHS = BinOp->getLHS();
3608 if (!InnerBinOp)
return Cond;
3610 if (InnerBinOp->getOpcode() != BO_EQ ||
3621 if (MacroName ==
"CONCEPT_REQUIRES" || MacroName ==
"CONCEPT_REQUIRES_")
3622 return BinOp->getRHS();
3632class FailedBooleanConditionPrinterHelper :
public PrinterHelper {
3634 explicit FailedBooleanConditionPrinterHelper(
const PrintingPolicy &P)
3637 bool handledStmt(Stmt *E, raw_ostream &OS)
override {
3638 const auto *DR = dyn_cast<DeclRefExpr>(E);
3639 if (DR && DR->getQualifier()) {
3642 DR->getQualifier().print(OS, Policy,
true);
3644 const ValueDecl *VD = DR->getDecl();
3646 if (
const auto *IV = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
3648 printTemplateArgumentList(
3649 OS, IV->getTemplateArgs().asArray(), Policy,
3650 IV->getSpecializedTemplate()->getTemplateParameters());
3658 const PrintingPolicy Policy;
3663std::pair<Expr *, std::string>
3672 Expr *FailedCond =
nullptr;
3673 for (
Expr *Term : Terms) {
3687 if (Term->EvaluateAsBooleanCondition(Succeeded,
Context) &&
3689 FailedCond = TermAsWritten;
3694 FailedCond =
Cond->IgnoreParenImpCasts();
3696 std::string Description;
3698 llvm::raw_string_ostream Out(Description);
3701 FailedBooleanConditionPrinterHelper Helper(Policy);
3702 FailedCond->
printPretty(Out, &Helper, Policy, 0,
"\n",
nullptr);
3704 return { FailedCond, Description };
3720 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
3721 return std::make_unique<CandidateCallback>(*
this);
3732 std::nullopt,
false,
3748 if (
const auto *S = UnderlyingName.getAsSubstTemplateTemplateParmPack()) {
3750 }
else if (
const auto *DTN = UnderlyingName.getAsDependentTemplateName()) {
3751 if (DTN->getName().getIdentifier())
3759 }
else if (
const auto *ATN = UnderlyingName.getAsAssumedTemplateName()) {
3761 *
this,
Scope, ATN, TemplateLoc);
3762 CorrectedName.isNull()) {
3763 Diag(TemplateLoc, diag::err_no_template) << ATN->getDeclName();
3766 Name = CorrectedName;
3774 if (ForNestedNameSpecifier)
3775 Diag(TemplateLoc, diag::err_non_type_template_in_nested_name_specifier)
3776 << isa_and_nonnull<VarTemplateDecl>(
Template) << Name << R;
3778 Diag(TemplateLoc, diag::err_template_id_not_a_type) << Name << R;
3798 dyn_cast<TypeAliasTemplateDecl>(
Template)) {
3806 SemaRef.Diag(TemplateLoc, diag::err_tag_reference_non_tag)
3836 std::optional<ContextRAII> SavedContext;
3838 SavedContext.emplace(*
this,
AliasTemplate->getDeclContext());
3843 if (CanonType.
isNull()) {
3849 if (*DeductionInfo &&
3850 (*DeductionInfo)->hasSFINAEDiagnostic() &&
3851 (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==
3852 diag::err_typename_nested_not_found_enable_if &&
3853 TemplateArgs[0].getArgument().getKind()
3856 std::string FailedDescription;
3857 std::tie(FailedCond, FailedDescription) =
3863 (*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);
3867 (*DeductionInfo)->addSFINAEDiagnostic(
3869 PDiag(diag::err_typename_nested_not_found_requirement)
3870 << FailedDescription
3878 }
else if (
auto *BTD = dyn_cast<BuiltinTemplateDecl>(
Template)) {
3882 TemplateSpecializationType::anyDependentTemplateArguments(
3891 CanonType =
Context.getCanonicalTemplateSpecializationType(
3893 Context.getCanonicalTemplateName(Name,
true),
3906 if (Ctx->isFileContext())
break;
3915 !
Record->getDescribedClassTemplate())
3924 if (CanonType != Injected)
3934 dyn_cast<ClassTemplateDecl>(
Template)) {
3937 void *InsertPos =
nullptr;
3972 "type of non-dependent specialization is not a RecordType");
3974 llvm_unreachable(
"Unhandled template kind");
3980 return Context.getTemplateSpecializationType(
3992 assert(ATN &&
"not an assumed template name");
3993 II = ATN->getDeclName().getAsIdentifierInfo();
4010 SourceLocation RAngleLoc,
bool IsCtorOrDtorName,
bool IsClassName,
4015 if (!IsCtorOrDtorName && !IsClassName && SS.
isSet()) {
4041 TemplateD, TemplateII, TemplateIILoc, LAngleLoc,
4042 TemplateArgsIn, RAngleLoc);
4049 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
4050 if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
4053 ? diag::err_out_of_line_qualified_id_type_names_constructor
4054 : diag::ext_out_of_line_qualified_id_type_names_constructor)
4065 ElaboratedKeyword, TemplateD.
get(), TemplateIILoc, TemplateArgs,
4074 TemplateIILoc, TemplateArgs);
4107 if (
const RecordType *RT =
Result->getAs<RecordType>()) {
4111 assert(Id &&
"templated class must have an identifier");
4115 Diag(TagLoc, diag::err_use_with_wrong_tag)
4152 const TemplateTypeParmType *TPT =
4154 return TPT && !
Type.hasQualifiers() &&
4155 TPT->getDepth() == Depth && TPT->getIndex() == Index;
4163 dyn_cast<NonTypeTemplateParmDecl>(DRE->
getDecl());
4169 dyn_cast_or_null<TemplateTemplateParmDecl>(
4173 llvm_unreachable(
"unexpected kind of template argument");
4179 if (Params->
size() != Args.size() || Params->
size() != SpecParams->
size())
4182 unsigned Depth = Params->
getDepth();
4184 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
4202 if (
auto *SpecNTTP =
4203 dyn_cast<NonTypeTemplateParmDecl>(SpecParams->
getParam(I))) {
4204 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(I));
4205 if (!NTTP || NTTP->getType().getCanonicalType() !=
4206 SpecNTTP->getType().getCanonicalType())
4214template<
typename PartialSpecDecl>
4216 if (Partial->getDeclContext()->isDependentContext())
4225 auto *
Template = Partial->getSpecializedTemplate();
4226 S.
Diag(Partial->getLocation(),
4227 diag::ext_partial_spec_not_more_specialized_than_primary)
4237 diag::note_partial_spec_not_more_specialized_than_primary)
4243 Template->getAssociatedConstraints(TemplateAC);
4244 Partial->getAssociatedConstraints(PartialAC);
4251 const llvm::SmallBitVector &DeducibleParams) {
4252 for (
unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
4253 if (!DeducibleParams[I]) {
4255 if (Param->getDeclName())
4256 S.
Diag(Param->getLocation(), diag::note_non_deducible_parameter)
4257 << Param->getDeclName();
4259 S.
Diag(Param->getLocation(), diag::note_non_deducible_parameter)
4266template<
typename PartialSpecDecl>
4268 PartialSpecDecl *Partial) {
4281 auto *TemplateParams = Partial->getTemplateParameters();
4282 llvm::SmallBitVector DeducibleParams(TemplateParams->size());
4284 TemplateParams->getDepth(), DeducibleParams);
4286 if (!DeducibleParams.all()) {
4287 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
4288 S.
Diag(Partial->getLocation(), diag::ext_partial_specs_not_deducible)
4290 << (NumNonDeducible > 1)
4292 Partial->getTemplateArgsAsWritten()->RAngleLoc);
4313 llvm::SmallBitVector DeducibleParams(TemplateParams->size());
4315 for (
unsigned I = 0; I != TemplateParams->size(); ++I) {
4317 auto *Param = TemplateParams->getParam(I);
4319 DeducibleParams[I] =
true;
4322 if (!DeducibleParams.all()) {
4323 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
4324 Diag(TD->
getLocation(), diag::err_deduction_guide_template_not_deducible)
4325 << (NumNonDeducible > 1);
4336 "Variable template specialization is declared with a template id.");
4353 FnTemplate = *OTS->begin();
4363 if (
const auto *DSA =
VarTemplate->getAttr<NoSpecializationsAttr>()) {
4364 auto Message = DSA->getMessage();
4365 Diag(TemplateNameLoc, diag::warn_invalid_specialization)
4367 Diag(DSA->getLoc(), diag::note_marked_here) << DSA;
4371 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
4391 TemplateArgs.
size(),
4398 !TemplateSpecializationType::anyDependentTemplateArguments(
4400 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
4407 (!
Context.getLangOpts().CPlusPlus20 ||
4413 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
4423 void *InsertPos =
nullptr;
4427 PrevDecl =
VarTemplate->findPartialSpecialization(
4453 cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
4462 VarTemplate->AddPartialSpecialization(Partial, InsertPos);
4501 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
4505 diag::note_instantiation_required_here)
4535struct PartialSpecMatchResult {
4543 if (Var->
getName() !=
"format_kind" ||
4564 bool SetWrittenArgs) {
4565 assert(
Template &&
"A variable template id without template?");
4577 if (
Template->getDeclContext()->isDependentContext() ||
4578 TemplateSpecializationType::anyDependentTemplateArguments(
4585 return Context.isSameTemplateArgument(Arg1, Arg2);
4591 !IsLibstdcxxStdFormatKind(
PP, Var) &&
4595 IsSameTemplateArg)) {
4596 Diag(TemplateNameLoc,
4597 diag::err_auto_variable_cannot_appear_in_own_initializer)
4598 << diag::ParsingInitFor::VarTemplate << Var << Var->
getType();
4603 Template->getPartialSpecializations(PartialSpecs);
4607 Partial->getTemplateArgs().asArray(),
4608 IsSameTemplateArg)) {
4609 Diag(TemplateNameLoc,
4610 diag::err_auto_variable_cannot_appear_in_own_initializer)
4611 << diag::ParsingInitFor::VarTemplatePartialSpec << Partial
4612 << Partial->getType();
4621 void *InsertPos =
nullptr;
4625 if (Spec->getType()->isUndeducedType()) {
4627 Diag(TemplateNameLoc,
4628 diag::err_auto_variable_cannot_appear_in_own_initializer)
4629 << diag::ParsingInitFor::VarTemplateExplicitSpec << Spec
4634 Diag(TemplateNameLoc, diag::err_var_template_spec_type_depends_on_self)
4635 << Spec << Spec->getType();
4649 bool AmbiguousPartialSpec =
false;
4650 typedef PartialSpecMatchResult MatchResult;
4662 Template->getPartialSpecializations(PartialSpecs);
4674 if (
Template->getMostRecentDecl()->isMemberSpecialization() &&
4675 !Partial->getMostRecentDecl()->isMemberSpecialization())
4690 Matched.push_back(PartialSpecMatchResult());
4691 Matched.back().Partial = Partial;
4696 if (Matched.size() >= 1) {
4698 if (Matched.size() == 1) {
4711 PEnd = Matched.end();
4714 PointOfInstantiation) ==
4722 PEnd = Matched.end();
4725 P->Partial, Best->Partial,
4726 PointOfInstantiation) != Best->Partial) {
4727 AmbiguousPartialSpec =
true;
4734 InstantiationPattern = Best->Partial;
4735 PartialSpecArgs = Best->Args;
4752 Decl->setTemplateArgsAsWritten(TemplateArgs);
4754 if (AmbiguousPartialSpec) {
4757 Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
4761 for (MatchResult P : Matched)
4762 Diag(P.Partial->getLocation(), diag::note_partial_spec_match)
4769 dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
4770 Decl->setInstantiationOf(D, PartialSpecArgs);
4774 assert(
Decl &&
"No variable template specialization?");
4784 *TemplateArgs,
false);
4785 if (
Decl.isInvalid())
4804 assert(
Template &&
"A variable template id without template?");
4807 Template->templateParameterKind() !=
4839 Diag(Loc, diag::err_template_missing_args)
4847 bool TemplateKeyword,
4859 bool DoCheckConstraintSatisfaction) {
4860 assert(NamedConcept &&
"A concept template id without a template?");
4867 NamedConcept, ConceptNameInfo.
getLoc(),
4886 bool AreArgsDependent =
4887 TemplateSpecializationType::anyDependentTemplateArguments(
4894 TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,
4898 if (
const auto *
Concept = dyn_cast<ConceptDecl>(NamedConcept);
4900 DoCheckConstraintSatisfaction) {
4919 Context,
CL, CSD, AreArgsDependent ?
nullptr : &Satisfaction);
4938 assert(!R.
isAmbiguous() &&
"ambiguous lookup when building templateid");
4948 bool KnownDependent =
false;
4957 KnownDependent =
true;
4975 TemplateKWLoc, TemplateArgs);
4981 R.
begin(), R.
end(), KnownDependent,
4997 assert(TemplateArgs || TemplateKWLoc.
isValid());
5001 false, TemplateKWLoc))
5030 bool EnteringContext,
5032 bool AllowInjectedClassName) {
5036 diag::warn_cxx98_compat_template_outside_of_template :
5037 diag::ext_template_outside_of_template)
5047 else if (ObjectType)
5066 bool MemberOfUnknownSpecialization;
5068 ObjectType, EnteringContext,
Result,
5069 MemberOfUnknownSpecialization);
5072 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
5073 if (!AllowInjectedClassName && SS.
isNotEmpty() && LookupRD &&
5086 diag::ext_out_of_line_qualified_id_type_names_constructor)
5094 if (!MemberOfUnknownSpecialization) {
5125 {Qualifier, Name.Identifier, TemplateKWLoc.isValid()}));
5130 {Qualifier, Name.OperatorFunctionId.Operator,
5131 TemplateKWLoc.isValid()}));
5146 diag::err_template_kw_refers_to_dependent_non_template)
5148 << TemplateKWLoc.
isValid() << TemplateKWLoc;
5185 dyn_cast<DependentScopeDeclRefExpr>(Arg.
getAsExpr())) {
5186 SS.
Adopt(ArgExpr->getQualifierLoc());
5187 NameInfo = ArgExpr->getNameInfo();
5189 dyn_cast<CXXDependentScopeMemberExpr>(Arg.
getAsExpr())) {
5190 if (ArgExpr->isImplicitAccess()) {
5191 SS.
Adopt(ArgExpr->getQualifierLoc());
5192 NameInfo = ArgExpr->getMemberNameInfo();
5201 Result.wasNotFoundInCurrentInstantiation()) {
5202 assert(SS.
getScopeRep() &&
"dependent scope expr must has a scope!");
5206 ? diag::ext_ms_template_type_arg_missing_typename
5207 : diag::err_template_arg_must_be_type_suggest)
5240 SugaredConverted.push_back(Arg);
5241 CanonicalConverted.push_back(Arg);
5247 Diag(SR.
getBegin(), diag::err_template_arg_must_be_type) << SR;
5261 ArgType->isObjCLifetimeType() &&
5269 CanonicalConverted.push_back(
5304 Output = Param->getDefaultArgument();
5318 for (
unsigned i = 0, e = Param->getDepth(); i != e; ++i)
5321 bool ForLambdaCallOperator =
false;
5322 if (
const auto *Rec = dyn_cast<CXXRecordDecl>(
Template->getDeclContext()))
5323 ForLambdaCallOperator = Rec->isLambda();
5325 !ForLambdaCallOperator);
5328 Param->getDefaultArgumentLoc(),
5329 Param->getDeclName()))
5373 for (
unsigned i = 0, e = Param->getDepth(); i != e; ++i)
5380 TemplateArgLists, Output);
5417 SugaredConverted,
SourceRange(TemplateLoc, RAngleLoc));
5424 for (
unsigned i = 0, e = Param->getDepth(); i != e; ++i)
5441 HasDefaultArg =
false;
5447 HasDefaultArg =
true;
5450 RAngleLoc, TypeParm, SugaredConverted,
5451 CanonicalConverted, Output))
5457 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
5461 HasDefaultArg =
true;
5464 RAngleLoc, NonTypeParm, SugaredConverted,
5465 CanonicalConverted, Output))
5475 HasDefaultArg =
true;
5479 *
this,
Template, TemplateKWLoc, TemplateNameLoc, RAngleLoc, TempTempParm,
5480 SugaredConverted, CanonicalConverted, QualifierLoc);
5504 TemplateName Name = TagLoc.getTypePtr()->getTemplateName(Context);
5510 TagLoc.getQualifierLoc(), TagLoc.getNameLoc());
5517 unsigned ArgumentPackIndex,
5531 QualType NTTPType = NTTP->getType();
5532 if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
5533 NTTPType = NTTP->getExpansionType(ArgumentPackIndex);
5547 if (
auto *PET = NTTPType->
getAs<PackExpansionType>()) {
5549 NTTPType =
SubstType(PET->getPattern(), MLTAL, NTTP->getLocation(),
5550 NTTP->getDeclName());
5552 NTTPType =
SubstType(NTTPType, MLTAL, NTTP->getLocation(),
5553 NTTP->getDeclName());
5560 NTTP->getLocation());
5565 auto checkExpr = [&](
Expr *E) ->
Expr * {
5569 NTTP, NTTPType, E, SugaredResult, CanonicalResult,
5581 llvm_unreachable(
"Should never see a NULL template argument here");
5585 Expr *R = checkExpr(E);
5611 if (!checkExpr(R.
get()))
5650 NTTP, NTTPType, E.
get(), SugaredResult, CanonicalResult,
5682 if (
T->isFunctionType())
5683 Diag(SR.
getBegin(), diag::err_template_arg_nontype_ambig) << SR <<
T;
5685 Diag(SR.
getBegin(), diag::err_template_arg_must_be_expr) << SR;
5691 llvm_unreachable(
"Caller must expand template argument packs");
5736 ArgLoc = ConvertedArg;
5741 llvm_unreachable(
"Should never see a NULL template argument here");
5752 Context.getCanonicalTemplateArgument(Arg));
5780 llvm_unreachable(
"non-type argument with template template parameter");
5783 llvm_unreachable(
"Caller must expand template argument packs");
5790template<
typename TemplateParmDecl>
5793 const TemplateParmDecl *D,
5798 ->getTemplateParameters()
5799 ->getParam(D->getIndex()));
5806 D->getDefaultArgumentLoc(), Modules,
5817 S.
Diag(Loc, diag::err_template_arg_list_different_arity)
5834 DefaultArgs, PartialTemplateArgs, CTAI, UpdateArgsWithConversions,
5865 unsigned ArgIdx = 0, NumArgs = NewArgs.
size();
5868 ParamEnd = Params->
end(),
5872 if (
size_t ParamIdx = Param - ParamBegin;
5875 assert(ArgIdx == NumArgs &&
"bad default argument deduction");
5877 assert(Param + DefaultArgs.
Args.size() <= ParamEnd);
5882 Context.getCanonicalTemplateArgument(DefArg));
5892 if (*Expansions == SugaredArgumentPack.size()) {
5897 SugaredArgumentPack.clear();
5901 CanonicalArgumentPack.clear();
5906 }
else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
5908 Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5920 dyn_cast<NonTypeTemplateParmDecl>(*Param);
5922 auto TL = NTTP->getTypeSourceInfo()
5927 for (
const auto &UPP : Unexpanded) {
5928 auto *TST = UPP.first.dyn_cast<
const TemplateSpecializationType *>();
5933 Diag(TL.getEllipsisLoc(),
5934 diag::err_unsupported_builtin_template_pack_expansion)
5935 << TST->getTemplateName();
5940 if (ArgIdx < NumArgs) {
5942 bool NonPackParameter =
5952 if (!(*Param)->isTemplateParameterPack() ||
5959 RAngleLoc, SugaredArgumentPack.size(), CTAI,
5964 clang::isSubstitutedDefaultArgument(
Context, Arg, *Param,
5974 RAngleLoc, SugaredArgumentPack.size(), CTAI,
5981 if (ArgIsExpansion && NonPackParameter) {
5987 diag::err_template_expansion_into_fixed_list)
5999 if (ArgIsExpansion && (CTAI.
MatchingTTP || NonPackParameter)) {
6003 if (!SugaredArgumentPack.empty()) {
6007 SugaredArgumentPack.begin(),
6008 SugaredArgumentPack.end());
6009 SugaredArgumentPack.clear();
6012 CanonicalArgumentPack.begin(),
6013 CanonicalArgumentPack.end());
6014 CanonicalArgumentPack.clear();
6017 while (ArgIdx < NumArgs) {
6021 Context.getCanonicalTemplateArgument(Arg));
6028 if ((*Param)->isTemplateParameterPack()) {
6043 if (PartialTemplateArgs) {
6044 if ((*Param)->isTemplateParameterPack() && !SugaredArgumentPack.empty()) {
6055 if ((*Param)->isTemplateParameterPack()) {
6057 "Should have dealt with this already");
6062 if (Param + 1 != ParamEnd) {
6064 (
Template->getMostRecentDecl()->getKind() != Decl::Kind::Concept) &&
6065 "Concept templates must have parameter packs at the end.");
6071 SugaredArgumentPack.clear();
6075 CanonicalArgumentPack.clear();
6094 if (!HasDefaultArg) {
6099 dyn_cast<NonTypeTemplateParmDecl>(*Param))
6133 if (isTemplateTemplateParameter)
6148 while (ArgIdx < NumArgs &&
6149 NewArgs[ArgIdx].
getArgument().isPackExpansion()) {
6153 Context.getCanonicalTemplateArgument(Arg));
6159 if (ArgIdx < NumArgs) {
6160 Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
6171 if (UpdateArgsWithConversions)
6172 TemplateArgs = std::move(NewArgs);
6174 if (!PartialTemplateArgs) {
6181 if (
auto *TD = dyn_cast<TemplateDecl>(NewContext))
6183 auto *RD = dyn_cast<CXXRecordDecl>(NewContext);
6187 dyn_cast_or_null<CXXMethodDecl>(
Template->getTemplatedDecl()))
6188 ThisQuals =
Method->getMethodQualifiers();
6212 class UnnamedLocalNoLinkageFinder
6213 :
public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
6221 UnnamedLocalNoLinkageFinder(
Sema &S,
SourceRange SR) : S(S), SR(SR) { }
6224 return T.isNull() ?
false : inherited::Visit(
T.getTypePtr());
6227#define TYPE(Class, Parent) \
6228 bool Visit##Class##Type(const Class##Type *);
6229#define ABSTRACT_TYPE(Class, Parent) \
6230 bool Visit##Class##Type(const Class##Type *) { return false; }
6231#define NON_CANONICAL_TYPE(Class, Parent) \
6232 bool Visit##Class##Type(const Class##Type *) { return false; }
6233#include "clang/AST/TypeNodes.inc"
6235 bool VisitTagDecl(
const TagDecl *Tag);
6240bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(
const BuiltinType*) {
6244bool UnnamedLocalNoLinkageFinder::VisitComplexType(
const ComplexType*
T) {
6245 return Visit(
T->getElementType());
6248bool UnnamedLocalNoLinkageFinder::VisitPointerType(
const PointerType*
T) {
6249 return Visit(
T->getPointeeType());
6252bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
6254 return Visit(
T->getPointeeType());
6257bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
6259 return Visit(
T->getPointeeType());
6262bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
6264 return Visit(
T->getPointeeType());
6267bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
6269 if (Visit(
T->getPointeeType()))
6271 if (
auto *RD =
T->getMostRecentCXXRecordDecl())
6272 return VisitTagDecl(RD);
6273 return VisitNestedNameSpecifier(
T->getQualifier());
6276bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
6278 return Visit(
T->getElementType());
6281bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
6283 return Visit(
T->getElementType());
6286bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
6288 return Visit(
T->getElementType());
6291bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
6293 return Visit(
T->getElementType());
6296bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
6298 return Visit(
T->getElementType());
6301bool UnnamedLocalNoLinkageFinder::VisitDependentSizedMatrixType(
6303 return Visit(
T->getElementType());
6306bool UnnamedLocalNoLinkageFinder::VisitDependentAddressSpaceType(
6308 return Visit(
T->getPointeeType());
6311bool UnnamedLocalNoLinkageFinder::VisitVectorType(
const VectorType*
T) {
6312 return Visit(
T->getElementType());
6315bool UnnamedLocalNoLinkageFinder::VisitDependentVectorType(
6317 return Visit(
T->getElementType());
6320bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(
const ExtVectorType*
T) {
6321 return Visit(
T->getElementType());
6324bool UnnamedLocalNoLinkageFinder::VisitConstantMatrixType(
6326 return Visit(
T->getElementType());
6329bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
6331 for (
const auto &A :
T->param_types()) {
6336 return Visit(
T->getReturnType());
6339bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
6341 return Visit(
T->getReturnType());
6344bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
6349bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(
const TypeOfExprType*) {
6353bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(
const TypeOfType*
T) {
6354 return Visit(
T->getUnmodifiedType());
6357bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(
const DecltypeType*) {
6361bool UnnamedLocalNoLinkageFinder::VisitPackIndexingType(
6362 const PackIndexingType *) {
6366bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
6367 const UnaryTransformType*) {
6371bool UnnamedLocalNoLinkageFinder::VisitAutoType(
const AutoType *
T) {
6372 return Visit(
T->getDeducedType());
6375bool UnnamedLocalNoLinkageFinder::VisitDeducedTemplateSpecializationType(
6376 const DeducedTemplateSpecializationType *
T) {
6377 return Visit(
T->getDeducedType());
6380bool UnnamedLocalNoLinkageFinder::VisitRecordType(
const RecordType*
T) {
6381 return VisitTagDecl(
T->getOriginalDecl()->getDefinitionOrSelf());
6384bool UnnamedLocalNoLinkageFinder::VisitEnumType(
const EnumType*
T) {
6385 return VisitTagDecl(
T->getOriginalDecl()->getDefinitionOrSelf());
6388bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
6389 const TemplateTypeParmType*) {
6393bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
6394 const SubstTemplateTypeParmPackType *) {
6398bool UnnamedLocalNoLinkageFinder::VisitSubstBuiltinTemplatePackType(
6399 const SubstBuiltinTemplatePackType *) {
6403bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
6404 const TemplateSpecializationType*) {
6408bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
6409 const InjectedClassNameType*
T) {
6410 return VisitTagDecl(
T->getOriginalDecl()->getDefinitionOrSelf());
6413bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
6414 const DependentNameType*
T) {
6415 return VisitNestedNameSpecifier(
T->getQualifier());
6418bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
6419 const PackExpansionType*
T) {
6420 return Visit(
T->getPattern());
6423bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(
const ObjCObjectType *) {
6427bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
6432bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
6437bool UnnamedLocalNoLinkageFinder::VisitAtomicType(
const AtomicType*
T) {
6438 return Visit(
T->getValueType());
6441bool UnnamedLocalNoLinkageFinder::VisitPipeType(
const PipeType*
T) {
6445bool UnnamedLocalNoLinkageFinder::VisitBitIntType(
const BitIntType *
T) {
6449bool UnnamedLocalNoLinkageFinder::VisitArrayParameterType(
6451 return VisitConstantArrayType(
T);
6454bool UnnamedLocalNoLinkageFinder::VisitDependentBitIntType(
6459bool UnnamedLocalNoLinkageFinder::VisitTagDecl(
const TagDecl *Tag) {
6460 if (
Tag->getDeclContext()->isFunctionOrMethod()) {
6461 S.Diag(SR.getBegin(), S.getLangOpts().CPlusPlus11
6462 ? diag::warn_cxx98_compat_template_arg_local_type
6463 : diag::ext_template_arg_local_type)
6464 << S.Context.getCanonicalTagType(Tag) << SR;
6468 if (!
Tag->hasNameForLinkage()) {
6469 S.Diag(SR.getBegin(),
6470 S.getLangOpts().CPlusPlus11 ?
6471 diag::warn_cxx98_compat_template_arg_unnamed_type :
6472 diag::ext_template_arg_unnamed_type) << SR;
6473 S.Diag(
Tag->getLocation(), diag::note_template_unnamed_type_here);
6480bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
6491 llvm_unreachable(
"Invalid NestedNameSpecifier::Kind!");
6494bool UnnamedLocalNoLinkageFinder::VisitHLSLAttributedResourceType(
6495 const HLSLAttributedResourceType *
T) {
6496 if (
T->hasContainedType() && Visit(
T->getContainedType()))
6498 return Visit(
T->getWrappedType());
6501bool UnnamedLocalNoLinkageFinder::VisitHLSLInlineSpirvType(
6502 const HLSLInlineSpirvType *
T) {
6503 for (
auto &Operand :
T->getOperands())
6505 if (Visit(
Operand.getResultType()))
6511 assert(ArgInfo &&
"invalid TypeSourceInfo");
6517 return Diag(SR.
getBegin(), diag::err_variably_modified_template_arg) << Arg;
6518 }
else if (
Context.hasSameUnqualifiedType(Arg,
Context.OverloadTy)) {
6519 return Diag(SR.
getBegin(), diag::err_template_arg_overload_type) << SR;
6530 UnnamedLocalNoLinkageFinder Finder(*
this, SR);
6531 (void)Finder.Visit(CanonArg);
6548 Decl *Entity =
nullptr) {
6554 if (Entity && Entity->hasAttr<DLLImportAttr>())
6559 "Incomplete parameter type in isNullPointerValueTemplateArgument!");
6572 EvalResult.
Diag = &Notes;
6580 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
6581 diag::note_invalid_subexpr_in_const_expr) {
6582 DiagLoc = Notes[0].first;
6586 S.
Diag(DiagLoc, diag::err_template_arg_not_address_constant)
6588 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
6589 S.
Diag(Notes[I].first, Notes[I].second);
6607 bool ObjCLifetimeConversion;
6610 ObjCLifetimeConversion))
6615 S.
Diag(Arg->
getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
6634 std::string Code =
"static_cast<" + ParamType.
getAsString() +
">(";
6635 S.
Diag(Arg->
getExprLoc(), diag::err_template_arg_untyped_null_constant)
6655 bool ObjCLifetimeConversion;
6659 ObjCLifetimeConversion)) {
6664 if (!ParamRef->getPointeeType()->isFunctionType()) {
6674 unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
6675 unsigned ArgQuals = ArgType.getCVRQualifiers();
6677 if ((ParamQuals | ArgQuals) != ParamQuals) {
6679 diag::err_template_arg_ref_bind_ignores_quals)
6716 bool AddressTaken =
false;
6723 bool ExtWarnMSTemplateArg =
false;
6726 while (
UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
6728 if (UnOpKind == UO_Deref)
6729 ExtWarnMSTemplateArg =
true;
6730 if (UnOpKind == UO_AddrOf || UnOpKind == UO_Deref) {
6733 FirstOpKind = UnOpKind;
6734 FirstOpLoc = UnOp->getOperatorLoc();
6740 if (ExtWarnMSTemplateArg)
6744 if (FirstOpKind == UO_AddrOf)
6745 AddressTaken =
true;
6749 assert(FirstOpKind == UO_Deref);
6772 bool ExtraParens =
false;
6774 if (!
Invalid && !ExtraParens) {
6780 Arg =
Parens->getSubExpr();
6784 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
6788 if (UnOp->getOpcode() == UO_AddrOf) {
6789 Arg = UnOp->getSubExpr();
6790 AddressTaken =
true;
6791 AddrOpLoc = UnOp->getOperatorLoc();
6796 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
6801 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg))
6802 Entity = DRE->getDecl();
6804 Entity = CUE->getGuidDecl();
6811 S.
Diag(Arg->
getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
6814 CanonicalConverted =
6831 CanonicalConverted =
6852 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Entity)) {
6853 if (!Method->isStatic()) {
6862 VarDecl *Var = dyn_cast<VarDecl>(Entity);
6863 MSGuidDecl *Guid = dyn_cast<MSGuidDecl>(Entity);
6866 if (!
Func && !Var && !Guid) {
6878 ? diag::warn_cxx98_compat_template_arg_object_internal
6879 : diag::ext_template_arg_object_internal)
6881 S.
Diag(Entity->
getLocation(), diag::note_template_arg_internal_object)
6886 S.
Diag(Entity->
getLocation(), diag::note_template_arg_internal_object)
6915 S.
Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
6921 S.
Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
6963 CanonicalConverted =
6977 Expr *Arg = ResultArg;
6978 bool ObjCLifetimeConversion;
6990 bool ExtraParens =
false;
6992 if (!
Invalid && !ExtraParens) {
6998 Arg =
Parens->getSubExpr();
7002 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
7007 if (UnOp->getOpcode() == UO_AddrOf) {
7008 DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());
7014 else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
7020 CanonicalConverted =
7024 CanonicalConverted =
7043 S.
Diag(ResultArg->
getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
7055 ObjCLifetimeConversion)) {
7062 S.
Diag(ResultArg->
getBeginLoc(), diag::err_template_arg_not_convertible)
7070 diag::err_template_arg_not_pointer_to_member_form)
7079 ->isImplicitObjectMemberFunction()) &&
7080 "Only non-static member pointers can make it here");
7086 CanonicalConverted =
7091 CanonicalConverted =
7099 S.
Diag(Arg->
getBeginLoc(), diag::err_template_arg_not_pointer_to_member_form)
7119 auto *ArgPE = dyn_cast<PackExpansionExpr>(Arg);
7120 Expr *DeductionArg = ArgPE ? ArgPE->getPattern() : Arg;
7121 auto setDeductionArg = [&](
Expr *NewDeductionArg) {
7122 DeductionArg = NewDeductionArg;
7126 DeductionArg, ArgPE->getEllipsisLoc(), ArgPE->getNumExpansions());
7134 bool IsDeduced = DeducedT && DeducedT->getDeducedType().isNull();
7140 Context.getTrivialTypeSourceInfo(ParamType, Param->getLocation());
7145 DeductionArg->
getBeginLoc(),
false, DeductionArg);
7146 Expr *Inits[1] = {DeductionArg};
7153 Param->getTemplateDepth() + 1);
7169 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param))
7171 diag::err_non_type_template_parm_type_deduction_failure)
7172 << Param->getDeclName() << NTTP->getType() << Arg->
getType()
7178 assert(!ParamType.
isNull() &&
"substituting DependentTy can't fail");
7186 if (ParamType.
isNull()) {
7194 "non-type template parameter type cannot be qualified");
7208 setDeductionArg(E.
get());
7212 Context.getCanonicalTemplateArgument(SugaredConverted));
7221 : !
Context.hasSameUnqualifiedType(ParamType,
7227 Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
7240 if (ArgPE && !StrictCheck) {
7243 Context.getCanonicalTemplateArgument(SugaredConverted));
7257 Context.hasSameUnqualifiedType(ParamType, InnerArg->
getType())) {
7259 if (
auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
7268 CanonicalConverted =
7269 Context.getCanonicalTemplateArgument(SugaredConverted);
7279 bool IsConvertedConstantExpression =
true;
7282 StartLoc,
false, DeductionArg);
7283 Expr *Inits[1] = {DeductionArg};
7298 IsConvertedConstantExpression =
false;
7307 if (IsConvertedConstantExpression) {
7309 DeductionArg, ParamType,
7317 ArgResult = DeductionArg;
7323 setDeductionArg(ArgResult.
get());
7325 CanonicalConverted =
7326 Context.getCanonicalTemplateArgument(SugaredConverted);
7333 false, PreNarrowingValue);
7336 setDeductionArg(ArgResult.
get());
7338 if (
Value.isLValue()) {
7357 if (
Value.hasLValuePath() &&
Value.getLValuePath().size() == 1 && VD &&
7359 Value.getLValuePath()[0].getAsArrayIndex() == 0 &&
7363 CanonicalConverted =
7364 Context.getCanonicalTemplateArgument(SugaredConverted);
7367 CanonicalConverted =
7376 if (!
Value.hasLValuePath() ||
Value.getLValuePath().size() ||
7377 Value.isLValueOnePastTheEnd()) {
7378 Diag(StartLoc, diag::err_non_type_template_arg_subobject)
7383 "null reference should not be a constant expression");
7385 "non-null value of type nullptr_t?");
7389 if (
Value.isAddrLabelDiff())
7390 return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
7394 CanonicalConverted =
7395 Context.getCanonicalTemplateArgument(SugaredConverted);
7398 CanonicalConverted =
7405 assert(!ArgPE && !StrictCheck);
7437 Arg = ArgResult.
get();
7442 CanonicalConverted =
7443 Context.getCanonicalTemplateArgument(SugaredConverted);
7452 IntegerType = ED->getIntegerType();
7454 ?
Context.getIntWidth(IntegerType)
7455 :
Context.getTypeSize(IntegerType));
7458 CanonicalConverted =
7466 Arg = ArgResult.
get();
7478 if (!
ArgType->isIntegralOrEnumerationType()) {
7479 Diag(Arg->
getBeginLoc(), diag::err_template_arg_not_integral_or_enumeral)
7493 return S.
Diag(Loc, diag::err_template_arg_not_ice) <<
T;
7518 Diag(StartLoc, diag::err_template_arg_not_convertible)
7531 CanonicalConverted =
7532 Context.getCanonicalTemplateArgument(SugaredConverted);
7538 IntegerType = ED->getIntegerType();
7544 unsigned AllowedBits =
Context.getTypeSize(IntegerType);
7545 if (
Value.getBitWidth() != AllowedBits)
7549 llvm::APSInt OldValue =
Value;
7554 ?
Context.getIntWidth(IntegerType)
7555 :
Context.getTypeSize(IntegerType);
7556 if (
Value.getBitWidth() != AllowedBits)
7562 (OldValue.isSigned() && OldValue.isNegative())) {
7570 unsigned RequiredBits;
7572 RequiredBits = OldValue.getActiveBits();
7573 else if (OldValue.isUnsigned())
7574 RequiredBits = OldValue.getActiveBits() + 1;
7576 RequiredBits = OldValue.getSignificantBits();
7577 if (RequiredBits > AllowedBits) {
7587 CanonicalConverted =
7637 *
this, Param, ParamType, Arg, SugaredConverted,
7638 CanonicalConverted))
7644 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
7655 "Only object pointers allowed here");
7658 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
7670 assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&
7671 "Only object references allowed here");
7675 ParamRefType->getPointeeType(),
7690 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
7699 CanonicalConverted =
7700 Context.getCanonicalTemplateArgument(SugaredConverted);
7707 << Arg->
getType() << ParamType;
7715 Diag(Arg->
getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
7729 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
7752 unsigned DiagFoundKind = 0;
7754 if (
auto *TTP = llvm::dyn_cast<TemplateTemplateParmDecl>(
Template)) {
7755 switch (TTP->templateParameterKind()) {
7766 Kind = TTP->templateParameterKind();
7782 assert(
false &&
"Unexpected Decl");
7785 if (Kind == Param->templateParameterKind()) {
7789 unsigned DiagKind = 0;
7790 switch (Param->templateParameterKind()) {
7803 Diag(
Template->getLocation(), diag::note_template_arg_refers_to_template_here)
7817 bool *StrictPackMatch) {
7824 assert(Name.
isDependent() &&
"Non-dependent template isn't a declaration?");
7851 if (ParamsAC.empty())
7854 Template->getAssociatedConstraints(TemplateAC);
7856 bool IsParamAtLeastAsConstrained;
7858 IsParamAtLeastAsConstrained))
7860 if (!IsParamAtLeastAsConstrained) {
7862 diag::err_template_template_parameter_not_at_least_as_constrained)
7864 Diag(Param->getLocation(), diag::note_entity_declared_at) << Param;
7874 unsigned HereDiagID,
7875 unsigned ExternalDiagID) {
7880 llvm::raw_svector_ostream Out(Str);
7888 std::optional<SourceRange> ParamRange) {
7891 diag::note_template_decl_external);
7892 if (ParamRange && ParamRange->isValid()) {
7894 "Parameter range has location when Decl does not");
7901 diag::note_template_param_external);
7917 ParamType =
Context.getArrayDecayedType(ParamType);
7919 ParamType =
Context.getPointerType(ParamType);
7928 ? CK_NullToMemberPointer
7929 : CK_NullToPointer);
7932 "Only declaration template arguments permitted here");
7969 "arg for class template param not a template parameter object");
7974 "unexpected type for decl template argument");
7976 dyn_cast_if_present<NonTypeTemplateParmDecl>(
TemplateParam)) {
7977 QualType TemplateParamType = NTTP->getType();
7978 const AutoType *AT = TemplateParamType->
getAs<AutoType>();
7979 if (AT && AT->isDecltypeAuto()) {
7991 "value kind mismatch for non-type template argument");
8010 "unexpected conversion required for non-type template argument");
8037 T = ED->getIntegerType();
8040 if (
T->isAnyCharacterType()) {
8042 if (
T->isWideCharType())
8046 else if (
T->isChar16Type())
8048 else if (
T->isChar32Type())
8054 }
else if (
T->isBooleanType()) {
8088 llvm_unreachable(
"unexpected template argument value");
8113 return MakeInitList(
8126 return MakeInitList(Elts);
8131 llvm_unreachable(
"Unexpected APValue kind.");
8140 if (
T->isReferenceType()) {
8141 T =
T->getPointeeType();
8147 llvm_unreachable(
"Unhandled APValue::ValueKind enum");
8159 llvm_unreachable(
"not a non-type template argument");
8177 llvm_unreachable(
"Unhandled TemplateArgument::ArgKind enum");
8184 const NamedDecl *OldInstFrom,
bool Complain,
8189 unsigned NextDiag = diag::err_template_param_different_kind;
8190 if (TemplateArgLoc.
isValid()) {
8191 S.
Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
8192 NextDiag = diag::note_template_param_different_kind;
8194 S.
Diag(
New->getLocation(), NextDiag)
8209 unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
8210 if (TemplateArgLoc.
isValid()) {
8211 S.
Diag(TemplateArgLoc,
8212 diag::err_template_arg_template_params_mismatch);
8213 NextDiag = diag::note_template_parameter_pack_non_pack;
8219 S.
Diag(
New->getLocation(), NextDiag)
8220 << ParamKind <<
New->isParameterPack();
8229 dyn_cast<NonTypeTemplateParmDecl>(Old)) {
8237 (!OldNTTP->getType()->isDependentType() &&
8247 unsigned NextDiag = diag::err_template_nontype_parm_different_type;
8248 if (TemplateArgLoc.
isValid()) {
8249 S.
Diag(TemplateArgLoc,
8250 diag::err_template_arg_template_params_mismatch);
8251 NextDiag = diag::note_template_nontype_parm_different_type;
8255 S.
Diag(OldNTTP->getLocation(),
8256 diag::note_template_nontype_parm_prev_declaration)
8257 << OldNTTP->getType();
8267 dyn_cast<TemplateTemplateParmDecl>(Old)) {
8273 OldTTP->getTemplateParameters(), Complain,
8284 const Expr *NewC =
nullptr, *OldC =
nullptr;
8288 NewC = TC->getImmediatelyDeclaredConstraint();
8290 OldC = TC->getImmediatelyDeclaredConstraint();
8293 ->getPlaceholderTypeConstraint())
8296 ->getPlaceholderTypeConstraint())
8299 llvm_unreachable(
"unexpected template parameter type");
8301 auto Diagnose = [&] {
8303 diag::err_template_different_type_constraint);
8305 diag::note_template_prev_declaration) << 0;
8308 if (!NewC != !OldC) {
8335 unsigned NextDiag = diag::err_template_param_list_different_arity;
8336 if (TemplateArgLoc.
isValid()) {
8337 S.
Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
8338 NextDiag = diag::note_template_param_list_different_arity;
8340 S.
Diag(
New->getTemplateLoc(), NextDiag)
8341 << (
New->size() > Old->
size())
8353 if (Old->
size() !=
New->size()) {
8370 OldParmEnd = Old->
end();
8371 OldParm != OldParmEnd; ++OldParm, ++NewParm) {
8372 if (NewParm == NewParmEnd) {
8379 OldInstFrom, Complain, Kind,
8385 if (NewParm != NewParmEnd) {
8394 const Expr *NewRC =
New->getRequiresClause();
8399 diag::err_template_different_requires_clause);
8401 diag::note_template_prev_declaration) << 0;
8404 if (!NewRC != !OldRC) {
8440 Diag(Range.getBegin(), diag::err_template_linkage) << Range;
8442 Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
8462 if (RD->isLocalClass())
8464 diag::err_template_inside_local_class)
8472 diag::err_template_outside_namespace_or_class_scope)
8483 return Record->getTemplateSpecializationKind();
8484 if (
FunctionDecl *Function = dyn_cast<FunctionDecl>(D))
8485 return Function->getTemplateSpecializationKind();
8486 if (
VarDecl *Var = dyn_cast<VarDecl>(D))
8539 S.
Diag(Loc, diag::err_template_spec_unknown_kind)
8549 S.
Diag(Loc, diag::err_template_spec_decl_function_scope)
8564 : DC->
Equals(SpecializedContext))) {
8566 S.
Diag(Loc, diag::err_template_spec_redecl_global_scope)
8567 << EntityKind << Specialized;
8570 int Diag = diag::err_template_spec_redecl_out_of_scope;
8572 Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
8573 S.
Diag(Loc,
Diag) << EntityKind << Specialized
8574 << ND << isa<CXXRecordDecl>(ND);
8577 S.
Diag(Specialized->getLocation(), diag::note_specialized_entity);
8591 DependencyChecker Checker(Depth,
true);
8592 Checker.TraverseStmt(E);
8595 return Checker.MatchLoc;
8601 DependencyChecker Checker(Depth,
true);
8602 Checker.TraverseTypeLoc(TL);
8605 return Checker.MatchLoc;
8613 bool HasError =
false;
8614 for (
unsigned I = 0; I != NumArgs; ++I) {
8617 S, TemplateNameLoc, Param, Args[I].pack_begin(),
8618 Args[I].pack_size(), IsDefaultArgument))
8635 ArgExpr = Expansion->getPattern();
8639 ArgExpr = ICE->getSubExpr();
8649 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
8653 if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(ArgExpr);
8675 if (ParamUseRange.
isValid()) {
8676 if (IsDefaultArgument) {
8677 S.
Diag(TemplateNameLoc,
8678 diag::err_dependent_non_type_arg_in_partial_spec);
8680 diag::note_dependent_non_type_default_arg_in_partial_spec)
8684 diag::err_dependent_non_type_arg_in_partial_spec)
8691 Param->getDepth(), Param->getTypeSourceInfo()->getTypeLoc());
8692 if (ParamUseRange.
isValid()) {
8694 diag::err_dependent_typed_non_type_arg_in_partial_spec)
8695 << Param->getType();
8714 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
8716 = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->
getParam(I));
8721 Param, &TemplateArgs[I],
8722 1, I >= NumExplicit))
8746 Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
8752 if (
const auto *DSA =
ClassTemplate->getAttr<NoSpecializationsAttr>()) {
8753 auto Message = DSA->getMessage();
8754 Diag(TemplateNameLoc, diag::warn_invalid_specialization)
8756 Diag(DSA->getLoc(), diag::note_marked_here) << DSA;
8764 bool isMemberSpecialization =
false;
8765 bool isPartialSpecialization =
false;
8770 TemplateNameLoc, &TemplateId,
8782 KWLoc, TemplateNameLoc, SS, &TemplateId, TemplateParameterLists,
8797 if (TemplateParams && TemplateParams->
size() > 0) {
8798 isPartialSpecialization =
true;
8801 Diag(KWLoc, diag::err_partial_specialization_friend)
8809 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
8812 if (TTP->hasDefaultArgument()) {
8813 Diag(TTP->getDefaultArgumentLoc(),
8814 diag::err_default_arg_in_partial_spec);
8815 TTP->removeDefaultArgument();
8818 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
8819 if (NTTP->hasDefaultArgument()) {
8820 Diag(NTTP->getDefaultArgumentLoc(),
8821 diag::err_default_arg_in_partial_spec)
8822 << NTTP->getDefaultArgument().getSourceRange();
8823 NTTP->removeDefaultArgument();
8829 diag::err_default_arg_in_partial_spec)
8835 }
else if (TemplateParams) {
8837 Diag(KWLoc, diag::err_template_spec_friend)
8844 "should have a 'template<>' for this decl");
8851 "Invalid enum tag in class template spec!");
8855 Diag(KWLoc, diag::err_use_with_wrong_tag)
8860 diag::note_previous_use);
8869 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
8871 isPartialSpecialization
8887 if (isPartialSpecialization) {
8889 TemplateArgs.
size(),
8896 !TemplateSpecializationType::anyDependentTemplateArguments(
8898 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
8900 isPartialSpecialization =
false;
8905 void *InsertPos =
nullptr;
8908 if (isPartialSpecialization)
8922 isPartialSpecialization))
8925 if (!isPartialSpecialization) {
8933 if (TemplateParameterLists.size() > 0) {
8935 TemplateParameterLists);
8942 Context.getCanonicalTemplateSpecializationType(
8949 (!
Context.getLangOpts().CPlusPlus20 ||
8958 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
8966 TemplateParameterLists.data());
8971 cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
8974 Context, Kind, DC, KWLoc, TemplateNameLoc, TemplateParams,
8978 if (TemplateParameterLists.size() > 1 && SS.
isSet()) {
8980 Context, TemplateParameterLists.drop_back(1));
8984 ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
9013 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
9017 diag::note_instantiation_required_here)
9032 bool HiddenDefVisible =
false;
9033 if (Def && SkipBody &&
9037 if (!HiddenDefVisible && Hidden)
9060 if (ModulePrivateLoc.
isValid())
9062 << (isPartialSpecialization? 1 : 0)
9130 diag::err_concept_decls_may_only_appear_in_global_namespace_scope);
9134 if (TemplateParameterLists.size() > 1) {
9135 Diag(NameLoc, diag::err_concept_extra_headers);
9141 if (Params->
size() == 0) {
9142 Diag(NameLoc, diag::err_concept_no_parameters);
9149 ParamEnd = Params->
end();
9150 ParamIt != ParamEnd; ++ParamIt) {
9151 Decl const *Param = *ParamIt;
9152 if (Param->isParameterPack()) {
9153 if (++ParamIt == ParamEnd)
9155 Diag(Param->getLocation(),
9156 diag::err_template_param_pack_must_be_last_template_parameter);
9167 Diag(NameLoc, diag::err_concept_no_associated_constraints);
9204 Expr *ConstraintExpr,
9206 assert(!
C->hasDefinition() &&
"Concept already defined");
9208 C->setInvalidDecl();
9211 C->setDefinition(ConstraintExpr);
9222 bool AddToScope =
true;
9226 if (!WasAlreadyAdded && AddToScope)
9239 auto *OldConcept = dyn_cast<ConceptDecl>(
Previous.getRepresentativeDecl()->getUnderlyingDecl());
9241 auto *Old =
Previous.getRepresentativeDecl();
9249 bool IsSame =
Context.isSameEntity(NewDecl, OldConcept);
9251 Diag(NewDecl->
getLocation(), diag::err_redefinition_different_concept)
9275 if (
auto *CE = llvm::dyn_cast<ConceptDecl>(
Concept);
9276 CE && !CE->isInvalidDecl() && !CE->hasDefinition()) {
9277 Diag(Loc, diag::err_recursive_concept) << CE;
9278 Diag(CE->getLocation(), diag::note_declared_at);
9291 D->
dropAttrs<DLLImportAttr, DLLExportAttr>();
9294 FD->setInlineSpecified(
false);
9305 for (
Decl *Prev = D; Prev && !PrevDiagLoc.
isValid();
9306 Prev = Prev->getPreviousDecl()) {
9307 PrevDiagLoc = Prev->getLocation();
9309 assert(PrevDiagLoc.
isValid() &&
9310 "Explicit instantiation without point of instantiation?");
9320 bool &HasNoEffect) {
9321 HasNoEffect =
false;
9328 "previous declaration must be implicit!");
9341 if (PrevPointOfInstantiation.
isInvalid()) {
9345 PrevDecl,
Context.getTargetInfo().getTriple().isOSCygMing());
9354 PrevPointOfInstantiation.
isValid()) &&
9355 "Explicit instantiation without point of instantiation?");
9369 Diag(NewLoc, diag::err_specialization_after_instantiation)
9371 Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
9376 llvm_unreachable(
"The switch over PrevTSK must be exhaustive.");
9406 diag::err_explicit_instantiation_declaration_after_definition);
9412 diag::note_explicit_instantiation_definition_here);
9416 llvm_unreachable(
"Unexpected TemplateSpecializationKind!");
9432 Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
9435 diag::note_previous_template_specialization);
9466 ? diag::ext_explicit_instantiation_duplicate
9467 : diag::err_explicit_instantiation_duplicate)
9470 diag::note_previous_explicit_instantiation);
9476 llvm_unreachable(
"Missing specialization/instantiation case?");
9486 enum DiscardReason { NotAFunctionTemplate, NotAMemberOfEnclosing };
9492 DiscardedCandidates.push_back(std::make_pair(NotAFunctionTemplate, D));
9499 DiscardedCandidates.push_back(std::make_pair(NotAMemberOfEnclosing, D));
9507 Diag(FD->
getLocation(), diag::err_dependent_function_template_spec_no_match)
9509 for (
auto &P : DiscardedCandidates)
9510 Diag(P.second->getLocation(),
9511 diag::note_dependent_function_template_spec_discard_reason)
9512 << P.first << IsFriend;
9517 ExplicitTemplateArgs);
9530 llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>
9531 ConvertedTemplateArgs;
9554 if (
auto *NewMD = dyn_cast<CXXMethodDecl>(FD);
9555 !
getLangOpts().CPlusPlus14 && NewMD && NewMD->isConstexpr() &&
9557 auto *OldMD = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
9558 if (OldMD && OldMD->isConst()) {
9568 if (ExplicitTemplateArgs)
9569 Args = *ExplicitTemplateArgs;
9582 ExplicitTemplateArgs ? &Args :
nullptr, FT,
Specialization, Info);
9587 I.getPair(), FunTmpl->getTemplatedDecl(),
9601 CUDA().IdentifyTarget(FD,
true)) {
9603 I.getPair(), FunTmpl->getTemplatedDecl(),
9610 if (ExplicitTemplateArgs)
9619 if (QualifiedFriend && Candidates.
empty()) {
9625 if (
auto *OldFD = dyn_cast<FunctionDecl>(OldND->getUnderlyingDecl()))
9636 PDiag(diag::err_function_template_spec_ambiguous)
9637 << FD->
getDeclName() << (ExplicitTemplateArgs !=
nullptr),
9638 PDiag(diag::note_function_template_spec_matched));
9647 const auto *DSA = PT->getAttr<NoSpecializationsAttr>()) {
9648 auto Message = DSA->getMessage();
9650 << PT << !Message.empty() << Message;
9651 Diag(DSA->getLoc(), diag::note_marked_here) << DSA;
9679 auto *SpecializationFPT =
9690 assert(SpecInfo &&
"Function template specialization info missing?");
9728 bool HasNoEffect =
false;
9743 !isFriend || (InstFrom && InstFrom->getDependentSpecializationInfo())) {
9757 "This must be the only existing declaration of this specialization");
9772 FD->setFunctionTemplateSpecialization(
9775 ExplicitTemplateArgs ? &ConvertedTemplateArgs[
Specialization] :
nullptr);
9794 assert(!
Member->isTemplateDecl() && !
Member->getDescribedTemplate() &&
9795 "Only for non-template members");
9798 NamedDecl *FoundInstantiation =
nullptr;
9808 auto *
Method = dyn_cast<CXXMethodDecl>(Candidate->getUnderlyingDecl());
9826 Method->getTrailingRequiresClause() &&
9830 !Satisfaction.IsSatisfied))
9833 Candidates.
addDecl(Candidate);
9837 if (Candidates.
empty())
9854 FoundInstantiation = *Best;
9855 Instantiation = BestMethod;
9872 Diag(
Member->getLocation(), diag::err_function_member_spec_ambiguous)
9873 <<
Member << (InstantiatedFrom ? InstantiatedFrom : Instantiation);
9874 for (
NamedDecl *Candidate : Candidates) {
9875 Candidate = Candidate->getUnderlyingDecl();
9876 Diag(Candidate->getLocation(), diag::note_function_member_spec_matched)
9884 (PrevVar = dyn_cast<VarDecl>(
Previous.getFoundDecl())))
9886 FoundInstantiation =
Previous.getRepresentativeDecl();
9887 Instantiation = PrevVar;
9894 (PrevRecord = dyn_cast<CXXRecordDecl>(
Previous.getFoundDecl()))) {
9895 FoundInstantiation =
Previous.getRepresentativeDecl();
9896 Instantiation = PrevRecord;
9903 (PrevEnum = dyn_cast<EnumDecl>(
Previous.getFoundDecl()))) {
9904 FoundInstantiation =
Previous.getRepresentativeDecl();
9905 Instantiation = PrevEnum;
9911 if (!Instantiation) {
9936 Previous.addDecl(FoundInstantiation);
9941 if (!InstantiatedFrom) {
9942 Diag(
Member->getLocation(), diag::err_spec_member_not_instantiated)
9954 assert(MSInfo &&
"Member specialization info missing?");
9956 bool HasNoEffect =
false;
9968 Instantiation,
Member->getLocation(),
9974 if (
auto *MemberFunction = dyn_cast<FunctionDecl>(
Member)) {
9980 if (InstantiationFunction->
isDeleted()) {
9983 InstantiationFunction);
9989 MemberFunction->setInstantiationOfMemberFunction(
9991 }
else if (
auto *MemberVar = dyn_cast<VarDecl>(
Member)) {
9992 MemberVar->setInstantiationOfStaticDataMember(
9994 }
else if (
auto *MemberClass = dyn_cast<CXXRecordDecl>(
Member)) {
9995 MemberClass->setInstantiationOfMemberClass(
9997 }
else if (
auto *MemberEnum = dyn_cast<EnumDecl>(
Member)) {
9998 MemberEnum->setInstantiationOfMemberEnum(
10001 llvm_unreachable(
"unknown member specialization kind");
10007 Previous.addDecl(FoundInstantiation);
10016template<
typename DeclT>
10027 OrigD->setLocation(Loc);
10033 if (Instantiation ==
Member)
10036 if (
auto *
Function = dyn_cast<CXXMethodDecl>(Instantiation))
10038 else if (
auto *Var = dyn_cast<VarDecl>(Instantiation))
10040 else if (
auto *
Record = dyn_cast<CXXRecordDecl>(Instantiation))
10042 else if (
auto *
Enum = dyn_cast<EnumDecl>(Instantiation))
10045 llvm_unreachable(
"unknown member specialization kind");
10053 bool WasQualifiedName) {
10058 S.
Diag(InstLoc, diag::err_explicit_instantiation_in_class)
10071 if (WasQualifiedName) {
10072 if (CurContext->
Encloses(OrigContext))
10079 if (
NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) {
10080 if (WasQualifiedName)
10083 diag::err_explicit_instantiation_out_of_scope :
10084 diag::warn_explicit_instantiation_out_of_scope_0x)
10089 diag::err_explicit_instantiation_unqualified_wrong_namespace :
10090 diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
10095 diag::err_explicit_instantiation_must_be_global :
10096 diag::warn_explicit_instantiation_must_be_global_0x)
10105 bool WasQualifiedName,
10112 S.
Diag(InstLoc, diag::err_explicit_instantiation_internal_linkage) << D;
10140 NNS =
T->getPrefix();
10149 auto *A = cast_or_null<InheritableAttr>(
getDLLAttr(Def));
10150 assert(A &&
"dllExportImportClassTemplateSpecialization called "
10151 "on Def without dllexport or dllimport");
10156 "delayed exports present at explicit instantiation");
10160 for (
auto &B : Def->
bases()) {
10161 if (
auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
10162 B.getType()->getAsCXXRecordDecl()))
10182 "Invalid enum tag in class template explicit instantiation!");
10188 Diag(TemplateNameLoc, diag::err_tag_reference_non_tag) << TD << NTK << Kind;
10194 Kind,
false, KWLoc,
10196 Diag(KWLoc, diag::err_use_with_wrong_tag)
10201 diag::note_previous_use);
10214 !
Context.getTargetInfo().getTriple().isOSCygMing()) {
10218 if (AL.getKind() == ParsedAttr::AT_DLLExport) {
10220 diag::warn_attribute_dllexport_explicit_instantiation_decl);
10221 Diag(AL.getLoc(), diag::note_attribute);
10226 if (
auto *A =
ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {
10228 diag::warn_attribute_dllexport_explicit_instantiation_decl);
10229 Diag(A->getLocation(), diag::note_attribute);
10235 bool DLLImportExplicitInstantiationDef =
false;
10237 Context.getTargetInfo().getCXXABI().isMicrosoft()) {
10240 ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
10242 if (AL.getKind() == ParsedAttr::AT_DLLImport)
10244 if (AL.getKind() == ParsedAttr::AT_DLLExport) {
10252 DLLImportExplicitInstantiationDef =
true;
10271 void *InsertPos =
nullptr;
10279 Context.getTargetInfo().getTriple().isOSCygMing()) {
10283 if (AL.getKind() == ParsedAttr::AT_DLLExport) {
10285 diag::warn_attribute_dllexport_explicit_instantiation_def);
10297 bool HasNoEffect =
false;
10300 PrevDecl, PrevDecl_TSK,
10317 PrevDecl =
nullptr;
10321 DLLImportExplicitInstantiationDef) {
10323 HasNoEffect =
false;
10338 if (
const auto *A = PrevDecl->
getAttr<MSInheritanceAttr>()) {
10340 Clone->setInherited(
true);
10346 if (!HasNoEffect && !PrevDecl) {
10359 bool PreviouslyDLLExported =
Specialization->hasAttr<DLLExportAttr>();
10384 = cast_or_null<ClassTemplateSpecializationDecl>(
10396 Def = cast_or_null<ClassTemplateSpecializationDecl>(
10404 DLLImportExplicitInstantiationDef)) {
10409 Context.getTargetInfo().shouldDLLImportComdatSymbols()) {
10415 A->setInherited(
true);
10423 bool NewlyDLLExported =
10424 !PreviouslyDLLExported &&
Specialization->hasAttr<DLLExportAttr>();
10426 Context.getTargetInfo().shouldDLLImportComdatSymbols()) {
10440 "Def and Specialization should match for implicit instantiation");
10447 Context.getTargetInfo().getTriple().isOSCygMing() &&
10448 PrevDecl->
hasAttr<DLLExportAttr>()) {
10472 bool Owned =
false;
10473 bool IsDependent =
false;
10481 assert(!IsDependent &&
"explicit instantiation of dependent name not yet handled");
10487 assert(!Tag->isEnum() &&
"shouldn't see enumerations here");
10489 if (Tag->isInvalidDecl())
10495 Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
10497 Diag(
Record->getLocation(), diag::note_nontemplate_decl_here);
10508 Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
10523 = cast_or_null<CXXRecordDecl>(
Record->getPreviousDecl());
10524 if (!PrevDecl &&
Record->getDefinition())
10528 bool HasNoEffect =
false;
10529 assert(MSInfo &&
"No member specialization information?");
10541 = cast_or_null<CXXRecordDecl>(
Record->getDefinition());
10549 Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
10550 << 0 <<
Record->getDeclName() <<
Record->getDeclContext();
10560 RecordDef = cast_or_null<CXXRecordDecl>(
Record->getDefinition());
10591 diag::err_explicit_instantiation_requires_name)
10630 diag::err_explicit_instantiation_inline :
10631 diag::warn_explicit_instantiation_inline_0x)
10637 diag::err_explicit_instantiation_constexpr);
10673 if (!PrevTemplate) {
10680 Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
10687 diag::err_explicit_instantiation_data_member_not_instantiated)
10702 Diag(
T->getTypeLoc().getBeginLoc(),
10703 diag::err_auto_not_allowed_var_inst);
10712 diag::err_explicit_instantiation_without_template_id)
10714 Diag(PrevTemplate->getLocation(),
10715 diag::note_explicit_instantiation_here);
10725 TemplateArgs,
true);
10754 diag::ext_explicit_instantiation_without_qualified_id)
10762 bool HasNoEffect =
false;
10764 PrevTSK, POI, HasNoEffect))
10767 if (!HasNoEffect) {
10770 if (
auto *VTSD = dyn_cast<VarTemplatePartialSpecializationDecl>(Prev)) {
10771 VTSD->setExternKeywordLoc(ExternLoc);
10772 VTSD->setTemplateKeywordLoc(TemplateLoc);
10786 Diag(
T->getTypeLoc().getBeginLoc(),
10787 diag::err_invalid_var_template_spec_type)
10788 << 0 << PrevTemplate << R << Prev->
getType();
10789 Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
10790 << 2 << PrevTemplate->getDeclName();
10795 return (
Decl*)
nullptr;
10800 bool HasExplicitTemplateArgs =
false;
10804 HasExplicitTemplateArgs =
true;
10819 if (!HasExplicitTemplateArgs) {
10823 if (
Context.hasSameUnqualifiedType(
Method->getType(), Adjusted)) {
10824 if (
Method->getPrimaryTemplate()) {
10828 C.FoundDecl = P.getPair();
10832 if (
Method->getTrailingRequiresClause() &&
10851 FunTmpl, (HasExplicitTemplateArgs ? &TemplateArgs :
nullptr), R,
10882 if (!NonTemplateMatches.
empty()) {
10893 Msg = diag::err_explicit_instantiation_ambiguous;
10897 Msg = diag::err_explicit_instantiation_no_candidate;
10913 TemplateMatches.
begin(), TemplateMatches.
end(),
10915 PDiag(diag::err_explicit_instantiation_not_known) << Name,
10916 PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
10917 PDiag(diag::note_explicit_instantiation_candidate));
10933 if (FPT->hasExceptionSpec()) {
10935 diag::err_mismatched_exception_spec_explicit_instantiation;
10937 DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;
10940 PDiag(diag::note_explicit_instantiation_here),
10951 diag::err_explicit_instantiation_member_function_not_instantiated)
10960 if (!PrevDecl &&
Specialization->isThisDeclarationADefinition())
10964 bool HasNoEffect =
false;
10975 return (
Decl*)
nullptr;
10986 if (
auto *RD = dyn_cast<CXXRecordDecl>(
Specialization->getDeclContext()))
10987 if (RD->getIdentifier() && RD->getIdentifier()->isStr(
"valarray") &&
10988 RD->isInStdNamespace())
10989 return (
Decl*)
nullptr;
10999 Context.getTargetInfo().getCXXABI().isMicrosoft())
11023 diag::ext_explicit_instantiation_without_qualified_id)
11033 return (
Decl*)
nullptr;
11042 assert(Name &&
"Expected a name in a dependent tag");
11051 Diag(NameLoc, diag::err_dependent_tag_decl)
11078 DiagCompat(TypenameLoc, diag_compat::typename_outside_of_template)
11086 TypenameLoc, QualifierLoc, II, IdLoc, &TSI,
11102 ? diag::compat_cxx11_typename_outside_of_template
11103 : diag::compat_pre_cxx11_typename_outside_of_template)
11111 if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
11112 Diag(TemplateIILoc,
11113 diag::ext_out_of_line_qualified_id_type_names_constructor)
11115 << (TemplateKWLoc.
isValid() ? 1 : 0 );
11126 TemplateIn.
get(), TemplateIILoc, TemplateArgs,
11136 TemplateIILoc, TemplateArgs);
11146 if (!II.
isStr(
"type"))
11154 auto EnableIfTSTLoc =
11156 if (!EnableIfTSTLoc || EnableIfTSTLoc.getNumArgs() == 0)
11158 const TemplateSpecializationType *EnableIfTST = EnableIfTSTLoc.
getTypePtr();
11162 EnableIfTST->getTemplateName().getAsTemplateDecl();
11163 if (!EnableIfDecl || EnableIfTST->isIncompleteType())
11169 if (!EnableIfII || !EnableIfII->
isStr(
"enable_if"))
11173 CondRange = EnableIfTSTLoc.getArgLoc(0).getSourceRange();
11177 if (EnableIfTSTLoc.getArgLoc(0).getArgument().getKind()
11181 Cond = EnableIfTSTLoc.getArgLoc(0).getSourceExpression();
11197 bool DeducedTSTContext) {
11199 DeducedTSTContext);
11206 TL.setElaboratedKeywordLoc(KeywordLoc);
11207 TL.setQualifierLoc(QualifierLoc);
11208 TL.setNameLoc(IILoc);
11211 TL.setElaboratedKeywordLoc(KeywordLoc);
11212 TL.setQualifierLoc(QualifierLoc);
11213 TL.setNameLoc(IILoc);
11217 assert(!QualifierLoc);
11221 TL.setElaboratedKeywordLoc(KeywordLoc);
11222 TL.setQualifierLoc(QualifierLoc);
11223 TL.setNameLoc(IILoc);
11244 SS.
Adopt(QualifierLoc);
11247 if (QualifierLoc) {
11274 unsigned DiagID = 0;
11275 Decl *Referenced =
nullptr;
11276 switch (
Result.getResultKind()) {
11287 std::string FailedDescription;
11288 std::tie(FailedCond, FailedDescription) =
11292 diag::err_typename_nested_not_found_requirement)
11293 << FailedDescription
11299 diag::err_typename_nested_not_found_enable_if)
11300 << Ctx << CondRange;
11304 DiagID = Ctx ? diag::err_typename_nested_not_found
11305 : diag::err_unknown_typename;
11314 Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
11315 << Name << Ctx << FullRange;
11317 = dyn_cast<UnresolvedUsingValueDecl>(
Result.getRepresentativeDecl())){
11319 Diag(Loc, diag::note_using_value_decl_missing_typename)
11359 assert(!QualifierLoc);
11362 return Context.getTypeDeclType(
11372 if (!DeducedTSTContext) {
11375 Diag(IILoc, diag::err_dependent_deduced_tst)
11377 <<
QualType(Qualifier.getAsType(), 0);
11379 Diag(IILoc, diag::err_deduced_tst)
11387 return Context.getDeducedTemplateSpecializationType(
11392 DiagID = Ctx ? diag::err_typename_nested_not_type
11393 : diag::err_typename_not_type;
11394 Referenced =
Result.getFoundDecl();
11398 DiagID = Ctx ? diag::err_typename_nested_not_type
11399 : diag::err_typename_not_type;
11400 Referenced = *
Result.begin();
11412 Diag(IILoc, DiagID) << FullRange << Name << Ctx;
11414 Diag(IILoc, DiagID) << FullRange << Name;
11417 Ctx ? diag::note_typename_member_refers_here
11418 : diag::note_typename_refers_here)
11425 class CurrentInstantiationRebuilder
11433 CurrentInstantiationRebuilder(
Sema &SemaRef,
11437 Loc(Loc), Entity(Entity) { }
11445 return T.isNull() || !
T->isInstantiationDependentType();
11450 SourceLocation getBaseLocation() {
return Loc; }
11453 DeclarationName getBaseEntity() {
return Entity; }
11457 void setBase(SourceLocation Loc, DeclarationName Entity) {
11459 this->Entity = Entity;
11472 if (!
T || !
T->getType()->isInstantiationDependentType())
11475 CurrentInstantiationRebuilder Rebuilder(*
this, Loc, Name);
11476 return Rebuilder.TransformType(
T);
11480 CurrentInstantiationRebuilder Rebuilder(*
this, E->
getExprLoc(),
11482 return Rebuilder.TransformExpr(E);
11493 = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
11503 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
11512 = dyn_cast<TemplateTemplateParmDecl>(Param)) {
11514 TTP->getTemplateParameters()))
11556 unsigned NumArgs) {
11558 llvm::raw_svector_ostream Out(Str);
11560 if (!Params || Params->
size() == 0 || NumArgs == 0)
11561 return std::string();
11563 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
11573 Out << Id->getName();
11585 return std::string(Out.str());
11593 auto LPT = std::make_unique<LateParsedTemplate>();
11596 LPT->Toks.swap(Toks);
11643class ExplicitSpecializationVisibilityChecker {
11652 : S(S), Loc(Loc), Kind(Kind) {}
11655 if (
auto *FD = dyn_cast<FunctionDecl>(ND))
11656 return checkImpl(FD);
11657 if (
auto *RD = dyn_cast<CXXRecordDecl>(ND))
11658 return checkImpl(RD);
11659 if (
auto *VD = dyn_cast<VarDecl>(ND))
11660 return checkImpl(VD);
11661 if (
auto *ED = dyn_cast<EnumDecl>(ND))
11662 return checkImpl(ED);
11666 void diagnose(NamedDecl *D,
bool IsPartialSpec) {
11667 auto Kind = IsPartialSpec ? Sema::MissingImportKind::PartialSpecialization
11668 : Sema::MissingImportKind::ExplicitSpecialization;
11669 const bool Recover =
true;
11674 if (Modules.empty())
11680 bool CheckMemberSpecialization(
const NamedDecl *D) {
11681 return Kind == Sema::AcceptableKind::Visible
11686 bool CheckExplicitSpecialization(
const NamedDecl *D) {
11687 return Kind == Sema::AcceptableKind::Visible
11692 bool CheckDeclaration(
const NamedDecl *D) {
11709 template<
typename SpecDecl>
11710 void checkImpl(SpecDecl *Spec) {
11711 bool IsHiddenExplicitSpecialization =
false;
11715 if constexpr (std::is_same_v<SpecDecl, FunctionDecl>)
11716 SpecKind = Spec->getTemplateSpecializationKindForInstantiation();
11718 IsHiddenExplicitSpecialization = Spec->getMemberSpecializationInfo()
11719 ? !CheckMemberSpecialization(Spec)
11720 : !CheckExplicitSpecialization(Spec);
11722 checkInstantiated(Spec);
11725 if (IsHiddenExplicitSpecialization)
11726 diagnose(Spec->getMostRecentDecl(),
false);
11729 void checkInstantiated(FunctionDecl *FD) {
11734 void checkInstantiated(CXXRecordDecl *RD) {
11735 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
11739 auto From = SD->getSpecializedTemplateOrPartial();
11740 if (
auto *TD = From.dyn_cast<ClassTemplateDecl *>())
11742 else if (
auto *TD =
11743 From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
11744 if (!CheckDeclaration(TD))
11745 diagnose(TD,
true);
11750 void checkInstantiated(VarDecl *RD) {
11751 auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
11755 auto From = SD->getSpecializedTemplateOrPartial();
11756 if (
auto *TD = From.dyn_cast<VarTemplateDecl *>())
11758 else if (
auto *TD =
11759 From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
11760 if (!CheckDeclaration(TD))
11761 diagnose(TD,
true);
11766 void checkInstantiated(EnumDecl *FD) {}
11768 template<
typename TemplDecl>
11769 void checkTemplate(TemplDecl *TD) {
11770 if (TD->isMemberSpecialization()) {
11771 if (!CheckMemberSpecialization(TD))
11772 diagnose(TD->getMostRecentDecl(),
false);
11782 ExplicitSpecializationVisibilityChecker(*
this, Loc,
11792 ExplicitSpecializationVisibilityChecker(*
this, Loc,
11800 if (
const auto *FD = dyn_cast<FunctionDecl>(N)) {
11808 if (!CSC.isInstantiationRecord() || CSC.PointOfInstantiation.isInvalid())
11810 return CSC.PointOfInstantiation;
This file provides AST data structures related to concepts.
Defines the clang::ASTContext interface.
Defines enum values for all the target-independent builtin functions.
static Decl::Kind getKind(const Decl *D)
This file defines the classes used to store parsed information about declaration-specifiers and decla...
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.
@ ForVisibleRedeclaration
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
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 TemplateName resolveAssumedTemplateNameAsType(Sema &S, Scope *Scope, const AssumedTemplateStorage *ATN, SourceLocation NameLoc)
static QualType builtinCommonTypeImpl(Sema &S, ElaboratedTypeKeyword Keyword, TemplateName BaseTemplate, SourceLocation TemplateLoc, ArrayRef< TemplateArgument > Ts)
static bool isSameAsPrimaryTemplate(TemplateParameterList *Params, TemplateParameterList *SpecParams, ArrayRef< TemplateArgument > Args)
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 QualType checkBuiltinTemplateIdType(Sema &SemaRef, ElaboratedTypeKeyword Keyword, BuiltinTemplateDecl *BTD, ArrayRef< TemplateArgument > Converted, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
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 bool CheckTemplateArgumentIsCompatibleWithParameter(Sema &S, NamedDecl *Param, QualType ParamType, Expr *ArgIn, Expr *Arg, QualType ArgType)
Checks whether the given template argument is compatible with its template parameter.
static bool isInVkNamespace(const RecordType *RT)
static ExprResult formImmediatelyDeclaredConstraint(Sema &S, NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, NamedDecl *NamedConcept, NamedDecl *FoundDecl, SourceLocation LAngleLoc, SourceLocation RAngleLoc, QualType ConstrainedType, SourceLocation ParamNameLoc, ArgumentLocAppender Appender, SourceLocation EllipsisLoc)
static TemplateArgumentListInfo makeTemplateArgumentListInfo(Sema &S, TemplateIdAnnotation &TemplateId)
Convert the parser's template argument list representation into our form.
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 SpirvOperand checkHLSLSpirvTypeOperand(Sema &SemaRef, QualType OperandArg, SourceLocation Loc)
static SourceLocation DiagLocForExplicitInstantiation(NamedDecl *D, SourceLocation PointOfInstantiation)
Compute the diagnostic location for an explicit instantiation.
static bool RemoveLookupResult(LookupResult &R, NamedDecl *C)
static bool CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S, NamedDecl *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 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 NullPointerValueKind isNullPointerValueTemplateArgument(Sema &S, NamedDecl *Param, QualType ParamType, Expr *Arg, Decl *Entity=nullptr)
Determine whether the given template argument is a null pointer value of the appropriate type.
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 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 CheckTemplateArgumentPointerToMember(Sema &S, NamedDecl *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 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.
Allows QualTypes to be sorted and hence used in maps and sets.
static const TemplateArgument & getArgument(const TemplateArgument &A)
C Language Family Type Representation.
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()
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
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.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const LangOptions & getLangOpts() const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
TemplateName getQualifiedTemplateName(NestedNameSpecifier Qualifier, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
QualType getUnconstrainedType(QualType T) const
Remove any type constraints from a template parameter type, for equivalence comparison of template pa...
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
SourceLocation getLAngleLoc() const
NamedDecl * getFoundDecl() const
TemplateDecl * getNamedConcept() const
DeclarationNameInfo getConceptNameInfo() 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.
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr)
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
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.
NestedNameSpecifier getScopeRep() const
Retrieve the representation of the nested-name-specifier.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
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...
static CanQual< Type > CreateUnsafe(QualType Other)
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
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
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, CanQualType CanonInjectedTST, 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...
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, bool StrictPackMatch, ClassTemplateSpecializationDecl *PrevDecl)
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.
Complex values, per C99 6.2.5p11.
Declaration of a C++20 concept.
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, TemplateDecl *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...
bool WantExpressionKeywords
bool WantRemainingKeywords
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 ...
bool isStdNamespace() const
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 semantically 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
void ClearStorageClassSpecs()
bool isNoreturnSpecified() const
SourceLocation getStorageClassSpecLoc() const
SCS getStorageClassSpec() const
SourceLocation getBeginLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation getNoreturnSpecLoc() const
SourceLocation getExplicitSpecLoc() const
TSCS getThreadStorageClassSpec() const
ParsedAttributes & getAttributes()
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.
NameKind getNameKind() const
Determine what kind of name this is.
void setTypeSourceInfo(TypeSourceInfo *TI)
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
SourceLocation getIdentifierLoc() const
SourceLocation getEllipsisLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
bool isInvalidType() const
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
const IdentifierInfo * getIdentifier() const
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)
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 vector type where either the type or size is dependent.
virtual bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc)
virtual bool TraverseTypeLoc(TypeLoc TL, bool TraverseQualifier=true)
virtual bool TraverseStmt(MaybeConst< Stmt > *S)
virtual bool TraverseTemplateName(TemplateName Template)
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...
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 containsErrors() const
Whether this expression contains subexpressions which had errors.
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
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.
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...
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, NamedDecl *Param)
Create the initialization entity for a template parameter.
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].
Represents a linkage specification.
A stack-allocated class that identifies which local variable declaration instantiations are present i...
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.
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.
UnresolvedSetImpl::iterator iterator
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
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.
std::string getQualifiedNameAsString() const
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.
NamespaceAndPrefixLoc getAsNamespaceAndPrefix() const
NestedNameSpecifier getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
TypeLoc castAsTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
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.
const Type * getAsType() const
@ MicrosoftSuper
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Global
The global specifier '::'. There is no stored value.
@ Type
A type, stored as a Type*.
@ Namespace
A namespace-like entity, stored as a NamespaceBaseDecl*.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
SourceLocation getDefaultArgumentLoc() const
Retrieve the location of the default argument, if any.
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
QualType getExpansionType(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
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)
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)
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
Represents a pointer to an Objective C object.
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.
bool isVarDeclReference() const
TemplateTemplateParmDecl * getTemplateTemplateDecl() const
bool isConceptReference() const
ArrayRef< TemplateArgumentLoc > template_arguments() const
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.
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.
ParsedTemplateArgument()
Build an empty template argument.
KindType getKind() const
Determine what kind of template argument we have.
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.
SourceLocation getTemplateKwLoc() const
Retrieve the location of the template argument.
Expr * getAsExpr() const
Retrieve the non-type template argument's expression.
SourceLocation getNameLoc() const
Retrieve the location of the template argument.
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.
bool NeedsStdLibCxxWorkaroundBefore(std::uint64_t FixedVersion)
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.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
QualType getNonPackExpansionType() const
Remove an outer pack expansion type (if any) from 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.
void setMemberSpecialization()
Note that this member template is a specialization.
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.
DeclContext * getEntity() const
Get the entity corresponding to this scope.
bool isTemplateParamScope() const
isTemplateParamScope - Return true if this scope is a C++ template parameter scope.
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Scope * getTemplateParamParent()
@ 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 DiagCompat(SourceLocation Loc, unsigned CompatDiagId, bool DeferHint=false)
Emit a compatibility diagnostic.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
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.
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)
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)
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 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...
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)
TemplateName SubstTemplateName(SourceLocation TemplateKWLoc, NestedNameSpecifierLoc &QualifierLoc, TemplateName Name, SourceLocation NameLoc, const MultiLevelTemplateArgumentList &TemplateArgs)
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.
ExprResult BuildSubstNonTypeTemplateParmExpr(Decl *AssociatedDecl, const NonTypeTemplateParmDecl *NTTP, SourceLocation loc, TemplateArgument Replacement, UnsignedOrNone PackIndex, bool Final)
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)
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.
VarTemplateSpecializationDecl * BuildVarTemplateInstantiation(VarTemplateDecl *VarTemplate, VarDecl *FromVar, const TemplateArgumentList *PartialSpecArgs, SmallVectorImpl< TemplateArgument > &Converted, SourceLocation PointOfInstantiation, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *StartingScope=nullptr)
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(NamedDecl *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 InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain, bool PrimaryStrictPackMatch)
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...
bool isRedefinitionAllowedFor(NamedDecl *D, NamedDecl **Suggested, bool &Visible)
Determine if D has a definition which allows we redefine it in current TU.
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.
ExprResult CheckConceptTemplateId(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &ConceptNameInfo, NamedDecl *FoundDecl, TemplateDecl *NamedConcept, const TemplateArgumentListInfo *TemplateArgs, bool DoCheckConstraintSatisfaction=true)
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 isTemplateTemplateParameterAtLeastAsSpecializedAs(TemplateParameterList *PParam, TemplateDecl *PArg, TemplateDecl *AArg, const DefaultArguments &DefaultArgs, SourceLocation ArgLoc, bool PartialOrdering, bool *StrictPackMatch)
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 CheckDeclCompatibleWithTemplateTemplate(TemplateDecl *Template, TemplateTemplateParmDecl *Param, const TemplateArgumentLoc &Arg)
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)
ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee, SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, UnsignedOrNone NumExpansions)
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
bool CheckConstraintSatisfaction(ConstrainedDeclOrNestedRequirement Entity, ArrayRef< AssociatedConstraint > AssociatedConstraints, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction, const ConceptReference *TopLevelConceptId=nullptr, Expr **ConvertedExpr=nullptr)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
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_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 CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, CheckTemplateArgumentInfo &CTAI, CheckTemplateArgumentKind CTAK)
Check that the given template argument corresponds to the given template parameter.
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
ArrayRef< InventedTemplateParameterInfo > getInventedParameterInfos() const
void inferGslOwnerPointerAttribute(CXXRecordDecl *Record)
Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
NamedDecl * ActOnTemplateTemplateParameter(Scope *S, SourceLocation TmpLoc, TemplateNameKind Kind, bool TypenameKeyword, TemplateParameterList *Params, SourceLocation EllipsisLoc, IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth, unsigned Position, SourceLocation EqualLoc, ParsedTemplateArgument DefaultArg)
ActOnTemplateTemplateParameter - Called when a C++ template template parameter (e....
FPOptions & getCurFPFeatures()
Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, TranslationUnitKind TUKind=TU_Complete, CodeCompleteConsumer *CompletionConsumer=nullptr)
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.
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...
bool isPotentialImplicitMemberAccess(const CXXScopeSpec &SS, LookupResult &R, bool IsAddressOfOperand)
Check whether an expression might be an implicit class member access.
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument.
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.
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.
bool hasExplicitCallingConv(QualType T)
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)
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,...
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...
bool IsFunctionConversion(QualType FromType, QualType ToType, bool *DiscardingCFIUncheckedCallee=nullptr, bool *AddingCFIUncheckedCallee=nullptr) const
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
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.
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...
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, TemplateDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
TemplateArgumentLoc SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, SourceLocation TemplateKWLoc, SourceLocation TemplateNameLoc, 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...
void FilterAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true)
TypeSourceInfo * SubstAutoTypeSourceInfoDependent(TypeSourceInfo *TypeWithAuto)
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...
QualType CheckTemplateIdType(ElaboratedTypeKeyword Keyword, TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, Scope *Scope, bool ForNestedNameSpecifier)
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.
void InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
void MarkUnusedFileScopedDecl(const DeclaratorDecl *D)
If it's a file scoped decl that must warn if not used, keep track of it.
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=AllowFoldKind::No)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, bool IsAddressOfOperand)
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param, TemplateParameterList *Params, TemplateArgumentLoc &Arg, bool PartialOrdering, bool *StrictPackMatch)
Check a template argument against its corresponding template template parameter.
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 inParameterMappingSubstitution() const
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 CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
void makeMergedDefinitionVisible(NamedDecl *ND)
Make a merged definition of an existing hidden definition ND visible at the specified location.
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AvailabilityMergeKind::Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation, NamedDecl *Instantiation, bool InstantiatedFromMember, const NamedDecl *Pattern, const NamedDecl *PatternDef, TemplateSpecializationKind TSK, bool Complain=true, bool *Unreachable=nullptr)
Determine whether we would be unable to instantiate this template (because it either has no definitio...
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
DeclResult CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation TemplateNameLoc, const TemplateArgumentListInfo &TemplateArgs, bool SetWrittenArgs)
Get the specialization of the given variable template corresponding to the specified argument list,...
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.
bool IsAtLeastAsConstrained(const NamedDecl *D1, MutableArrayRef< AssociatedConstraint > AC1, const NamedDecl *D2, MutableArrayRef< AssociatedConstraint > AC2, bool &Result)
Check whether the given declaration's associated constraints are at least as constrained than another...
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_TemplateTemplateParameterPack
@ TPC_FriendFunctionTemplate
@ TPC_ClassTemplateMember
@ TPC_FriendClassTemplate
@ TPC_FriendFunctionTemplateDefinition
friend class InitializationSequence
void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We've found a use of a templated declaration that would trigger an implicit instantiation.
QualType SubstAutoTypeDependent(QualType TypeWithAuto)
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)
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope.
void CheckConceptRedefinition(ConceptDecl *NewDecl, LookupResult &Previous, bool &AddToScope)
TypeResult ActOnTemplateIdType(Scope *S, ElaboratedTypeKeyword ElaboratedKeyword, SourceLocation ElaboratedKeywordLoc, 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)
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.
ExprResult CheckVarOrConceptTemplateTemplateId(const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, TemplateTemplateParmDecl *Template, SourceLocation TemplateLoc, const TemplateArgumentListInfo *TemplateArgs)
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.
bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(const NamedDecl *D1, ArrayRef< AssociatedConstraint > AC1, const NamedDecl *D2, ArrayRef< AssociatedConstraint > AC2)
If D1 was not at least as constrained as D2, but would've been if a pair of atomic constraints involv...
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, const DefaultArguments &DefaultArgs, bool PartialTemplateArgs, CheckTemplateArgumentInfo &CTAI, bool UpdateArgsWithConversions=true, bool *ConstraintsNotSatisfied=nullptr)
Check that the given template arguments can be provided to the given template, converting the argumen...
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
OpaquePtr< TemplateName > TemplateTy
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 checkTypeDeclType(DeclContext *LookupCtx, DiagCtorKind DCK, TypeDecl *TD, SourceLocation NameLoc)
Returns the TypeDeclType for the given type declaration, as ASTContext::getTypeDeclType would,...
void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD)
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
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 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
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)
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
TemplateArgumentLocInfo getLocInfo() const
const TemplateArgument & getArgument() const
SourceLocation getTemplateNameLoc() const
TypeSourceInfo * getTypeSourceInfo() const
SourceRange getSourceRange() const LLVM_READONLY
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Represents a template argument.
ArrayRef< TemplateArgument > getPackAsArray() const
Return the array of arguments in this template argument pack.
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
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.
DeducedTemplateStorage * getAsDeducedTemplateName() const
Retrieve the deduced template info, if any.
bool isNull() const
Determine whether this template name is NULL.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template declarations that this template name refers to,...
AssumedTemplateStorage * getAsAssumedTemplateName() const
Retrieve information on a name that has been assumed to be a template-name in order to permit a call ...
std::pair< TemplateName, DefaultArguments > getTemplateDeclAndDefaultArgs() const
Retrieves the underlying template name that this template name refers to, along with the deduced defa...
UsingShadowDecl * getAsUsingShadowDecl() const
Retrieve the using shadow declaration through which the underlying template declaration is introduced...
bool isDependent() const
Determines whether this is a dependent template name.
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.
NamedDecl ** iterator
Iterates through the template parameters in this list.
bool hasAssociatedConstraints() const
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< AssociatedConstraint > &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.
void set(SourceLocation ElaboratedKeywordLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKeywordLoc, SourceLocation NameLoc, SourceLocation LAngleLoc, SourceLocation RAngleLoc)
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.
TemplateNameKind templateParameterKind() const
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
void setInheritedDefaultArgument(const ASTContext &C, TemplateTemplateParmDecl *Prev)
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, TemplateNameKind ParameterKind, bool Typename, TemplateParameterList *Params)
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.
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...
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.
void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint, UnsignedOrNone ArgPackSubstIndex)
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
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, UnsignedOrNone NumExpanded=std::nullopt)
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.
const Type * getTypeForDecl() const
SourceLocation getBeginLoc() const LLVM_READONLY
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
TypeSpecTypeLoc pushTypeSpec(QualType T)
Pushes space for a typespec TypeLoc.
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...
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.
SourceLocation getNameLoc() const
void setNameLoc(SourceLocation Loc)
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.
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 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 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 isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
bool isMemberPointerType() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
EnumDecl * getAsEnumDecl() const
Retrieves the EnumDecl this type refers to.
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
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
const T * getAs() const
Member-template getAs<specific type>'.
bool isNullPtrType() const
bool isRecordType() const
QualType getUnderlyingType() const
Wrapper for source info for typedefs.
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.
struct OFI OperatorFunctionId
When Kind == IK_OperatorFunctionId, the overloaded operator that we parsed.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
const IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId,...
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
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.
Wrapper for source info for unresolved typename using decls.
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,...
VarDecl * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
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.
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.
__inline void unsigned int _2
@ OS
Indicates that the tracking object is a descendant of a referenced-counted OSObject,...
The JSON file list parser is used to communicate input to InstallAPI.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
TypeSpecifierType
Specifies the kind of type.
@ Match
This is not an overload because the signature exactly matches an existing declaration.
bool isa(CodeGen::Address addr)
OpaquePtr< TemplateName > ParsedTemplateTy
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
@ 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)
@ 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.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ Found
Name lookup found a single declaration that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
@ ovl_fail_constraints_not_satisfied
This candidate was not viable because its associated constraints were not satisfied.
@ TemplateName
The identifier is a template name. FIXME: Add an annotation for that.
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.
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
bool isPackProducingBuiltinTemplateName(TemplateName N)
@ 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+.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
ActionResult< Decl * > DeclResult
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
DynamicRecursiveASTVisitorBase< true > ConstDynamicRecursiveASTVisitor
StorageClass
Storage classes.
UnsignedOrNone getExpandedPackSize(const NamedDecl *Param)
Check whether the template parameter is a pack expansion, and if so, determine the number of paramete...
@ 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.
ActionResult< ParsedType > TypeResult
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
const FunctionProtoType * T
@ Template
We are parsing a template declaration.
TagTypeKind
The kind of a tag type.
@ Enum
The "enum" keyword.
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...
@ Keyword
The name has been typo-corrected to a keyword.
@ Type
The name was classified as a type.
CastKind
CastKind - The kind of operation required for a conversion.
SourceRange getTemplateParamsRange(TemplateParameterList const *const *Params, unsigned NumParams)
Retrieves the range of the given template parameter lists.
MutableArrayRef< ParsedTemplateArgument > ASTTemplateArgsPtr
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.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
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.
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
DynamicRecursiveASTVisitorBase< false > DynamicRecursiveASTVisitor
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.
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,...
U cast(CodeGen::Address addr)
SmallVector< Token, 4 > CachedTokens
A set of tokens that has been cached for later parsing.
@ TemplateArg
Value of a non-type template parameter.
@ TempArgStrict
As above, but applies strict template checking rules.
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
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.
ActionResult< Expr * > ExprResult
@ Parens
New-expression has a C++98 paren-delimited initializer.
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.
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
NestedNameSpecifierLoc Prefix
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
Describes how types, statements, expressions, and declarations should be printed.
unsigned TerseOutput
Provide a 'terse' output.
unsigned PrintAsCanonical
Whether to print entities as written or canonically.
bool StrictPackMatch
Is set to true when, in the context of TTP matching, a pack parameter matches non-pack arguments.
bool MatchingTTP
If true, assume these template arguments are the injected template arguments for a template template ...
bool PartialOrdering
The check is being performed in the context of partial ordering.
SmallVector< TemplateArgument, 4 > SugaredConverted
The checked, converted argument will be added to the end of these vectors.
SmallVector< TemplateArgument, 4 > CanonicalConverted
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)
OverloadedOperatorKind Operator
The kind of overloaded operator.