40#include "llvm/ADT/SmallBitVector.h"
41#include "llvm/ADT/SmallString.h"
42#include "llvm/ADT/StringExtras.h"
54 return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc());
62 for (
Scope *TempParamScope = S->getTemplateParamParent(); TempParamScope;
63 TempParamScope = TempParamScope->getParent()->getTemplateParamParent()) {
68 auto ParamsAtDepth = [&](
unsigned D) { Depth = std::max(Depth, D + 1); };
73 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(FSI)) {
74 if (!LSI->TemplateParams.empty()) {
75 ParamsAtDepth(LSI->AutoTemplateParameterDepth);
78 if (LSI->GLTemplateParameterList) {
79 ParamsAtDepth(LSI->GLTemplateParameterList->getDepth());
89 if (!Info.TemplateParams.empty()) {
90 ParamsAtDepth(Info.AutoTemplateParameterDepth);
105 bool AllowFunctionTemplates,
106 bool AllowDependent) {
109 if (isa<TemplateDecl>(D)) {
110 if (!AllowFunctionTemplates && isa<FunctionTemplateDecl>(D))
116 if (
const auto *
Record = dyn_cast<CXXRecordDecl>(D)) {
128 if (
Record->isInjectedClassName()) {
130 if (
Record->getDescribedClassTemplate())
131 return Record->getDescribedClassTemplate();
133 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(
Record))
134 return Spec->getSpecializedTemplate();
143 if (AllowDependent && isa<UnresolvedUsingValueDecl>(D))
150 bool AllowFunctionTemplates,
151 bool AllowDependent) {
162 bool AllowFunctionTemplates,
164 bool AllowNonTemplateFunctions) {
168 if (AllowNonTemplateFunctions &&
169 isa<FunctionDecl>((*I)->getUnderlyingDecl()))
178 bool hasTemplateKeyword,
181 bool EnteringContext,
183 bool &MemberOfUnknownSpecialization,
184 bool Disambiguation) {
188 MemberOfUnknownSpecialization =
false;
190 switch (Name.getKind()) {
197 Name.OperatorFunctionId.Operator);
237 bool AnyFunctionTemplates =
false;
240 if (isa<FunctionTemplateDecl>(FoundTemplate))
241 AnyFunctionTemplates =
true;
244 FoundUsingShadow = dyn_cast<UsingShadowDecl>(FoundD);
252 if (!D && !AnyFunctionTemplates) {
253 R.suppressDiagnostics();
270 unsigned ResultCount = R.
end() - R.
begin();
271 if (!D && ResultCount > 1) {
282 assert(D &&
"unambiguous result is not a template name");
285 if (isa<UnresolvedUsingValueDecl>(D)) {
287 MemberOfUnknownSpecialization =
true;
294 assert(!FoundUsingShadow || FoundUsingShadow->
getTargetDecl() == TD);
301 if (isa<FunctionTemplateDecl>(TD)) {
307 assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||
308 isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||
309 isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl>(TD));
332 if (R.
empty())
return false;
366 Diag(IILoc, diag::err_template_kw_missing)
376 QualType ObjectType,
bool EnteringContext,
379 bool AllowTypoCorrection) {
390 bool IsDependent =
false;
391 if (!ObjectType.
isNull()) {
394 assert(SS.
isEmpty() &&
"ObjectType and scope specifier cannot coexist");
400 "Caller should have completed object type");
432 bool ObjectTypeSearchedInScope =
false;
433 bool AllowFunctionTemplatesInLookup =
true;
465 if (!ObjectType.
isNull()) {
469 AllowFunctionTemplatesInLookup =
false;
470 ObjectTypeSearchedInScope =
true;
493 if (AllFunctions || (Found.
empty() && !IsDependent)) {
505 if (Found.
empty() && !IsDependent && AllowTypoCorrection) {
513 FilterCCC.WantExpressionKeywords =
false;
514 FilterCCC.WantRemainingKeywords =
false;
515 FilterCCC.WantCXXNamedCasts =
true;
519 if (
auto *ND = Corrected.getFoundDecl())
524 }
else if (!Found.
empty()) {
527 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
528 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
529 Name.getAsString() == CorrectedStr;
531 << Name << LookupCtx << DroppedSpecifier
551 if (ExampleLookupResult && RequiredTemplate) {
552 Diag(Found.
getNameLoc(), diag::err_template_kw_refers_to_non_template)
557 diag::note_template_kw_refers_to_non_template)
565 if (S && !ObjectType.
isNull() && !ObjectTypeSearchedInScope &&
582 if (FoundOuter.
empty()) {
600 diag::ext_nested_name_member_ref_lookup_ambiguous)
604 diag::note_ambig_member_ref_object_type)
607 diag::note_ambig_member_ref_scope);
630 bool MissingTemplateKeyword =
false;
633 if (
auto *DRE = dyn_cast<DeclRefExpr>(
TemplateName.get())) {
634 NameInfo = DRE->getNameInfo();
635 SS.
Adopt(DRE->getQualifierLoc());
637 Found = DRE->getFoundDecl();
638 }
else if (
auto *ME = dyn_cast<MemberExpr>(
TemplateName.get())) {
639 NameInfo = ME->getMemberNameInfo();
640 SS.
Adopt(ME->getQualifierLoc());
642 LookupCtx = ME->getBase()->getType()->getAsCXXRecordDecl();
643 Found = ME->getMemberDecl();
644 }
else if (
auto *DSDRE =
645 dyn_cast<DependentScopeDeclRefExpr>(
TemplateName.get())) {
646 NameInfo = DSDRE->getNameInfo();
647 SS.
Adopt(DSDRE->getQualifierLoc());
648 MissingTemplateKeyword =
true;
649 }
else if (
auto *DSME =
650 dyn_cast<CXXDependentScopeMemberExpr>(
TemplateName.get())) {
651 NameInfo = DSME->getMemberNameInfo();
652 SS.
Adopt(DSME->getQualifierLoc());
653 MissingTemplateKeyword =
true;
655 llvm_unreachable(
"unexpected kind of potential template name");
660 if (MissingTemplateKeyword) {
669 TemplateCandidateFilter(
Sema &S) : S(S) {
670 WantTypeSpecifiers =
false;
671 WantExpressionKeywords =
false;
672 WantRemainingKeywords =
false;
673 WantCXXNamedCasts =
true;
675 bool ValidateCandidate(
const TypoCorrection &Candidate)
override {
681 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
682 return std::make_unique<TemplateCandidateFilter>(*
this);
687 TemplateCandidateFilter CCC(*
this);
690 auto *ND = Corrected.getFoundDecl();
693 if (ND || Corrected.isKeyword()) {
695 std::string CorrectedStr(Corrected.getAsString(
getLangOpts()));
696 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
697 Name.getAsString() == CorrectedStr;
699 PDiag(diag::err_non_template_in_member_template_id_suggest)
700 << Name << LookupCtx << DroppedSpecifier
704 PDiag(diag::err_non_template_in_template_id_suggest)
709 diag::note_non_template_in_template_id_found);
714 Diag(NameInfo.
getLoc(), diag::err_non_template_in_template_id)
717 Diag(Found->
getLocation(), diag::note_non_template_in_template_id_found);
727 bool isAddressOfOperand,
742 bool MightBeCxx11UnevalField =
748 IsEnum = isa_and_nonnull<EnumType>(NNS->getAsType());
750 if (!MightBeCxx11UnevalField && !isAddressOfOperand && !IsEnum &&
751 isa<CXXMethodDecl>(DC) &&
752 cast<CXXMethodDecl>(DC)->isImplicitObjectMemberFunction()) {
754 cast<CXXMethodDecl>(DC)->getThisType().getNonReferenceType();
758 NamedDecl *FirstQualifierInScope =
nullptr;
764 FirstQualifierInScope, NameInfo, TemplateArgs);
781 Context, QualifierLoc, TemplateKWLoc, NameInfo, TemplateArgs);
789 bool InstantiatedFromMember,
794 assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||
795 isa<VarDecl>(Instantiation));
797 bool IsEntityBeingDefined =
false;
798 if (
const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
799 IsEntityBeingDefined = TD->isBeingDefined();
801 if (PatternDef && !IsEntityBeingDefined) {
816 if (!Complain || (PatternDef && PatternDef->
isInvalidDecl()))
820 if (
TagDecl *TD = dyn_cast<TagDecl>(Instantiation))
823 Diag(PointOfInstantiation,
824 diag::err_template_instantiate_within_definition)
830 }
else if (InstantiatedFromMember) {
831 if (isa<FunctionDecl>(Instantiation)) {
832 Diag(PointOfInstantiation,
833 diag::err_explicit_instantiation_undefined_member)
838 assert(isa<TagDecl>(Instantiation) &&
"Must be a TagDecl!");
839 Diag(PointOfInstantiation,
840 diag::err_implicit_instantiate_member_undefined)
845 if (isa<FunctionDecl>(Instantiation)) {
846 Diag(PointOfInstantiation,
847 diag::err_explicit_instantiation_undefined_func_template)
850 }
else if (isa<TagDecl>(Instantiation)) {
851 Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
856 assert(isa<VarDecl>(Instantiation) &&
"Must be a VarDecl!");
857 if (isa<VarTemplateSpecializationDecl>(Instantiation)) {
858 Diag(PointOfInstantiation,
859 diag::err_explicit_instantiation_undefined_var_template)
863 Diag(PointOfInstantiation,
864 diag::err_explicit_instantiation_undefined_member)
881 bool SupportedForCompatibility) {
894 ? diag::ext_template_param_shadow
895 : (SupportedForCompatibility ? diag::ext_compat_template_param_shadow
896 : diag::err_template_param_shadow);
897 const auto *ND = cast<NamedDecl>(PrevDecl);
898 Diag(
Loc, DiagId) << ND->getDeclName();
906 if (
TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) {
907 D = Temp->getTemplatedDecl();
916 "Only template template arguments can be pack expansions here");
917 assert(
getAsTemplate().get().containsUnexpandedParameterPack() &&
918 "Template template argument pack expansion without packs");
920 Result.EllipsisLoc = EllipsisLoc;
955 llvm_unreachable(
"Unhandled parsed template argument");
962 for (
unsigned I = 0,
Last = TemplateArgsIn.size(); I !=
Last; ++I)
972 RedeclarationKind::ForVisibleRedeclaration);
986 assert(TInfo &&
"template argument with no location");
994 EllipsisLoc = PET.getEllipsisLoc();
995 TL = PET.getPatternLoc();
1000 SS.
Adopt(ET.getQualifierLoc());
1001 TL = ET.getNamedTypeLoc();
1005 TemplateName Name = DTST.getTypePtr()->getTemplateName();
1011 DTST.getTemplateNameLoc());
1041 unsigned Depth,
unsigned Position,
1044 bool HasTypeConstraint) {
1045 assert(S->isTemplateParamScope() &&
1046 "Template type parameter not in template parameter scope!");
1048 bool IsParameterPack = EllipsisLoc.
isValid();
1051 KeyLoc, ParamNameLoc, Depth, Position,
1052 ParamName,
Typename, IsParameterPack,
1058 LSI->LocalPacks.push_back(Param);
1071 if (DefaultArg && IsParameterPack) {
1072 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1073 DefaultArg =
nullptr;
1081 assert(DefaultTInfo &&
"expected source information for type");
1108 return TemplateArgs;
1121 diag::err_type_constraint_non_type_concept);
1127 if (!WereArgsSpecified &&
1130 diag::err_type_constraint_missing_arguments)
1149 bool AllowUnexpandedPack) {
1166 if (EllipsisLoc.
isInvalid() && !AllowUnexpandedPack) {
1175 ConceptName, CD, USD ? cast<NamedDecl>(USD) : CD,
1177 ConstrainedParameter, EllipsisLoc);
1180template <
typename ArgumentLocAppender>
1195 Appender(ConstraintArgs);
1204 FoundDecl ? FoundDecl : NamedConcept, NamedConcept,
1207 return ImmediatelyDeclaredConstraint;
1223 ImmediatelyDeclaredConstraint.
get(), BO_LAnd,
1224 EllipsisLoc,
nullptr,
1244 *TemplateArgs) :
nullptr;
1249 *
this,
NS, NameInfo, NamedConcept, FoundDecl,
1252 ParamAsArgument, ConstrainedParameter->
getLocation(),
1255 for (const auto &ArgLoc : TemplateArgs->arguments())
1256 ConstraintArgs.addArgument(ArgLoc);
1259 if (ImmediatelyDeclaredConstraint.
isInvalid())
1269 ImmediatelyDeclaredConstraint.
get());
1280 diag::err_unsupported_placeholder_constraint)
1299 for (unsigned I = 0, C = TL.getNumArgs(); I != C; ++I)
1300 ConstraintArgs.addArgument(TL.getArgLoc(I));
1303 if (ImmediatelyDeclaredConstraint.
isInvalid() ||
1304 !ImmediatelyDeclaredConstraint.
isUsable())
1308 ImmediatelyDeclaredConstraint.
get());
1346 Diag(
Loc, diag::err_template_nontype_parm_rvalue_ref) <<
T;
1356 Diag(
Loc, diag::err_template_nontype_parm_bad_type) <<
T;
1364 Diag(
Loc, diag::err_template_nontype_parm_not_structural) <<
T;
1371 for (
const FieldDecl *FD : RD->fields()) {
1373 Diag(FD->getLocation(), diag::note_not_structural_non_public) <<
T << 0;
1376 if (FD->isMutable()) {
1377 Diag(FD->getLocation(), diag::note_not_structural_mutable_field) <<
T;
1380 if (FD->getType()->isRValueReferenceType()) {
1381 Diag(FD->getLocation(), diag::note_not_structural_rvalue_ref_field)
1388 for (
const auto &BaseSpec : RD->bases()) {
1389 if (BaseSpec.getAccessSpecifier() !=
AS_public) {
1390 Diag(BaseSpec.getBaseTypeLoc(), diag::note_not_structural_non_public)
1401 for (
const FieldDecl *FD : RD->fields()) {
1404 SubLoc = FD->getLocation();
1412 for (
const auto &BaseSpec : RD->bases()) {
1415 SubLoc = BaseSpec.getBaseTypeLoc();
1423 assert(Kind != -1 &&
"couldn't find reason why type is not structural");
1424 Diag(SubLoc, diag::note_not_structural_subobject)
1425 <<
T << Kind << SubType;
1438 Diag(
Loc, diag::err_variably_modified_nontype_template_param)
1462 return T.getUnqualifiedType();
1480 return T.getUnqualifiedType();
1491 Diag(
Loc, diag::err_template_nontype_parm_bad_structural_type) <<
T;
1495 Diag(
Loc, diag::warn_cxx17_compat_template_nontype_parm_type) <<
T;
1496 return T.getUnqualifiedType();
1507 auto CheckValidDeclSpecifiers = [
this, &D] {
1521 Diag(
Loc, diag::err_invalid_decl_specifier_in_nontype_parm)
1558 CheckValidDeclSpecifiers();
1561 if (isa<AutoType>(
T))
1563 diag::warn_cxx14_compat_template_nontype_parm_auto_type)
1566 assert(S->isTemplateParamScope() &&
1567 "Non-type template parameter not in template parameter scope!");
1587 if (TL.isConstrained())
1596 LSI->LocalPacks.push_back(Param);
1610 if (
Default && IsParameterPack) {
1611 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1635 assert(S->isTemplateParamScope() &&
1636 "Template template parameter not in template parameter scope!");
1639 bool IsParameterPack = EllipsisLoc.
isValid();
1642 NameLoc.
isInvalid() ? TmpLoc : NameLoc, Depth, Position, IsParameterPack,
1648 LSI->LocalPacks.push_back(Param);
1659 if (Params->
size() == 0) {
1668 if (IsParameterPack && !
Default.isInvalid()) {
1669 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1684 Diag(DefaultArg.
getLocation(), diag::err_template_arg_not_valid_template)
1702class ConstraintRefersToContainingTemplateChecker
1703 :
public TreeTransform<ConstraintRefersToContainingTemplateChecker> {
1704 bool Result =
false;
1706 unsigned TemplateDepth = 0;
1710 void CheckIfContainingRecord(
const CXXRecordDecl *CheckingRD) {
1717 if (
const auto *RD = dyn_cast<CXXRecordDecl>(DC))
1718 if (CheckingRD == RD->getMostRecentDecl())
1723 assert(D->
getDepth() <= TemplateDepth &&
1724 "Nothing should reference a value below the actual template depth, "
1725 "depth is likely wrong");
1726 if (D->
getDepth() != TemplateDepth)
1737 ConstraintRefersToContainingTemplateChecker(
Sema &SemaRef,
1739 unsigned TemplateDepth)
1740 : inherited(SemaRef), Friend(Friend), TemplateDepth(TemplateDepth) {}
1741 bool getResult()
const {
return Result; }
1747 using inherited::TransformTemplateTypeParmType;
1751 "Nothing should reference a value below the actual template depth, "
1752 "depth is likely wrong");
1755 return inherited::TransformTemplateTypeParmType(
1767 if (
auto *TD = dyn_cast<TypedefNameDecl>(D))
1768 TransformType(TD->getUnderlyingType());
1769 else if (
auto *NTTPD = dyn_cast<NonTypeTemplateParmDecl>(D))
1770 CheckNonTypeTemplateParmDecl(NTTPD);
1771 else if (
auto *VD = dyn_cast<ValueDecl>(D))
1772 TransformType(VD->getType());
1773 else if (
auto *TD = dyn_cast<TemplateDecl>(D))
1774 TransformTemplateParameterList(TD->getTemplateParameters());
1775 else if (
auto *RD = dyn_cast<CXXRecordDecl>(D))
1776 CheckIfContainingRecord(RD);
1777 else if (isa<NamedDecl>(D)) {
1780 llvm_unreachable(
"Don't know how to handle this declaration type yet");
1788 const Expr *Constraint) {
1790 ConstraintRefersToContainingTemplateChecker Checker(*
this, Friend,
1792 Checker.TransformExpr(
const_cast<Expr *
>(Constraint));
1793 return Checker.getResult();
1806 Expr *RequiresClause) {
1808 Diag(ExportLoc, diag::warn_template_export_unsupported);
1814 Context, TemplateLoc, LAngleLoc,
1815 llvm::ArrayRef(Params.data(), Params.size()), RAngleLoc, RequiresClause);
1850 return cast<TemplateDecl>(D)->getTemplateParameters();
1860 assert(TemplateParams && TemplateParams->
size() > 0 &&
1861 "No template parameters");
1862 assert(TUK !=
TUK_Reference &&
"Can only declare or define class templates");
1871 "can't build template of enumerated type");
1875 Diag(KWLoc, diag::err_template_unnamed_class);
1889 if (!SemanticContext) {
1894 ? diag::warn_template_qualified_friend_ignored
1895 : diag::err_template_qualified_declarator_no_match)
1938 PrevDecl = (*
Previous.begin())->getUnderlyingDecl();
1950 dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
1955 if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) &&
1956 cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
1959 = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
1960 if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
1962 = cast<ClassTemplateSpecializationDecl>(PrevDecl)
1963 ->getSpecializedTemplate();
1986 PrevDecl = PrevClassTemplate =
nullptr;
1987 SemanticContext = OutermostContext;
2001 PrevDecl = (*
Previous.begin())->getUnderlyingDecl();
2004 }
else if (PrevDecl &&
2007 PrevDecl = PrevClassTemplate =
nullptr;
2009 if (
auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
2010 PrevDecl ?
Previous.getRepresentativeDecl() :
nullptr)) {
2012 !(PrevClassTemplate &&
2015 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
2016 Diag(Shadow->getTargetDecl()->getLocation(),
2017 diag::note_using_decl_target);
2018 Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl) << 0;
2020 PrevDecl = PrevClassTemplate =
nullptr;
2024 if (PrevClassTemplate) {
2033 TemplateParams, PrevClassTemplate,
2046 Diag(KWLoc, diag::err_use_with_wrong_tag)
2062 auto *Tmpl = cast<CXXRecordDecl>(Hidden)->getDescribedClassTemplate();
2063 assert(Tmpl &&
"original definition of a class template is not a "
2068 Diag(NameLoc, diag::err_redefinition) << Name;
2069 Diag(Def->getLocation(), diag::note_previous_definition);
2076 }
else if (PrevDecl) {
2082 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
2096 (SS.
isSet() && SemanticContext && SemanticContext->
isRecord() &&
2108 Diag(NameLoc, TUK ==
TUK_Friend ? diag::err_friend_decl_does_not_match
2109 : diag::err_member_decl_does_not_match)
2110 << Name << SemanticContext <<
true << SS.
getRange();
2120 bool ShouldAddRedecl
2125 PrevClassTemplate && ShouldAddRedecl ?
2129 if (NumOuterTemplateParamLists > 0)
2132 llvm::ArrayRef(OuterTemplateParamLists, NumOuterTemplateParamLists));
2146 if (ShouldAddRedecl)
2151 if (ModulePrivateLoc.
isValid())
2162 if (PrevClassTemplate &&
2180 if (PrevClassTemplate)
2216 if (PrevClassTemplate)
2235class ExtractTypeForDeductionGuide
2241 ExtractTypeForDeductionGuide(
2244 :
Base(SemaRef), MaterializedTypedefs(MaterializedTypedefs) {}
2249 ASTContext &Context = SemaRef.getASTContext();
2259 if (isa<TypeAliasDecl>(OrigDecl))
2264 assert(isa<TypedefDecl>(OrigDecl) &&
"Not a Type alias or typedef");
2269 MaterializedTypedefs.push_back(
Decl);
2288 auto DeductionGuideName =
2299 TInfo->
getType(), TInfo, LocEnd, Ctor);
2300 Guide->setImplicit(IsImplicit);
2301 Guide->setParams(Params);
2303 for (
auto *Param : Params)
2304 Param->setDeclContext(Guide);
2305 for (
auto *TD : MaterializedTypedefs)
2306 TD->setDeclContext(Guide);
2309 SemaRef.
Context, DC,
Loc, DeductionGuideName, TemplateParams, Guide);
2310 GuideTemplate->setImplicit(IsImplicit);
2311 Guide->setDescribedFunctionTemplate(GuideTemplate);
2313 if (isa<CXXRecordDecl>(DC)) {
2319 return GuideTemplate;
2327 unsigned NewDepth,
unsigned NewIndex) {
2344 if (InstantiatedDefaultArg)
2345 NewTTP->setDefaultArgument(InstantiatedDefaultArg);
2351template <
typename NonTypeTemplateOrTemplateTemplateParmDecl>
2352NonTypeTemplateOrTemplateTemplateParmDecl *
2354 NonTypeTemplateOrTemplateTemplateParmDecl *OldParam,
2356 unsigned NewDepth) {
2359 auto *NewParam = cast<NonTypeTemplateOrTemplateTemplateParmDecl>(
2361 NewParam->setPosition(NewIndex);
2362 NewParam->setDepth(NewDepth);
2368struct ConvertConstructorToDeductionGuideTransform {
2369 ConvertConstructorToDeductionGuideTransform(
Sema &S,
2371 : SemaRef(S), Template(Template) {
2379 NestedPattern = Pattern;
2424 AllParams.reserve(TemplateParams->
size() + InnerParams->
size());
2425 AllParams.insert(AllParams.begin(),
2426 TemplateParams->
begin(), TemplateParams->
end());
2427 SubstArgs.reserve(InnerParams->
size());
2428 Depth1Args.reserve(InnerParams->
size());
2434 Args.
setKind(TemplateSubstitutionKind::Rewrite);
2439 NamedDecl *NewParam = transformTemplateParameter(Param, Args);
2447 if (NestedPattern) {
2449 OuterInstantiationArgs);
2450 Instantiator.setEvaluateConstraints(
false);
2452 NewParam = cast<NamedDecl>(Instantiator.Visit(NewParam));
2457 "Unexpected template parameter depth");
2459 AllParams.push_back(NewParam);
2465 Expr *RequiresClause =
nullptr;
2466 if (
Expr *InnerRC = InnerParams->getRequiresClause()) {
2468 Args.
setKind(TemplateSubstitutionKind::Rewrite);
2479 TemplateParams = TemplateParameterList::Create(
2480 SemaRef.
Context, InnerParams->getTemplateLoc(),
2481 InnerParams->getLAngleLoc(), AllParams, InnerParams->getRAngleLoc(),
2489 Args.
setKind(TemplateSubstitutionKind::Rewrite);
2497 assert(FPTL &&
"no prototype for constructor declaration");
2505 QualType NewType = transformFunctionProtoType(TLB, FPTL, Params, Args,
2506 MaterializedTypedefs);
2511 return buildDeductionGuide(
2514 true, MaterializedTypedefs);
2525 DeductionGuideName, EPI);
2528 TSI = SemaRef.
SubstType(TSI, OuterInstantiationArgs,
Loc,
2529 DeductionGuideName);
2536 for (
auto T : ParamTypes) {
2539 TSI = SemaRef.
SubstType(TSI, OuterInstantiationArgs,
Loc,
2545 FPTL.
setParam(Params.size(), NewParam);
2546 Params.push_back(NewParam);
2549 return buildDeductionGuide(
2560 if (
auto *TTP = dyn_cast<TemplateTypeParmDecl>(
TemplateParam))
2561 return transformTemplateTypeParam(
2562 SemaRef, DC, TTP, Args, TTP->
getDepth() - 1,
2563 Depth1IndexAdjustment + TTP->
getIndex());
2564 if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(
TemplateParam))
2565 return transformTemplateParam(SemaRef, DC, TTP, Args,
2566 Depth1IndexAdjustment + TTP->
getIndex(),
2569 return transformTemplateParam(SemaRef, DC, NTTP, Args,
2570 Depth1IndexAdjustment + NTTP->getIndex(),
2571 NTTP->getDepth() - 1);
2574 QualType transformFunctionProtoType(
2594 if (NestedPattern) {
2595 NewParam = transformFunctionTypeParam(NewParam, OuterInstantiationArgs,
2596 MaterializedTypedefs);
2604 transformFunctionTypeParam(NewParam, Args, MaterializedTypedefs);
2607 ParamTypes.push_back(NewParam->
getType());
2608 Params.push_back(NewParam);
2630 ReturnType, ParamTypes, TL.
getBeginLoc(), DeductionGuideName, EPI);
2631 if (Result.isNull())
2640 for (
unsigned I = 0, E = NewTL.
getNumParams(); I != E; ++I)
2655 SemaRef.
SubstType(PackTL.getPatternLoc(), Args,
2657 if (!NewDI)
return nullptr;
2660 PackTL.getTypePtr()->getNumExpansions());
2671 NewDI = ExtractTypeForDeductionGuide(SemaRef, MaterializedTypedefs)
2681 NewDefArg =
new (SemaRef.
Context)
2689 auto NewType = NewDI->
getType();
2709 struct TemplateParamsReferencedFinder
2715 : TemplateParams(TemplateParams.begin(), TemplateParams.end()) {}
2733 if (TemplateParams.contains(ND))
2734 ReferencedTemplateParams.insert(ND);
2737 TemplateParamsReferencedFinder Finder(TemplateParams);
2738 Finder.TraverseTemplateArguments(DeducedArgs);
2741 for (
unsigned Index = 0; Index < TemplateParams.size(); ++Index) {
2742 if (Finder.ReferencedTemplateParams.contains(TemplateParams[Index]))
2743 Results.push_back(Index);
2751 assert(Name.getNameKind() ==
2753 "name must be a deduction guide name");
2754 auto Existing = DC->
lookup(Name);
2755 for (
auto *D : Existing)
2762 if (
auto *TTP = dyn_cast<TemplateTypeParmDecl>(
TemplateParam))
2764 if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(
TemplateParam))
2766 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
TemplateParam))
2767 return NTTP->getDepth();
2768 llvm_unreachable(
"Unhandled template parameter types");
2774 unsigned NewIndex,
unsigned NewDepth) {
2775 if (
auto *TTP = dyn_cast<TemplateTypeParmDecl>(
TemplateParam))
2776 return transformTemplateTypeParam(SemaRef, DC, TTP, Args, NewDepth,
2778 if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(
TemplateParam))
2779 return transformTemplateParam(SemaRef, DC, TTP, Args, NewIndex, NewDepth);
2780 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
TemplateParam))
2781 return transformTemplateParam(SemaRef, DC, NTTP, Args, NewIndex, NewDepth);
2782 llvm_unreachable(
"Unhandled template parameter types");
2797 Expr *IsDeducible) {
2822 unsigned AdjustDepth = 0;
2823 if (
auto *PrimaryTemplate =
2825 AdjustDepth = PrimaryTemplate->getTemplateDepth();
2837 NamedDecl *NewParam = transformTemplateParameter(
2839 AdjustedAliasTemplateArgs.size(),
2840 getTemplateParameterDepth(TP) + AdjustDepth);
2844 AdjustedAliasTemplateArgs.push_back(NewTemplateArgument);
2855 for (
unsigned Index = 0; Index < DeduceResults.size(); ++Index) {
2856 const auto &D = DeduceResults[Index];
2863 assert(TemplateArgsForBuildingRC[Index].isNull() &&
2864 "InstantiatedArgs must be null before setting");
2865 TemplateArgsForBuildingRC[Index] = Output.
getArgument();
2902 false, std::nullopt,
2906 for (
auto It : OuterLevelArgs)
2916 BinaryOperatorKind::BO_LAnd, E.
get(), IsDeducible);
2917 if (Conjunction.isInvalid())
2925Expr *buildIsDeducibleConstraint(
Sema &SemaRef,
2931 if (
auto *PrimaryTemplate =
2936 unsigned AdjustDepth = PrimaryTemplate->getTemplateDepth();
2938 for (
auto *TP : TemplateParams) {
2944 NamedDecl *NewParam = transformTemplateParameter(
2946 TransformedTemplateArgs.size(),
2947 getTemplateParameterDepth(TP) + AdjustDepth);
2951 TransformedTemplateArgs.push_back(NewTemplateArgument);
2973 TypeTrait::BTT_IsDeducible, IsDeducibleTypeTraitArgs,
2977std::pair<TemplateDecl *, llvm::ArrayRef<TemplateArgument>>
2981 ->getUnderlyingType()
2982 .getSingleStepDesugaredType(SemaRef.
Context);
2989 Template = TST->getTemplateName().getAsTemplateDecl();
2990 AliasRhsTemplateArgs = TST->template_arguments();
2991 }
else if (
const auto *RT = RhsType->getAs<
RecordType>()) {
2995 if (
const auto *CTSD = llvm::dyn_cast<ClassTemplateSpecializationDecl>(
2996 RT->getAsCXXRecordDecl())) {
2997 Template = CTSD->getSpecializedTemplate();
2998 AliasRhsTemplateArgs = CTSD->getTemplateArgs().asArray();
3001 assert(
false &&
"unhandled RHS type of the alias");
3003 return {Template, AliasRhsTemplateArgs};
3009BuildDeductionGuideForTypeAlias(
Sema &SemaRef,
3016 if (BuildingDeductionGuides.isInvalid())
3019 auto &Context = SemaRef.
Context;
3020 auto [Template, AliasRhsTemplateArgs] =
3029 FReturnType = InjectedCNT->getInjectedTST();
3033 assert(FReturnType &&
"expected to see a return type");
3066 AliasRhsTemplateArgs, TDeduceInfo, DeduceResults,
3073 for (
unsigned Index = 0; Index < DeduceResults.size(); ++Index) {
3074 if (
const auto &D = DeduceResults[Index]; !D.isNull())
3075 DeducedArgs.push_back(D);
3077 NonDeducedTemplateParamsInFIndex.push_back(Index);
3079 auto DeducedAliasTemplateParams =
3080 TemplateParamsReferencedInTemplateArgumentList(
3081 AliasTemplate->getTemplateParameters()->asArray(), DeducedArgs);
3099 for (
unsigned AliasTemplateParamIdx : DeducedAliasTemplateParams) {
3101 AliasTemplate->getTemplateParameters()->getParam(AliasTemplateParamIdx);
3107 NamedDecl *NewParam = transformTemplateParameter(
3109 FPrimeTemplateParams.size(),
3110 getTemplateParameterDepth(TP));
3111 FPrimeTemplateParams.push_back(NewParam);
3115 TransformedDeducedAliasArgs[AliasTemplateParamIdx] = NewTemplateArgument;
3119 for (
unsigned FTemplateParamIdx : NonDeducedTemplateParamsInFIndex) {
3126 NamedDecl *NewParam = transformTemplateParameter(
3127 SemaRef, F->
getDeclContext(), TP, Args, FPrimeTemplateParams.size(),
3128 getTemplateParameterDepth(TP));
3129 FPrimeTemplateParams.push_back(NewParam);
3131 assert(TemplateArgsForBuildingFPrime[FTemplateParamIdx].isNull() &&
3132 "The argument must be null before setting");
3133 TemplateArgsForBuildingFPrime[FTemplateParamIdx] =
3156 for (
unsigned Index = 0; Index < DeduceResults.size(); ++Index) {
3157 const auto &D = DeduceResults[Index];
3160 assert(!TemplateArgsForBuildingFPrime[Index].isNull() &&
3161 "template arguments for non-deduced template parameters should "
3169 assert(TemplateArgsForBuildingFPrime[Index].isNull() &&
3170 "InstantiatedArgs must be null before setting");
3171 TemplateArgsForBuildingFPrime[Index] = Output.
getArgument();
3175 auto *TemplateArgListForBuildingFPrime =
3179 F, TemplateArgListForBuildingFPrime,
AliasTemplate->getLocation(),
3181 auto *GG = cast<CXXDeductionGuideDecl>(FPrime);
3183 Expr *IsDeducible = buildIsDeducibleConstraint(
3184 SemaRef,
AliasTemplate, FPrime->getReturnType(), FPrimeTemplateParams);
3185 Expr *RequiresClause = buildAssociatedConstraints(
3193 Context,
AliasTemplate->getTemplateParameters()->getTemplateLoc(),
3195 FPrimeTemplateParams,
3200 GG->getCorrespondingConstructor(), GG->getExplicitSpecifier(),
3204 cast<CXXDeductionGuideDecl>(
Result->getTemplatedDecl())
3205 ->setDeductionCandidateKind(GG->getDeductionCandidateKind());
3211void DeclareImplicitDeductionGuidesForTypeAlias(
3215 auto &Context = SemaRef.
Context;
3219 if (hasDeclaredDeductionGuides(
3223 auto [Template, AliasRhsTemplateArgs] =
3231 Guides.suppressDiagnostics();
3233 for (
auto *G : Guides) {
3257 RHSTemplate, ParamTypes,
Loc);
3258 if (!RHSDeductionGuide)
3260 return BuildDeductionGuideForTypeAlias(SemaRef,
AliasTemplate,
3261 RHSDeductionGuide,
Loc);
3269 llvm::FoldingSetNodeID ID;
3270 ID.AddPointer(Template);
3271 for (
auto &
T : ParamTypes)
3273 unsigned Hash = ID.ComputeHash();
3281 if (
auto *
AliasTemplate = llvm::dyn_cast<TypeAliasTemplateDecl>(Template)) {
3282 if (
auto *FTD = DeclareAggregateDeductionGuideForTypeAlias(
3294 DefRecord->getDescribedClassTemplate())
3295 Template = DescribedTemplate;
3302 ConvertConstructorToDeductionGuideTransform Transform(
3303 *
this, cast<ClassTemplateDecl>(Template));
3314 *
this,
Loc, Template,
3316 if (BuildingDeductionGuides.isInvalid())
3320 Transform.NestedPattern ? Transform.NestedPattern : Transform.Template;
3323 auto *FTD = cast<FunctionTemplateDecl>(
3324 Transform.buildSimpleDeductionGuide(ParamTypes));
3334 if (
auto *
AliasTemplate = llvm::dyn_cast<TypeAliasTemplateDecl>(Template)) {
3340 if (
TemplateDecl *DescribedTemplate = DefRecord->getDescribedClassTemplate())
3341 Template = DescribedTemplate;
3348 ConvertConstructorToDeductionGuideTransform Transform(
3349 *
this, cast<ClassTemplateDecl>(Template));
3353 if (hasDeclaredDeductionGuides(Transform.DeductionGuideName, DC))
3362 *
this,
Loc, Template,
3364 if (BuildingDeductionGuides.isInvalid())
3372 Transform.NestedPattern ? Transform.NestedPattern : Transform.Template;
3375 bool AddedAny =
false;
3377 D = D->getUnderlyingDecl();
3386 if (ProcessedCtors.count(D))
3389 auto *FTD = dyn_cast<FunctionTemplateDecl>(D);
3399 return !P || P->hasUnparsedDefaultArg();
3403 ProcessedCtors.insert(D);
3404 Transform.transformConstructor(FTD, CD);
3413 Transform.buildSimpleDeductionGuide(std::nullopt);
3417 cast<CXXDeductionGuideDecl>(
3418 cast<FunctionTemplateDecl>(
3419 Transform.buildSimpleDeductionGuide(Transform.DeducedType))
3420 ->getTemplatedDecl())
3451 diag::warn_cxx98_compat_template_parameter_default_in_function_template
3452 : diag::ext_template_parameter_default_in_function_template)
3461 S.
Diag(ParamLoc, diag::err_template_parameter_default_template_member)
3470 S.
Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
3479 llvm_unreachable(
"Invalid TemplateParamListContext!");
3492 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
3497 if (TC->hasExplicitTemplateArgs())
3498 for (
auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
3506 if (!NTTP->isParameterPack() &&
3508 NTTP->getTypeSourceInfo(),
3516 = dyn_cast<TemplateTemplateParmDecl>(
P))
3564 bool SawDefaultArgument =
false;
3570 OldParam = OldParams->
begin();
3572 bool RemoveDefaultArguments =
false;
3574 NewParamEnd = NewParams->
end();
3575 NewParam != NewParamEnd; ++NewParam) {
3578 bool RedundantDefaultArg =
false;
3581 bool InconsistentDefaultArg =
false;
3583 std::string PrevModuleName;
3589 bool MissingDefaultArg =
false;
3592 bool SawParameterPack =
false;
3595 = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
3597 if (NewTypeParm->hasDefaultArgument() &&
3599 NewTypeParm->getLocation(),
3600 NewTypeParm->getDefaultArgumentInfo()->getTypeLoc()
3602 NewTypeParm->removeDefaultArgument();
3606 = OldParams? cast<TemplateTypeParmDecl>(*OldParam) :
nullptr;
3607 if (NewTypeParm->isParameterPack()) {
3608 assert(!NewTypeParm->hasDefaultArgument() &&
3609 "Parameter packs can't have a default argument!");
3610 SawParameterPack =
true;
3612 NewTypeParm->hasDefaultArgument() &&
3615 NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
3616 SawDefaultArgument =
true;
3619 RedundantDefaultArg =
true;
3620 else if (!
getASTContext().isSameDefaultTemplateArgument(OldTypeParm,
3622 InconsistentDefaultArg =
true;
3626 PreviousDefaultArgLoc = NewDefaultLoc;
3630 NewTypeParm->setInheritedDefaultArgument(
Context, OldTypeParm);
3632 }
else if (NewTypeParm->hasDefaultArgument()) {
3633 SawDefaultArgument =
true;
3634 PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
3635 }
else if (SawDefaultArgument)
3636 MissingDefaultArg =
true;
3638 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
3640 if (!NewNonTypeParm->isParameterPack() &&
3642 NewNonTypeParm->getTypeSourceInfo(),
3649 if (NewNonTypeParm->hasDefaultArgument() &&
3651 NewNonTypeParm->getLocation(),
3652 NewNonTypeParm->getDefaultArgument()->getSourceRange())) {
3653 NewNonTypeParm->removeDefaultArgument();
3658 = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) :
nullptr;
3659 if (NewNonTypeParm->isParameterPack()) {
3660 assert(!NewNonTypeParm->hasDefaultArgument() &&
3661 "Parameter packs can't have a default argument!");
3662 if (!NewNonTypeParm->isPackExpansion())
3663 SawParameterPack =
true;
3665 NewNonTypeParm->hasDefaultArgument() &&
3668 NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
3669 SawDefaultArgument =
true;
3671 RedundantDefaultArg =
true;
3673 OldNonTypeParm, NewNonTypeParm)) {
3674 InconsistentDefaultArg =
true;
3678 PreviousDefaultArgLoc = NewDefaultLoc;
3682 NewNonTypeParm->setInheritedDefaultArgument(
Context, OldNonTypeParm);
3684 }
else if (NewNonTypeParm->hasDefaultArgument()) {
3685 SawDefaultArgument =
true;
3686 PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
3687 }
else if (SawDefaultArgument)
3688 MissingDefaultArg =
true;
3691 = cast<TemplateTemplateParmDecl>(*NewParam);
3708 = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) :
nullptr;
3711 "Parameter packs can't have a default argument!");
3713 SawParameterPack =
true;
3714 }
else if (OldTemplateParm &&
3720 SawDefaultArgument =
true;
3722 RedundantDefaultArg =
true;
3724 OldTemplateParm, NewTemplateParm)) {
3725 InconsistentDefaultArg =
true;
3729 PreviousDefaultArgLoc = NewDefaultLoc;
3734 PreviousDefaultArgLoc
3737 SawDefaultArgument =
true;
3738 PreviousDefaultArgLoc
3740 }
else if (SawDefaultArgument)
3741 MissingDefaultArg =
true;
3747 if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
3750 Diag((*NewParam)->getLocation(),
3751 diag::err_template_param_pack_must_be_last_template_parameter);
3768 if (RedundantDefaultArg) {
3769 Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
3770 Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
3772 }
else if (InconsistentDefaultArg) {
3776 diag::err_template_param_default_arg_inconsistent_redefinition);
3778 diag::note_template_param_prev_default_arg_in_other_module)
3781 }
else if (MissingDefaultArg &&
3789 Diag((*NewParam)->getLocation(),
3790 diag::err_template_param_default_arg_missing);
3791 Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
3793 RemoveDefaultArguments =
true;
3804 if (RemoveDefaultArguments) {
3806 NewParamEnd = NewParams->
end();
3807 NewParam != NewParamEnd; ++NewParam) {
3811 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
3812 NTTP->removeDefaultArgument();
3814 cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
3834 bool IgnoreNonTypeDependent;
3839 DependencyChecker(
unsigned Depth,
bool IgnoreNonTypeDependent)
3840 : Depth(Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),
3844 : IgnoreNonTypeDependent(IgnoreNonTypeDependent), Match(
false) {
3847 Depth = PD->getDepth();
3849 dyn_cast<NonTypeTemplateParmDecl>(ND)) {
3850 Depth = PD->getDepth();
3852 Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
3857 if (ParmDepth >= Depth) {
3865 bool TraverseStmt(
Stmt *S, DataRecursionQueue *Q =
nullptr) {
3870 if (
auto *E = dyn_cast_or_null<Expr>(S))
3871 if (IgnoreNonTypeDependent && !E->isTypeDependent())
3873 return super::TraverseStmt(S, Q);
3876 bool TraverseTypeLoc(
TypeLoc TL) {
3877 if (IgnoreNonTypeDependent && !TL.
isNull() &&
3880 return super::TraverseTypeLoc(TL);
3889 return IgnoreNonTypeDependent || !Matches(
T->getDepth());
3895 if (Matches(PD->getDepth()))
3897 return super::TraverseTemplateName(N);
3902 dyn_cast<NonTypeTemplateParmDecl>(E->
getDecl()))
3903 if (Matches(PD->getDepth(), E->
getExprLoc()))
3905 return super::VisitDeclRefExpr(E);
3909 return TraverseType(
T->getReplacementType());
3914 return TraverseTemplateArgument(
T->getArgumentPack());
3918 return TraverseType(
T->getInjectedSpecializationType());
3927 if (!Params->
size())
3930 DependencyChecker Checker(Params,
false);
3931 Checker.TraverseType(
T);
3932 return Checker.Match;
3942 if (
const Type *CurType = NNS->getAsType()) {
3991 bool &IsMemberSpecialization,
bool &
Invalid,
bool SuppressDiagnostic) {
3992 IsMemberSpecialization =
false;
4013 while (!
T.isNull()) {
4014 NestedTypes.push_back(
T);
4020 = dyn_cast<ClassTemplateSpecializationDecl>(
Record)) {
4021 if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
4023 ExplicitSpecLoc = Spec->getLocation();
4026 }
else if (
Record->getTemplateSpecializationKind()
4028 ExplicitSpecLoc =
Record->getLocation();
4041 if (
TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
4087 std::reverse(NestedTypes.begin(), NestedTypes.end());
4095 bool SawNonEmptyTemplateParameterList =
false;
4098 if (SawNonEmptyTemplateParameterList) {
4099 if (!SuppressDiagnostic)
4100 Diag(DeclLoc, diag::err_specialize_member_of_template)
4101 << !Recovery <<
Range;
4103 IsMemberSpecialization =
false;
4112 if (CheckExplicitSpecialization(
Range,
true))
4117 if (!ParamLists.empty())
4118 ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
4120 ExpectedTemplateLoc = DeclStartLoc;
4122 if (!SuppressDiagnostic)
4123 Diag(DeclLoc, diag::err_template_spec_needs_header)
4130 for (
unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
4132 T = NestedTypes[TypeIdx];
4135 bool NeedEmptyTemplateHeader =
false;
4138 bool NeedNonemptyTemplateHeader =
false;
4151 = dyn_cast<ClassTemplatePartialSpecializationDecl>(
Record)) {
4152 ExpectedTemplateParams = Partial->getTemplateParameters();
4153 NeedNonemptyTemplateHeader =
true;
4154 }
else if (
Record->isDependentType()) {
4155 if (
Record->getDescribedClassTemplate()) {
4156 ExpectedTemplateParams =
Record->getDescribedClassTemplate()
4157 ->getTemplateParameters();
4158 NeedNonemptyTemplateHeader =
true;
4161 = dyn_cast<ClassTemplateSpecializationDecl>(
Record)) {
4167 NeedEmptyTemplateHeader =
true;
4170 }
else if (
Record->getTemplateSpecializationKind()) {
4171 if (
Record->getTemplateSpecializationKind()
4173 TypeIdx == NumTypes - 1)
4174 IsMemberSpecialization =
true;
4180 if (
TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
4182 NeedNonemptyTemplateHeader =
true;
4187 NeedNonemptyTemplateHeader =
false;
4197 if (
ParamIdx < ParamLists.size()) {
4198 if (ParamLists[
ParamIdx]->size() == 0) {
4199 if (CheckExplicitSpecialization(ParamLists[
ParamIdx]->getSourceRange(),
4203 SawNonEmptyTemplateParameterList =
true;
4206 if (NeedEmptyTemplateHeader) {
4209 if (TypeIdx == NumTypes - 1)
4210 IsMemberSpecialization =
true;
4212 if (
ParamIdx < ParamLists.size()) {
4213 if (ParamLists[
ParamIdx]->size() > 0) {
4215 if (!SuppressDiagnostic)
4217 diag::err_template_param_list_matches_nontemplate)
4220 ParamLists[
ParamIdx]->getRAngleLoc())
4232 if (DiagnoseMissingExplicitSpecialization(
4239 if (NeedNonemptyTemplateHeader) {
4245 if (
ParamIdx < ParamLists.size() &&
4247 ExpectedTemplateParams =
nullptr;
4252 if (
ParamIdx < ParamLists.size()) {
4254 if (ExpectedTemplateParams &&
4256 ExpectedTemplateParams,
4269 if (!SuppressDiagnostic)
4270 Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
4281 if (
ParamIdx >= ParamLists.size()) {
4282 if (TemplateId && !IsFriend) {
4298 if (
ParamIdx < ParamLists.size() - 1) {
4299 bool HasAnyExplicitSpecHeader =
false;
4300 bool AllExplicitSpecHeaders =
true;
4301 for (
unsigned I =
ParamIdx, E = ParamLists.size() - 1; I != E; ++I) {
4302 if (ParamLists[I]->size() == 0)
4303 HasAnyExplicitSpecHeader =
true;
4305 AllExplicitSpecHeaders =
false;
4308 if (!SuppressDiagnostic)
4310 AllExplicitSpecHeaders ? diag::ext_template_spec_extra_headers
4311 : diag::err_template_spec_extra_headers)
4313 ParamLists[ParamLists.size() - 2]->getRAngleLoc());
4318 if (ExplicitSpecLoc.
isValid() && HasAnyExplicitSpecHeader &&
4319 !SuppressDiagnostic)
4320 Diag(ExplicitSpecLoc,
4321 diag::note_explicit_template_spec_does_not_need_header)
4322 << NestedTypes.back();
4327 if (!AllExplicitSpecHeaders)
4338 if (ParamLists.back()->size() == 0 &&
4339 CheckExplicitSpecialization(ParamLists[
ParamIdx]->getSourceRange(),
4345 return ParamLists.back();
4349 if (
TemplateDecl *Template = Name.getAsTemplateDecl()) {
4351 << (isa<FunctionTemplateDecl>(Template)
4353 : isa<ClassTemplateDecl>(Template)
4355 : isa<VarTemplateDecl>(Template)
4357 : isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)
4366 Diag((*I)->getLocation(), diag::note_template_declared_here)
4367 << 0 << (*I)->getDeclName();
4385 QualType OrigType = Converted[1].getAsType();
4389 SemaRef.
Diag(TemplateArgs[1].getLocation(),
4390 diag::err_integer_sequence_integral_element_type);
4405 OrigType, TemplateArgs[1].getLocation())));
4407 if (llvm::APSInt NumArgs = NumArgsArg.
getAsIntegral(); NumArgs >= 0) {
4409 for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
4413 TA, OrigType, TemplateArgs[2].getLocation()));
4418 SemaRef.
Diag(TemplateArgs[2].getLocation(),
4419 diag::err_integer_sequence_negative_length);
4426 TemplateLoc, SyntheticTemplateArgs);
4433 assert(Converted.size() == 2 &&
4434 "__type_pack_element should be given an index and a parameter pack");
4442 assert(Index >= 0 &&
"the index used with __type_pack_element should be of "
4443 "type std::size_t, and hence be non-negative");
4445 if (Index >= Ts.pack_size()) {
4446 SemaRef.
Diag(TemplateArgs[0].getLocation(),
4447 diag::err_type_pack_element_out_of_bounds);
4452 int64_t N = Index.getExtValue();
4453 return Ts.getPackAsArray()[N].getAsType();
4455 llvm_unreachable(
"unexpected BuiltinTemplateDecl!");
4474 if (BinOp->getOpcode() == BO_LAnd) {
4481 Terms.push_back(Clause);
4490 if (!BinOp)
return Cond;
4492 if (BinOp->getOpcode() != BO_LOr)
return Cond;
4495 Expr *LHS = BinOp->getLHS();
4497 if (!InnerBinOp)
return Cond;
4499 if (InnerBinOp->getOpcode() != BO_EQ ||
4500 !isa<IntegerLiteral>(InnerBinOp->getRHS()))
4510 if (MacroName ==
"CONCEPT_REQUIRES" || MacroName ==
"CONCEPT_REQUIRES_")
4511 return BinOp->getRHS();
4521class FailedBooleanConditionPrinterHelper :
public PrinterHelper {
4526 bool handledStmt(
Stmt *E, raw_ostream &OS)
override {
4527 const auto *DR = dyn_cast<DeclRefExpr>(E);
4528 if (DR && DR->getQualifier()) {
4531 DR->getQualifier()->print(OS, Policy,
true);
4535 if (
const auto *IV = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
4538 OS, IV->getTemplateArgs().asArray(), Policy,
4539 IV->getSpecializedTemplate()->getTemplateParameters());
4552std::pair<Expr *, std::string>
4561 Expr *FailedCond =
nullptr;
4562 for (
Expr *Term : Terms) {
4566 if (isa<CXXBoolLiteralExpr>(TermAsWritten) ||
4567 isa<IntegerLiteral>(TermAsWritten))
4576 if (Term->EvaluateAsBooleanCondition(Succeeded,
Context) &&
4578 FailedCond = TermAsWritten;
4585 std::string Description;
4587 llvm::raw_string_ostream Out(Description);
4590 FailedBooleanConditionPrinterHelper Helper(Policy);
4591 FailedCond->
printPretty(Out, &Helper, Policy, 0,
"\n",
nullptr);
4593 return { FailedCond, Description };
4600 = Name.getUnderlying().getAsDependentTemplateName();
4610 if (Name.getAsAssumedTemplateName() &&
4615 if (!Template || isa<FunctionTemplateDecl>(Template) ||
4616 isa<VarTemplateDecl>(Template) || isa<ConceptDecl>(Template)) {
4619 if (Name.getAsSubstTemplateTemplateParmPack())
4623 Diag(TemplateLoc, diag::err_template_id_not_a_type)
4633 SugaredConverted, CanonicalConverted,
4640 dyn_cast<TypeAliasTemplateDecl>(Template)) {
4662 std::optional<ContextRAII> SavedContext;
4664 SavedContext.emplace(*
this,
AliasTemplate->getDeclContext());
4669 if (CanonType.
isNull()) {
4675 if (*DeductionInfo &&
4676 (*DeductionInfo)->hasSFINAEDiagnostic() &&
4677 (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==
4678 diag::err_typename_nested_not_found_enable_if &&
4679 TemplateArgs[0].getArgument().getKind()
4682 std::string FailedDescription;
4683 std::tie(FailedCond, FailedDescription) =
4689 (*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);
4693 (*DeductionInfo)->addSFINAEDiagnostic(
4695 PDiag(diag::err_typename_nested_not_found_requirement)
4696 << FailedDescription
4704 }
else if (
auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
4706 TemplateLoc, TemplateArgs);
4707 }
else if (Name.isDependent() ||
4709 TemplateArgs, CanonicalConverted)) {
4718 Name, CanonicalConverted);
4726 if (isa<ClassTemplateDecl>(Template)) {
4729 if (Ctx->isFileContext())
break;
4737 if (!isa<ClassTemplatePartialSpecializationDecl>(
Record) &&
4738 !
Record->getDescribedClassTemplate())
4744 QualType Injected = cast<InjectedClassNameType>(ICNT)
4745 ->getInjectedSpecializationType();
4758 dyn_cast<ClassTemplateDecl>(Template)) {
4761 void *InsertPos =
nullptr;
4763 ClassTemplate->findSpecialization(CanonicalConverted, InsertPos);
4795 assert(isa<RecordType>(CanonType) &&
4796 "type of non-dependent specialization is not a RecordType");
4798 llvm_unreachable(
"Unhandled template kind");
4815 auto *ATN = Name.getAsAssumedTemplateName();
4816 assert(ATN &&
"not an assumed template name");
4817 II = ATN->getDeclName().getAsIdentifierInfo();
4833 assert(ATN &&
"not an assumed template name");
4841 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
4842 return std::make_unique<CandidateCallback>(*
this);
4866 bool IsCtorOrDtorName,
bool IsClassName,
4871 if (!IsCtorOrDtorName && !IsClassName && SS.
isSet()) {
4897 TemplateD, TemplateII, TemplateIILoc, LAngleLoc,
4898 TemplateArgsIn, RAngleLoc);
4905 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
4906 if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
4909 ? diag::err_out_of_line_qualified_id_type_names_constructor
4910 : diag::ext_out_of_line_qualified_id_type_names_constructor)
4940 for (
unsigned I = 0, N = SpecTL.
getNumArgs(); I != N; ++I)
4957 for (
unsigned i = 0, e = SpecTL.
getNumArgs(); i != e; ++i)
4998 Keyword, DTN->getQualifier(), DTN->getIdentifier(),
5011 for (
unsigned I = 0, N = SpecTL.
getNumArgs(); I != N; ++I)
5022 Diag(TemplateLoc, diag::err_tag_reference_non_tag)
5024 Diag(TAT->getLocation(), diag::note_declared_at);
5036 assert(
Id &&
"templated class must have an identifier");
5040 Diag(TagLoc, diag::err_use_with_wrong_tag)
5055 for (
unsigned i = 0, e = SpecTL.
getNumArgs(); i != e; ++i)
5090 return TPT && !
Type.hasQualifiers() &&
5099 dyn_cast<NonTypeTemplateParmDecl>(DRE->
getDecl());
5105 dyn_cast_or_null<TemplateTemplateParmDecl>(
5109 llvm_unreachable(
"unexpected kind of template argument");
5114 if (Params->
size() != Args.size())
5117 unsigned Depth = Params->
getDepth();
5119 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
5138template<
typename PartialSpecDecl>
5140 if (Partial->getDeclContext()->isDependentContext())
5149 auto *Template = Partial->getSpecializedTemplate();
5150 S.
Diag(Partial->getLocation(),
5151 diag::ext_partial_spec_not_more_specialized_than_primary)
5152 << isa<VarTemplateDecl>(Template);
5161 diag::note_partial_spec_not_more_specialized_than_primary)
5168 Partial->getAssociatedConstraints(PartialAC);
5175 const llvm::SmallBitVector &DeducibleParams) {
5176 for (
unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
5177 if (!DeducibleParams[I]) {
5190template<
typename PartialSpecDecl>
5192 PartialSpecDecl *Partial) {
5205 auto *TemplateParams = Partial->getTemplateParameters();
5206 llvm::SmallBitVector DeducibleParams(TemplateParams->size());
5208 TemplateParams->getDepth(), DeducibleParams);
5210 if (!DeducibleParams.all()) {
5211 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
5212 S.
Diag(Partial->getLocation(), diag::ext_partial_specs_not_deducible)
5213 << isa<VarTemplatePartialSpecializationDecl>(Partial)
5214 << (NumNonDeducible > 1)
5216 Partial->getTemplateArgsAsWritten()->RAngleLoc);
5237 llvm::SmallBitVector DeducibleParams(TemplateParams->size());
5239 for (
unsigned I = 0; I != TemplateParams->size(); ++I) {
5241 auto *Param = TemplateParams->getParam(I);
5243 DeducibleParams[I] =
true;
5246 if (!DeducibleParams.all()) {
5247 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
5248 Diag(TD->
getLocation(), diag::err_deduction_guide_template_not_deducible)
5249 << (NumNonDeducible > 1);
5260 "Variable template specialization is declared with a template id.");
5273 dyn_cast_or_null<VarTemplateDecl>(Name.getAsTemplateDecl());
5276 if (
auto *OTS = Name.getAsOverloadedTemplate())
5277 FnTemplate = *OTS->begin();
5279 FnTemplate = dyn_cast_or_null<FunctionTemplateDecl>(Name.getAsTemplateDecl());
5288 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
5299 false, SugaredConverted, CanonicalConverted,
5307 TemplateArgs.
size(),
5308 CanonicalConverted))
5313 if (!Name.isDependent() &&
5315 TemplateArgs, CanonicalConverted)) {
5316 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
5322 CanonicalConverted) &&
5329 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
5339 void *InsertPos =
nullptr;
5343 PrevDecl =
VarTemplate->findPartialSpecialization(
5344 CanonicalConverted, TemplateParams, InsertPos);
5346 PrevDecl =
VarTemplate->findSpecialization(CanonicalConverted, InsertPos);
5368 cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
5373 CanonicalConverted);
5377 VarTemplate->AddPartialSpecialization(Partial, InsertPos);
5416 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
5420 diag::note_instantiation_required_here)
5450struct PartialSpecMatchResult {
5460 assert(Template &&
"A variable template id without template?");
5465 Template, TemplateNameLoc,
5467 SugaredConverted, CanonicalConverted,
5474 TemplateArgs, CanonicalConverted))
5479 void *InsertPos =
nullptr;
5493 bool AmbiguousPartialSpec =
false;
5508 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
5522 Matched.push_back(PartialSpecMatchResult());
5523 Matched.back().Partial = Partial;
5528 if (Matched.size() >= 1) {
5530 if (Matched.size() == 1) {
5543 PEnd = Matched.end();
5546 PointOfInstantiation) ==
5554 PEnd = Matched.end();
5557 P->Partial, Best->Partial,
5558 PointOfInstantiation) != Best->Partial) {
5559 AmbiguousPartialSpec =
true;
5566 InstantiationPattern = Best->Partial;
5567 PartialSpecArgs = Best->Args;
5579 Template, InstantiationPattern, PartialSpecArgs, TemplateArgs,
5580 CanonicalConverted, TemplateNameLoc );
5584 if (AmbiguousPartialSpec) {
5587 Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
5592 Diag(
P.Partial->getLocation(), diag::note_partial_spec_match)
5599 dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
5600 Decl->setInstantiationOf(D, PartialSpecArgs);
5604 assert(
Decl &&
"No variable template specialization?");
5615 if (
Decl.isInvalid())
5632 Diag(
Loc, diag::err_template_missing_args)
5646 assert(NamedConcept &&
"A concept template id without a template?");
5650 NamedConcept, ConceptNameInfo.
getLoc(),
5652 false, SugaredConverted, CanonicalConverted,
5660 CanonicalConverted);
5662 bool AreArgsDependent =
5664 *TemplateArgs, CanonicalConverted);
5672 if (!AreArgsDependent &&
5682 TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,
5685 Context, CL, CSD, AreArgsDependent ?
nullptr : &Satisfaction);
5704 assert(!R.
isAmbiguous() &&
"ambiguous lookup when building templateid");
5708 if (!TemplateArgs && !isa<FunctionTemplateDecl>(TD)) {
5713 bool KnownDependent =
false;
5722 KnownDependent =
true;
5737 R.
begin(), R.
end(), KnownDependent);
5756 assert(TemplateArgs || TemplateKWLoc.
isValid());
5765 false, TemplateKWLoc))
5777 auto DiagnoseTypeTemplateDecl = [&](
TemplateDecl *Temp,
5778 bool isTypeAliasTemplateDecl) {
5779 Diag(NameInfo.
getLoc(), diag::err_template_kw_refers_to_type_template)
5781 << isTypeAliasTemplateDecl;
5783 << isTypeAliasTemplateDecl;
5788 return DiagnoseTypeTemplateDecl(Temp,
false);
5791 return DiagnoseTypeTemplateDecl(Temp,
true);
5815 bool EnteringContext,
5817 bool AllowInjectedClassName) {
5818 if (TemplateKWLoc.
isValid() && S && !S->getTemplateParamParent())
5821 diag::warn_cxx98_compat_template_outside_of_template :
5822 diag::ext_template_outside_of_template)
5832 else if (ObjectType)
5851 bool MemberOfUnknownSpecialization;
5853 ObjectType, EnteringContext,
Result,
5854 MemberOfUnknownSpecialization);
5857 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
5858 if (!AllowInjectedClassName && SS.
isNotEmpty() && LookupRD &&
5860 Name.Identifier && LookupRD->getIdentifier() == Name.Identifier) {
5870 Diag(Name.getBeginLoc(),
5871 diag::ext_out_of_line_qualified_id_type_names_constructor)
5879 if (!MemberOfUnknownSpecialization) {
5896 Diag(Name.getBeginLoc(), diag::err_no_member)
5899 Diag(Name.getBeginLoc(), diag::err_undeclared_use)
5907 switch (Name.getKind()) {
5915 Qualifier, Name.OperatorFunctionId.Operator));
5929 Diag(Name.getBeginLoc(),
5930 diag::err_template_kw_refers_to_dependent_non_template)
5932 << TemplateKWLoc.
isValid() << TemplateKWLoc;
5969 dyn_cast<DependentScopeDeclRefExpr>(Arg.
getAsExpr())) {
5970 SS.
Adopt(ArgExpr->getQualifierLoc());
5971 NameInfo = ArgExpr->getNameInfo();
5973 dyn_cast<CXXDependentScopeMemberExpr>(Arg.
getAsExpr())) {
5974 if (ArgExpr->isImplicitAccess()) {
5975 SS.
Adopt(ArgExpr->getQualifierLoc());
5976 NameInfo = ArgExpr->getMemberNameInfo();
5985 Result.getResultKind() ==
5987 assert(SS.
getScopeRep() &&
"dependent scope expr must has a scope!");
5991 ? diag::ext_ms_template_type_arg_missing_typename
5992 : diag::err_template_arg_must_be_type_suggest)
6024 SugaredConverted.push_back(Arg);
6025 CanonicalConverted.push_back(Arg);
6031 Diag(SR.
getBegin(), diag::err_template_arg_must_be_type) << SR;
6053 CanonicalConverted.push_back(
6098 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
6101 bool ForLambdaCallOperator =
false;
6102 if (
const auto *Rec = dyn_cast<CXXRecordDecl>(Template->
getDeclContext()))
6103 ForLambdaCallOperator = Rec->isLambda();
6105 !ForLambdaCallOperator);
6107 SemaRef.
SubstType(ArgType, TemplateArgLists,
6150 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
6192 SugaredConverted,
SourceRange(TemplateLoc, RAngleLoc));
6199 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
6227 HasDefaultArg =
false;
6233 HasDefaultArg =
true;
6235 *
this, Template, TemplateLoc, RAngleLoc, TypeParm, SugaredConverted,
6236 CanonicalConverted);
6244 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
6248 HasDefaultArg =
true;
6250 *
this, Template, TemplateLoc, RAngleLoc, NonTypeParm, SugaredConverted,
6251 CanonicalConverted);
6260 = cast<TemplateTemplateParmDecl>(Param);
6264 HasDefaultArg =
true;
6267 *
this, Template, TemplateLoc, RAngleLoc, TempTempParm, SugaredConverted,
6268 CanonicalConverted, QualifierLoc);
6289 QualLoc = ETLoc.getQualifierLoc();
6290 TLoc = ETLoc.getNamedTypeLoc();
6296 QualLoc, InjLoc.getNameLoc());
6304 dyn_cast<ClassTemplateSpecializationDecl>(RecLoc.getDecl()))
6307 QualLoc, RecLoc.getNameLoc());
6341 unsigned ArgumentPackIndex,
6348 CanonicalConverted);
6355 QualType NTTPType = NTTP->getType();
6356 if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
6357 NTTPType = NTTP->getExpansionType(ArgumentPackIndex);
6360 !isa<TemplateTemplateParmDecl>(Template) &&
6375 NTTPType =
SubstType(PET->getPattern(), MLTAL, NTTP->getLocation(),
6376 NTTP->getDeclName());
6378 NTTPType =
SubstType(NTTPType, MLTAL, NTTP->getLocation(),
6379 NTTP->getDeclName());
6386 NTTP->getLocation());
6393 llvm_unreachable(
"Should never see a NULL template argument here");
6400 CanonicalResult, CTAK);
6409 if (Res.
get() != E) {
6414 SugaredConverted.push_back(SugaredResult);
6415 CanonicalConverted.push_back(CanonicalResult);
6426 CanonicalConverted.push_back(
6469 SugaredConverted.push_back(SugaredResult);
6470 CanonicalConverted.push_back(CanonicalResult);
6497 Diag(SR.
getBegin(), diag::err_template_arg_nontype_ambig) << SR <<
T;
6499 Diag(SR.
getBegin(), diag::err_template_arg_must_be_expr) << SR;
6505 llvm_unreachable(
"Caller must expand template argument packs");
6536 Template, SugaredConverted,
true),
6555 llvm_unreachable(
"Should never see a NULL template argument here");
6564 CanonicalConverted.push_back(
6580 llvm_unreachable(
"non-type argument with template template parameter");
6583 llvm_unreachable(
"Caller must expand template argument packs");
6590template<
typename TemplateParmDecl>
6593 const TemplateParmDecl *D,
6598 ->getTemplateParameters()
6599 ->getParam(D->getIndex()));
6606 D->getDefaultArgumentLoc(), Modules,
6617 S.
Diag(
Loc, diag::err_template_arg_list_different_arity)
6633 bool PartialOrderingTTP) {
6652 bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
6655 unsigned ArgIdx = 0, NumArgs = NewArgs.
size();
6658 ParamEnd = Params->
end();
6659 Param != ParamEnd; ) {
6663 if (*Expansions == SugaredArgumentPack.size()) {
6666 SugaredConverted.push_back(
6668 SugaredArgumentPack.clear();
6670 CanonicalConverted.push_back(
6672 CanonicalArgumentPack.clear();
6677 }
else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
6679 Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
6688 if (ArgIdx < NumArgs) {
6691 RAngleLoc, SugaredArgumentPack.size(),
6692 SugaredConverted, CanonicalConverted,
6696 CanonicalConverted.back().setIsDefaulted(
6699 CanonicalConverted, Params->
getDepth()));
6701 bool PackExpansionIntoNonPack =
6702 NewArgs[ArgIdx].getArgument().isPackExpansion() &&
6708 if (PackExpansionIntoNonPack && !PartialOrderingTTP &&
6709 (isa<TypeAliasTemplateDecl>(Template) ||
6710 isa<ConceptDecl>(Template))) {
6716 Diag(NewArgs[ArgIdx].getLocation(),
6717 diag::err_template_expansion_into_fixed_list)
6718 << (isa<ConceptDecl>(Template) ? 1 : 0)
6719 << NewArgs[ArgIdx].getSourceRange();
6727 if ((*Param)->isTemplateParameterPack()) {
6732 SugaredArgumentPack.push_back(SugaredConverted.pop_back_val());
6733 CanonicalArgumentPack.push_back(CanonicalConverted.pop_back_val());
6742 if (PackExpansionIntoNonPack) {
6743 if (!SugaredArgumentPack.empty()) {
6746 SugaredConverted.insert(SugaredConverted.end(),
6747 SugaredArgumentPack.begin(),
6748 SugaredArgumentPack.end());
6749 SugaredArgumentPack.clear();
6751 CanonicalConverted.insert(CanonicalConverted.end(),
6752 CanonicalArgumentPack.begin(),
6753 CanonicalArgumentPack.end());
6754 CanonicalArgumentPack.clear();
6757 while (ArgIdx < NumArgs) {
6759 SugaredConverted.push_back(Arg);
6760 CanonicalConverted.push_back(
6772 if (PartialTemplateArgs) {
6773 if ((*Param)->isTemplateParameterPack() && !SugaredArgumentPack.empty()) {
6774 SugaredConverted.push_back(
6776 CanonicalConverted.push_back(
6784 if ((*Param)->isTemplateParameterPack()) {
6786 "Should have dealt with this already");
6791 if (Param + 1 != ParamEnd) {
6794 "Concept templates must have parameter packs at the end.");
6798 SugaredConverted.push_back(
6800 SugaredArgumentPack.clear();
6802 CanonicalConverted.push_back(
6804 CanonicalArgumentPack.clear();
6824 *
this, Template, TemplateLoc, RAngleLoc, TTP, SugaredConverted,
6825 CanonicalConverted);
6832 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
6838 *
this, Template, TemplateLoc, RAngleLoc, NTTP, SugaredConverted,
6839 CanonicalConverted);
6847 = cast<TemplateTemplateParmDecl>(*Param);
6855 *
this, Template, TemplateLoc, RAngleLoc, TempParm, SugaredConverted,
6856 CanonicalConverted, QualifierLoc);
6877 SugaredConverted, CanonicalConverted,
6881 CanonicalConverted.back().setIsDefaulted(
true);
6886 if (isTemplateTemplateParameter)
6900 while (ArgIdx < NumArgs &&
6901 NewArgs[ArgIdx].
getArgument().isPackExpansion()) {
6903 SugaredConverted.push_back(Arg);
6910 if (ArgIdx < NumArgs) {
6911 Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
6922 if (UpdateArgsWithConversions)
6923 TemplateArgs = std::move(NewArgs);
6925 if (!PartialTemplateArgs) {
6932 if (
auto *TD = dyn_cast<TemplateDecl>(NewContext))
6934 auto *RD = dyn_cast<CXXRecordDecl>(NewContext);
6937 if (
const auto *Method =
6939 ThisQuals = Method->getMethodQualifiers();
6945 Template, NewContext,
false, CanonicalConverted,
6962 class UnnamedLocalNoLinkageFinder
6963 :
public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
6971 UnnamedLocalNoLinkageFinder(
Sema &S,
SourceRange SR) : S(S), SR(SR) { }
6974 return T.isNull() ?
false : inherited::Visit(
T.getTypePtr());
6977#define TYPE(Class, Parent) \
6978 bool Visit##Class##Type(const Class##Type *);
6979#define ABSTRACT_TYPE(Class, Parent) \
6980 bool Visit##Class##Type(const Class##Type *) { return false; }
6981#define NON_CANONICAL_TYPE(Class, Parent) \
6982 bool Visit##Class##Type(const Class##Type *) { return false; }
6983#include "clang/AST/TypeNodes.inc"
6985 bool VisitTagDecl(
const TagDecl *Tag);
6990bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(
const BuiltinType*) {
6994bool UnnamedLocalNoLinkageFinder::VisitComplexType(
const ComplexType*
T) {
6995 return Visit(
T->getElementType());
6998bool UnnamedLocalNoLinkageFinder::VisitPointerType(
const PointerType*
T) {
7002bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
7007bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
7012bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
7017bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
7022bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
7024 return Visit(
T->getElementType());
7027bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
7029 return Visit(
T->getElementType());
7032bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
7034 return Visit(
T->getElementType());
7037bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
7039 return Visit(
T->getElementType());
7042bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
7044 return Visit(
T->getElementType());
7047bool UnnamedLocalNoLinkageFinder::VisitDependentSizedMatrixType(
7049 return Visit(
T->getElementType());
7052bool UnnamedLocalNoLinkageFinder::VisitDependentAddressSpaceType(
7057bool UnnamedLocalNoLinkageFinder::VisitVectorType(
const VectorType*
T) {
7058 return Visit(
T->getElementType());
7061bool UnnamedLocalNoLinkageFinder::VisitDependentVectorType(
7063 return Visit(
T->getElementType());
7066bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(
const ExtVectorType*
T) {
7067 return Visit(
T->getElementType());
7070bool UnnamedLocalNoLinkageFinder::VisitConstantMatrixType(
7072 return Visit(
T->getElementType());
7075bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
7085bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
7090bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
7095bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(
const TypeOfExprType*) {
7099bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(
const TypeOfType*
T) {
7100 return Visit(
T->getUnmodifiedType());
7103bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(
const DecltypeType*) {
7107bool UnnamedLocalNoLinkageFinder::VisitPackIndexingType(
7112bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
7117bool UnnamedLocalNoLinkageFinder::VisitAutoType(
const AutoType *
T) {
7118 return Visit(
T->getDeducedType());
7121bool UnnamedLocalNoLinkageFinder::VisitDeducedTemplateSpecializationType(
7123 return Visit(
T->getDeducedType());
7126bool UnnamedLocalNoLinkageFinder::VisitRecordType(
const RecordType*
T) {
7127 return VisitTagDecl(
T->getDecl());
7130bool UnnamedLocalNoLinkageFinder::VisitEnumType(
const EnumType*
T) {
7131 return VisitTagDecl(
T->getDecl());
7134bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
7139bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
7144bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
7149bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
7151 return VisitTagDecl(
T->getDecl());
7154bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
7156 return VisitNestedNameSpecifier(
T->getQualifier());
7159bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
7161 if (
auto *Q =
T->getQualifier())
7162 return VisitNestedNameSpecifier(Q);
7166bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
7168 return Visit(
T->getPattern());
7171bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(
const ObjCObjectType *) {
7175bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
7180bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
7185bool UnnamedLocalNoLinkageFinder::VisitAtomicType(
const AtomicType*
T) {
7186 return Visit(
T->getValueType());
7189bool UnnamedLocalNoLinkageFinder::VisitPipeType(
const PipeType*
T) {
7193bool UnnamedLocalNoLinkageFinder::VisitBitIntType(
const BitIntType *
T) {
7197bool UnnamedLocalNoLinkageFinder::VisitArrayParameterType(
7199 return VisitConstantArrayType(
T);
7202bool UnnamedLocalNoLinkageFinder::VisitDependentBitIntType(
7207bool UnnamedLocalNoLinkageFinder::VisitTagDecl(
const TagDecl *Tag) {
7209 S.
Diag(SR.getBegin(),
7211 diag::warn_cxx98_compat_template_arg_local_type :
7212 diag::ext_template_arg_local_type)
7218 S.
Diag(SR.getBegin(),
7220 diag::warn_cxx98_compat_template_arg_unnamed_type :
7221 diag::ext_template_arg_unnamed_type) << SR;
7229bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
7247 llvm_unreachable(
"Invalid NestedNameSpecifier::Kind!");
7256 assert(ArgInfo &&
"invalid TypeSourceInfo");
7262 return Diag(SR.
getBegin(), diag::err_variably_modified_template_arg) << Arg;
7264 return Diag(SR.
getBegin(), diag::err_template_arg_overload_type) << SR;
7275 UnnamedLocalNoLinkageFinder Finder(*
this, SR);
7276 (void)Finder.Visit(CanonArg);
7293 Decl *Entity =
nullptr) {
7299 if (Entity && Entity->hasAttr<DLLImportAttr>())
7304 "Incomplete parameter type in isNullPointerValueTemplateArgument!");
7317 EvalResult.
Diag = &Notes;
7325 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
7326 diag::note_invalid_subexpr_in_const_expr) {
7327 DiagLoc = Notes[0].first;
7331 S.
Diag(DiagLoc, diag::err_template_arg_not_address_constant)
7333 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
7334 S.
Diag(Notes[I].first, Notes[I].second);
7352 bool ObjCLifetimeConversion;
7355 ObjCLifetimeConversion))
7360 S.
Diag(Arg->
getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
7379 std::string Code =
"static_cast<" + ParamType.
getAsString() +
">(";
7380 S.
Diag(Arg->
getExprLoc(), diag::err_template_arg_untyped_null_constant)
7399 bool ObjCLifetimeConversion;
7403 ObjCLifetimeConversion)) {
7408 if (!ParamRef->getPointeeType()->isFunctionType()) {
7418 unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
7421 if ((ParamQuals | ArgQuals) != ParamQuals) {
7423 diag::err_template_arg_ref_bind_ignores_quals)
7460 bool AddressTaken =
false;
7467 bool ExtWarnMSTemplateArg =
false;
7470 while (
UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
7472 if (UnOpKind == UO_Deref)
7473 ExtWarnMSTemplateArg =
true;
7474 if (UnOpKind == UO_AddrOf || UnOpKind == UO_Deref) {
7477 FirstOpKind = UnOpKind;
7478 FirstOpLoc = UnOp->getOperatorLoc();
7484 if (ExtWarnMSTemplateArg)
7488 if (FirstOpKind == UO_AddrOf)
7489 AddressTaken =
true;
7493 assert(FirstOpKind == UO_Deref);
7516 bool ExtraParens =
false;
7518 if (!
Invalid && !ExtraParens) {
7521 ? diag::warn_cxx98_compat_template_arg_extra_parens
7522 : diag::ext_template_arg_extra_parens)
7527 Arg =
Parens->getSubExpr();
7531 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
7535 if (UnOp->getOpcode() == UO_AddrOf) {
7536 Arg = UnOp->getSubExpr();
7537 AddressTaken =
true;
7538 AddrOpLoc = UnOp->getOperatorLoc();
7543 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
7548 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg))
7549 Entity = DRE->getDecl();
7551 Entity = CUE->getGuidDecl();
7558 S.
Diag(Arg->
getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
7561 CanonicalConverted =
7578 CanonicalConverted =
7591 if (isa<FieldDecl>(Entity) || isa<IndirectFieldDecl>(Entity)) {
7599 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Entity)) {
7600 if (!Method->isStatic()) {
7609 VarDecl *Var = dyn_cast<VarDecl>(Entity);
7610 MSGuidDecl *Guid = dyn_cast<MSGuidDecl>(Entity);
7613 if (!
Func && !Var && !Guid) {
7625 ? diag::warn_cxx98_compat_template_arg_object_internal
7626 : diag::ext_template_arg_object_internal)
7628 S.
Diag(Entity->
getLocation(), diag::note_template_arg_internal_object)
7633 S.
Diag(Entity->
getLocation(), diag::note_template_arg_internal_object)
7662 S.
Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
7668 S.
Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
7710 CanonicalConverted =
7726 Expr *Arg = ResultArg;
7727 bool ObjCLifetimeConversion;
7739 bool ExtraParens =
false;
7741 if (!
Invalid && !ExtraParens) {
7744 ? diag::warn_cxx98_compat_template_arg_extra_parens
7745 : diag::ext_template_arg_extra_parens)
7750 Arg =
Parens->getSubExpr();
7754 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
7759 if (UnOp->getOpcode() == UO_AddrOf) {
7760 DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());
7766 else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
7769 if (isa<NonTypeTemplateParmDecl>(VD)) {
7772 CanonicalConverted =
7776 CanonicalConverted =
7795 S.
Diag(ResultArg->
getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
7807 ObjCLifetimeConversion)) {
7814 S.
Diag(ResultArg->
getBeginLoc(), diag::err_template_arg_not_convertible)
7822 diag::err_template_arg_not_pointer_to_member_form)
7825 if (isa<FieldDecl>(DRE->
getDecl()) ||
7826 isa<IndirectFieldDecl>(DRE->
getDecl()) ||
7827 isa<CXXMethodDecl>(DRE->
getDecl())) {
7828 assert((isa<FieldDecl>(DRE->
getDecl()) ||
7829 isa<IndirectFieldDecl>(DRE->
getDecl()) ||
7830 cast<CXXMethodDecl>(DRE->
getDecl())
7831 ->isImplicitObjectMemberFunction()) &&
7832 "Only non-static member pointers can make it here");
7838 CanonicalConverted =
7843 CanonicalConverted =
7851 S.
Diag(Arg->
getBeginLoc(), diag::err_template_arg_not_pointer_to_member_form)
7880 auto *AT = dyn_cast<AutoType>(DeducedT);
7881 if (AT && AT->isDecltypeAuto()) {
7892 Expr *DeductionArg = Arg;
7893 if (
auto *PE = dyn_cast<PackExpansionExpr>(DeductionArg))
7894 DeductionArg = PE->getPattern();
7897 if (isa<DeducedTemplateSpecializationType>(DeducedT)) {
7901 DeductionArg->
getBeginLoc(),
false, DeductionArg);
7902 Expr *Inits[1] = {DeductionArg};
7925 diag::err_non_type_template_parm_type_deduction_failure)
7937 if (ParamType.
isNull()) {
7945 "non-type template parameter type cannot be qualified");
7971 Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
7982 auto *PE = dyn_cast<PackExpansionExpr>(Arg);
7984 Arg = PE->getPattern();
7996 PE->getNumExpansions());
8014 if (ParamType->
isRecordType() && isa<DeclRefExpr>(InnerArg) &&
8016 NamedDecl *ND = cast<DeclRefExpr>(InnerArg)->getDecl();
8017 if (
auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
8020 CanonicalConverted =
8024 if (isa<NonTypeTemplateParmDecl>(ND)) {
8026 CanonicalConverted =
8037 bool IsConvertedConstantExpression =
true;
8038 if (isa<InitListExpr>(Arg) || ParamType->
isRecordType()) {
8041 Expr *Inits[1] = {Arg};
8055 IsConvertedConstantExpression =
false;
8064 if (IsConvertedConstantExpression) {
8077 CanonicalConverted =
8085 false, PreNarrowingValue);
8089 if (
Value.isLValue()) {
8102 isa<LifetimeExtendedTemporaryDecl, UnnamedGlobalConstantDecl>(VD))) {
8108 if (
Value.hasLValuePath() &&
Value.getLValuePath().size() == 1 && VD &&
8110 Value.getLValuePath()[0].getAsArrayIndex() == 0 &&
8115 return ArgResult.
get();
8120 if (!
Value.hasLValuePath() ||
Value.getLValuePath().size() ||
8121 Value.isLValueOnePastTheEnd()) {
8122 Diag(StartLoc, diag::err_non_type_template_arg_subobject)
8127 "null reference should not be a constant expression");
8129 "non-null value of type nullptr_t?");
8133 if (
Value.isAddrLabelDiff())
8134 return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
8138 return ArgResult.
get();
8176 CanonicalConverted =
8186 IntegerType =
Enum->getDecl()->getIntegerType();
8192 CanonicalConverted =
8200 Arg = ArgResult.
get();
8213 Diag(Arg->
getBeginLoc(), diag::err_template_arg_not_integral_or_enumeral)
8226 return S.
Diag(
Loc, diag::err_template_arg_not_ice) <<
T;
8228 } Diagnoser(ArgType);
8264 CanonicalConverted =
8271 IntegerType =
Enum->getDecl()->getIntegerType();
8278 if (
Value.getBitWidth() != AllowedBits)
8282 llvm::APSInt OldValue =
Value;
8289 if (
Value.getBitWidth() != AllowedBits)
8295 (OldValue.isSigned() && OldValue.isNegative())) {
8303 unsigned RequiredBits;
8305 RequiredBits = OldValue.getActiveBits();
8306 else if (OldValue.isUnsigned())
8307 RequiredBits = OldValue.getActiveBits() + 1;
8309 RequiredBits = OldValue.getSignificantBits();
8310 if (RequiredBits > AllowedBits) {
8320 CanonicalConverted =
8370 *
this, Param, ParamType, Arg, SugaredConverted,
8371 CanonicalConverted))
8377 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
8388 "Only object pointers allowed here");
8391 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
8403 assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&
8404 "Only object references allowed here");
8408 ParamRefType->getPointeeType(),
8423 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
8432 CanonicalConverted =
8440 << Arg->
getType() << ParamType;
8448 Diag(Arg->
getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
8462 *
this, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))
8484 assert(Name.isDependent() &&
"Non-dependent template isn't a declaration?");
8503 if (!isa<ClassTemplateDecl>(Template) &&
8504 !isa<TemplateTemplateParmDecl>(Template) &&
8505 !isa<TypeAliasTemplateDecl>(Template) &&
8506 !isa<BuiltinTemplateDecl>(Template)) {
8507 assert(isa<FunctionTemplateDecl>(Template) &&
8508 "Only function templates are possible here");
8510 Diag(Template->
getLocation(), diag::note_template_arg_refers_here_func)
8532 Params, Template, Arg.
getLocation(), IsDeduced)) {
8542 if (ParamsAC.empty())
8547 bool IsParamAtLeastAsConstrained;
8549 IsParamAtLeastAsConstrained))
8551 if (!IsParamAtLeastAsConstrained) {
8553 diag::err_template_template_parameter_not_at_least_as_constrained)
8575 unsigned HereDiagID,
8576 unsigned ExternalDiagID) {
8581 llvm::raw_svector_ostream Out(Str);
8589 std::optional<SourceRange> ParamRange) {
8592 diag::note_template_decl_external);
8593 if (ParamRange && ParamRange->isValid()) {
8595 "Parameter range has location when Decl does not");
8602 diag::note_template_param_external);
8629 ? CK_NullToMemberPointer
8630 : CK_NullToPointer);
8633 "Only declaration template arguments permitted here");
8642 (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD) ||
8643 isa<IndirectFieldDecl>(VD)));
8671 assert(isa<TemplateParamObjectDecl>(VD) &&
8672 "arg for class template param not a template parameter object");
8677 "unexpected type for decl template argument");
8679 dyn_cast_if_present<NonTypeTemplateParmDecl>(
TemplateParam)) {
8680 QualType TemplateParamType = NTTP->getType();
8694 "value kind mismatch for non-type template argument");
8714 "unexpected conversion required for non-type template argument");
8741 T = ET->getDecl()->getIntegerType();
8792 llvm_unreachable(
"unexpected template argument value");
8817 return MakeInitList(
8830 return MakeInitList(Elts);
8835 llvm_unreachable(
"Unexpected APValue kind.");
8851 llvm_unreachable(
"Unhandled APValue::ValueKind enum");
8863 llvm_unreachable(
"not a non-type template argument");
8881 llvm_unreachable(
"Unhandled TemplateArgument::ArgKind enum");
8888 const NamedDecl *OldInstFrom,
bool Complain,
8893 unsigned NextDiag = diag::err_template_param_different_kind;
8894 if (TemplateArgLoc.
isValid()) {
8895 S.
Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
8896 NextDiag = diag::note_template_param_different_kind;
8915 unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
8916 if (TemplateArgLoc.
isValid()) {
8917 S.
Diag(TemplateArgLoc,
8918 diag::err_template_arg_template_params_mismatch);
8919 NextDiag = diag::note_template_parameter_pack_non_pack;
8922 unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0
8923 : isa<NonTypeTemplateParmDecl>(New)? 1
8936 = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
8944 (!OldNTTP->getType()->isDependentType() &&
8954 unsigned NextDiag = diag::err_template_nontype_parm_different_type;
8955 if (TemplateArgLoc.
isValid()) {
8956 S.
Diag(TemplateArgLoc,
8957 diag::err_template_arg_template_params_mismatch);
8958 NextDiag = diag::note_template_nontype_parm_different_type;
8963 S.
Diag(OldNTTP->getLocation(),
8964 diag::note_template_nontype_parm_prev_declaration)
8965 << OldNTTP->getType();
8976 dyn_cast<TemplateTemplateParmDecl>(Old)) {
8980 OldTTP->getTemplateParameters(), Complain,
8990 !isa<TemplateTemplateParmDecl>(Old)) {
8991 const Expr *NewC =
nullptr, *OldC =
nullptr;
8993 if (isa<TemplateTypeParmDecl>(New)) {
8994 if (
const auto *TC = cast<TemplateTypeParmDecl>(New)->getTypeConstraint())
8995 NewC = TC->getImmediatelyDeclaredConstraint();
8996 if (
const auto *TC = cast<TemplateTypeParmDecl>(Old)->getTypeConstraint())
8997 OldC = TC->getImmediatelyDeclaredConstraint();
8998 }
else if (isa<NonTypeTemplateParmDecl>(New)) {
8999 if (
const Expr *E = cast<NonTypeTemplateParmDecl>(New)
9000 ->getPlaceholderTypeConstraint())
9002 if (
const Expr *E = cast<NonTypeTemplateParmDecl>(Old)
9003 ->getPlaceholderTypeConstraint())
9006 llvm_unreachable(
"unexpected template parameter type");
9008 auto Diagnose = [&] {
9010 diag::err_template_different_type_constraint);
9012 diag::note_template_prev_declaration) << 0;
9015 if (!NewC != !OldC) {
9042 unsigned NextDiag = diag::err_template_param_list_different_arity;
9043 if (TemplateArgLoc.
isValid()) {
9044 S.
Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
9045 NextDiag = diag::note_template_param_list_different_arity;
9100 OldParmEnd = Old->
end();
9101 OldParm != OldParmEnd; ++OldParm) {
9103 !(*OldParm)->isTemplateParameterPack()) {
9104 if (NewParm == NewParmEnd) {
9113 OldInstFrom, Complain, Kind,
9128 for (; NewParm != NewParmEnd; ++NewParm) {
9130 OldInstFrom, Complain, Kind,
9137 if (NewParm != NewParmEnd) {
9152 diag::err_template_different_requires_clause);
9154 diag::note_template_prev_declaration) << 0;
9157 if (!NewRC != !OldRC) {
9186 S = S->getDeclParent();
9196 Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
9216 if (RD->isLocalClass())
9218 diag::err_template_inside_local_class)
9226 diag::err_template_outside_namespace_or_class_scope)
9237 return Record->getTemplateSpecializationKind();
9239 return Function->getTemplateSpecializationKind();
9240 if (
VarDecl *Var = dyn_cast<VarDecl>(D))
9241 return Var->getTemplateSpecializationKind();
9278 if (isa<ClassTemplateDecl>(Specialized))
9280 else if (isa<VarTemplateDecl>(Specialized))
9282 else if (isa<FunctionTemplateDecl>(Specialized))
9284 else if (isa<CXXMethodDecl>(Specialized))
9286 else if (isa<VarDecl>(Specialized))
9288 else if (isa<RecordDecl>(Specialized))
9290 else if (isa<EnumDecl>(Specialized) && S.
getLangOpts().CPlusPlus11)
9293 S.
Diag(
Loc, diag::err_template_spec_unknown_kind)
9303 S.
Diag(
Loc, diag::err_template_spec_decl_function_scope)
9318 : DC->
Equals(SpecializedContext))) {
9319 if (isa<TranslationUnitDecl>(SpecializedContext))
9320 S.
Diag(
Loc, diag::err_template_spec_redecl_global_scope)
9321 << EntityKind << Specialized;
9323 auto *ND = cast<NamedDecl>(SpecializedContext);
9324 int Diag = diag::err_template_spec_redecl_out_of_scope;
9326 Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
9328 << ND << isa<CXXRecordDecl>(ND);
9331 S.
Diag(Specialized->getLocation(), diag::note_specialized_entity);
9345 DependencyChecker Checker(Depth,
true);
9346 Checker.TraverseStmt(E);
9347 if (Checker.MatchLoc.isInvalid())
9349 return Checker.MatchLoc;
9355 DependencyChecker Checker(Depth,
true);
9356 Checker.TraverseTypeLoc(TL);
9357 if (Checker.MatchLoc.isInvalid())
9359 return Checker.MatchLoc;
9367 for (
unsigned I = 0; I != NumArgs; ++I) {
9370 S, TemplateNameLoc, Param, Args[I].pack_begin(),
9371 Args[I].pack_size(), IsDefaultArgument))
9384 ArgExpr = Expansion->getPattern();
9388 ArgExpr = ICE->getSubExpr();
9398 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
9399 if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
9419 if (ParamUseRange.
isValid()) {
9420 if (IsDefaultArgument) {
9421 S.
Diag(TemplateNameLoc,
9422 diag::err_dependent_non_type_arg_in_partial_spec);
9424 diag::note_dependent_non_type_default_arg_in_partial_spec)
9428 diag::err_dependent_non_type_arg_in_partial_spec)
9436 if (ParamUseRange.
isValid()) {
9438 diag::err_dependent_typed_non_type_arg_in_partial_spec)
9469 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
9471 = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->
getParam(I));
9476 Param, &TemplateArgs[I],
9477 1, I >= NumExplicit))
9489 assert(TUK !=
TUK_Reference &&
"References are not specializations");
9498 = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());
9501 Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
9502 << (Name.getAsTemplateDecl() &&
9503 isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));
9507 bool isMemberSpecialization =
false;
9508 bool isPartialSpecialization =
false;
9514 TemplateNameLoc, &TemplateId,
9526 KWLoc, TemplateNameLoc, SS, &TemplateId,
9527 TemplateParameterLists, TUK ==
TUK_Friend, isMemberSpecialization,
9536 if (TemplateParams && TemplateParams->
size() > 0) {
9537 isPartialSpecialization =
true;
9540 Diag(KWLoc, diag::err_partial_specialization_friend)
9548 for (
unsigned I = 0, N = TemplateParams->
size(); I != N; ++I) {
9553 diag::err_default_arg_in_partial_spec);
9557 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
9558 if (
Expr *DefArg = NTTP->getDefaultArgument()) {
9559 Diag(NTTP->getDefaultArgumentLoc(),
9560 diag::err_default_arg_in_partial_spec)
9561 << DefArg->getSourceRange();
9562 NTTP->removeDefaultArgument();
9568 diag::err_default_arg_in_partial_spec)
9574 }
else if (TemplateParams) {
9576 Diag(KWLoc, diag::err_template_spec_friend)
9582 assert(TUK ==
TUK_Friend &&
"should have a 'template<>' for this decl");
9589 "Invalid enum tag in class template spec!");
9593 Diag(KWLoc, diag::err_use_with_wrong_tag)
9598 diag::note_previous_use);
9607 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
9609 isPartialSpecialization
9618 false, SugaredConverted, CanonicalConverted,
9624 if (isPartialSpecialization) {
9626 TemplateArgs.
size(),
9627 CanonicalConverted))
9632 if (!Name.isDependent() &&
9634 TemplateArgs, CanonicalConverted)) {
9635 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
9637 isPartialSpecialization =
false;
9642 void *InsertPos =
nullptr;
9645 if (isPartialSpecialization)
9647 CanonicalConverted, TemplateParams, InsertPos);
9649 PrevDecl =
ClassTemplate->findSpecialization(CanonicalConverted, InsertPos);
9658 isPartialSpecialization))
9663 if (isPartialSpecialization) {
9668 CanonicalConverted);
9681 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
9691 TemplateParameterLists.size() - 1,
9692 TemplateParameterLists.data());
9697 = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
9701 TemplateNameLoc, TemplateParams,
ClassTemplate, CanonicalConverted,
9702 CanonType, PrevPartial);
9705 if (TemplateParameterLists.size() > 1 && SS.
isSet()) {
9707 Context, TemplateParameterLists.drop_back(1));
9711 ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
9728 if (TemplateParameterLists.size() > 0) {
9730 TemplateParameterLists);
9739 CanonicalConverted);
9763 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
9767 diag::note_instantiation_required_here)
9805 if (ModulePrivateLoc.
isValid())
9807 << (isPartialSpecialization? 1 : 0)
9833 Name, TemplateNameLoc, TemplateArgs, CanonType);
9870 diag::err_concept_decls_may_only_appear_in_global_namespace_scope);
9874 if (TemplateParameterLists.size() > 1) {
9875 Diag(NameLoc, diag::err_concept_extra_headers);
9881 if (Params->
size() == 0) {
9882 Diag(NameLoc, diag::err_concept_no_parameters);
9889 ParamEnd = Params->
end();
9890 ParamIt != ParamEnd; ++ParamIt) {
9891 Decl const *Param = *ParamIt;
9893 if (++ParamIt == ParamEnd)
9896 diag::err_template_param_pack_must_be_last_template_parameter);
9910 Diag(NameLoc, diag::err_concept_no_associated_constraints);
9921 bool AddToScope =
true;
9940 auto *OldConcept = dyn_cast<ConceptDecl>(
Previous.getRepresentativeDecl()->getUnderlyingDecl());
9942 auto *Old =
Previous.getRepresentativeDecl();
9952 Diag(NewDecl->
getLocation(), diag::err_redefinition_different_concept)
9978 if (MinGW || (isa<FunctionDecl>(D) &&
9979 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization()))
9980 D->
dropAttrs<DLLImportAttr, DLLExportAttr>();
9983 FD->setInlineSpecified(
false);
9994 for (
Decl *Prev = D; Prev && !PrevDiagLoc.
isValid();
9995 Prev = Prev->getPreviousDecl()) {
9996 PrevDiagLoc = Prev->getLocation();
9998 assert(PrevDiagLoc.
isValid() &&
9999 "Explicit instantiation without point of instantiation?");
10000 return PrevDiagLoc;
10031 bool &HasNoEffect) {
10032 HasNoEffect =
false;
10039 "previous declaration must be implicit!");
10052 if (PrevPointOfInstantiation.
isInvalid()) {
10066 PrevPointOfInstantiation.
isValid()) &&
10067 "Explicit instantiation without point of instantiation?");
10081 Diag(NewLoc, diag::err_specialization_after_instantiation)
10083 Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
10088 llvm_unreachable(
"The switch over PrevTSK must be exhaustive.");
10094 HasNoEffect =
true;
10109 HasNoEffect =
true;
10118 diag::err_explicit_instantiation_declaration_after_definition);
10124 diag::note_explicit_instantiation_definition_here);
10125 HasNoEffect =
true;
10128 llvm_unreachable(
"Unexpected TemplateSpecializationKind!");
10144 Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
10147 diag::note_previous_template_specialization);
10148 HasNoEffect =
true;
10163 HasNoEffect =
true;
10178 ? diag::ext_explicit_instantiation_duplicate
10179 : diag::err_explicit_instantiation_duplicate)
10182 diag::note_previous_explicit_instantiation);
10183 HasNoEffect =
true;
10188 llvm_unreachable(
"Missing specialization/instantiation case?");
10213 enum DiscardReason { NotAFunctionTemplate, NotAMemberOfEnclosing };
10217 if (!isa<FunctionTemplateDecl>(D)) {
10219 DiscardedCandidates.push_back(std::make_pair(NotAFunctionTemplate, D));
10226 DiscardedCandidates.push_back(std::make_pair(NotAMemberOfEnclosing, D));
10234 Diag(FD->
getLocation(), diag::err_dependent_function_template_spec_no_match)
10236 for (
auto &
P : DiscardedCandidates)
10237 Diag(
P.second->getLocation(),
10238 diag::note_dependent_function_template_spec_discard_reason)
10239 <<
P.first << IsFriend;
10244 ExplicitTemplateArgs);
10279 llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>
10280 ConvertedTemplateArgs;
10301 dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
10302 if (OldMD && OldMD->
isConst()) {
10312 if (ExplicitTemplateArgs)
10313 Args = *ExplicitTemplateArgs;
10325 cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
10326 ExplicitTemplateArgs ? &Args :
nullptr, FT,
Specialization, Info);
10331 I.getPair(), FunTmpl->getTemplatedDecl(),
10347 I.getPair(), FunTmpl->getTemplatedDecl(),
10354 if (ExplicitTemplateArgs)
10363 if (QualifiedFriend && Candidates.
empty()) {
10369 if (
auto *OldFD = dyn_cast<FunctionDecl>(OldND->getUnderlyingDecl()))
10380 PDiag(diag::err_function_template_spec_ambiguous)
10381 << FD->
getDeclName() << (ExplicitTemplateArgs !=
nullptr),
10382 PDiag(diag::note_function_template_spec_matched));
10415 auto *SpecializationFPT =
10426 assert(SpecInfo &&
"Function template specialization info missing?");
10464 bool HasNoEffect =
false;
10490 "This must be the only existing declaration of this specialization");
10505 FD->setFunctionTemplateSpecialization(
10508 ExplicitTemplateArgs ? &ConvertedTemplateArgs[
Specialization] :
nullptr);
10541 assert(!isa<TemplateDecl>(
Member) &&
"Only for non-template members");
10544 NamedDecl *FoundInstantiation =
nullptr;
10553 bool Ambiguous =
false;
10557 dyn_cast<CXXMethodDecl>((*I)->getUnderlyingDecl());
10572 !Satisfaction.IsSatisfied))
10574 Candidates.push_back(Method);
10577 Method, cast<FunctionDecl>(Instantiation))
10579 if (!MoreConstrained) {
10583 if (MoreConstrained == Method) {
10585 FoundInstantiation = *I;
10586 Instantiation = Method;
10592 Diag(
Member->getLocation(), diag::err_function_member_spec_ambiguous)
10593 <<
Member << (InstantiatedFrom ? InstantiatedFrom : Instantiation);
10595 Diag(Candidate->getLocation(), diag::note_function_member_spec_matched)
10599 }
else if (isa<VarDecl>(
Member)) {
10602 (PrevVar = dyn_cast<VarDecl>(
Previous.getFoundDecl())))
10604 FoundInstantiation =
Previous.getRepresentativeDecl();
10605 Instantiation = PrevVar;
10609 }
else if (isa<RecordDecl>(
Member)) {
10612 (PrevRecord = dyn_cast<CXXRecordDecl>(
Previous.getFoundDecl()))) {
10613 FoundInstantiation =
Previous.getRepresentativeDecl();
10614 Instantiation = PrevRecord;
10618 }
else if (isa<EnumDecl>(
Member)) {
10621 (PrevEnum = dyn_cast<EnumDecl>(
Previous.getFoundDecl()))) {
10622 FoundInstantiation =
Previous.getRepresentativeDecl();
10623 Instantiation = PrevEnum;
10629 if (!Instantiation) {
10643 if (InstantiatedFrom && isa<CXXMethodDecl>(
Member)) {
10644 cast<CXXMethodDecl>(
Member)->setInstantiationOfMemberFunction(
10645 cast<CXXMethodDecl>(InstantiatedFrom),
10647 }
else if (InstantiatedFrom && isa<CXXRecordDecl>(
Member)) {
10648 cast<CXXRecordDecl>(
Member)->setInstantiationOfMemberClass(
10649 cast<CXXRecordDecl>(InstantiatedFrom),
10654 Previous.addDecl(FoundInstantiation);
10659 if (!InstantiatedFrom) {
10660 Diag(
Member->getLocation(), diag::err_spec_member_not_instantiated)
10672 assert(MSInfo &&
"Member specialization info missing?");
10674 bool HasNoEffect =
false;
10686 Instantiation,
Member->getLocation(),
10692 if (
auto *MemberFunction = dyn_cast<FunctionDecl>(
Member)) {
10693 FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation);
10698 if (InstantiationFunction->
isDeleted()) {
10701 InstantiationFunction);
10707 MemberFunction->setInstantiationOfMemberFunction(
10709 }
else if (
auto *MemberVar = dyn_cast<VarDecl>(
Member)) {
10710 MemberVar->setInstantiationOfStaticDataMember(
10712 }
else if (
auto *MemberClass = dyn_cast<CXXRecordDecl>(
Member)) {
10713 MemberClass->setInstantiationOfMemberClass(
10715 }
else if (
auto *MemberEnum = dyn_cast<EnumDecl>(
Member)) {
10716 MemberEnum->setInstantiationOfMemberEnum(
10719 llvm_unreachable(
"unknown member specialization kind");
10725 Previous.addDecl(FoundInstantiation);
10734template<
typename DeclT>
10745 OrigD->setLocation(
Loc);
10750 NamedDecl *Instantiation = cast<NamedDecl>(
Member->getCanonicalDecl());
10751 if (Instantiation ==
Member)
10754 if (
auto *
Function = dyn_cast<CXXMethodDecl>(Instantiation))
10756 else if (
auto *Var = dyn_cast<VarDecl>(Instantiation))
10758 else if (
auto *
Record = dyn_cast<CXXRecordDecl>(Instantiation))
10760 else if (
auto *
Enum = dyn_cast<EnumDecl>(Instantiation))
10763 llvm_unreachable(
"unknown member specialization kind");
10771 bool WasQualifiedName) {
10776 S.
Diag(InstLoc, diag::err_explicit_instantiation_in_class)
10789 if (WasQualifiedName) {
10790 if (CurContext->
Encloses(OrigContext))
10797 if (
NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) {
10798 if (WasQualifiedName)
10801 diag::err_explicit_instantiation_out_of_scope :
10802 diag::warn_explicit_instantiation_out_of_scope_0x)
10807 diag::err_explicit_instantiation_unqualified_wrong_namespace :
10808 diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
10813 diag::err_explicit_instantiation_must_be_global :
10814 diag::warn_explicit_instantiation_must_be_global_0x)
10823 bool WasQualifiedName,
10830 S.
Diag(InstLoc, diag::err_explicit_instantiation_internal_linkage) << D;
10858 if (isa<TemplateSpecializationType>(
T))
10868 auto *A = cast_or_null<InheritableAttr>(
getDLLAttr(Def));
10869 assert(A &&
"dllExportImportClassTemplateSpecialization called "
10870 "on Def without dllexport or dllimport");
10875 "delayed exports present at explicit instantiation");
10879 for (
auto &B : Def->
bases()) {
10880 if (
auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
10881 B.getType()->getAsCXXRecordDecl()))
10902 "Invalid enum tag in class template explicit instantiation!");
10908 Diag(TemplateNameLoc, diag::err_tag_reference_non_tag)
10909 << TD << NTK << llvm::to_underlying(Kind);
10915 Kind,
false, KWLoc,
10917 Diag(KWLoc, diag::err_use_with_wrong_tag)
10922 diag::note_previous_use);
10939 if (AL.getKind() == ParsedAttr::AT_DLLExport) {
10941 diag::warn_attribute_dllexport_explicit_instantiation_decl);
10942 Diag(AL.getLoc(), diag::note_attribute);
10947 if (
auto *A =
ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {
10949 diag::warn_attribute_dllexport_explicit_instantiation_decl);
10950 Diag(A->getLocation(), diag::note_attribute);
10956 bool DLLImportExplicitInstantiationDef =
false;
10961 ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
10963 if (AL.getKind() == ParsedAttr::AT_DLLImport)
10965 if (AL.getKind() == ParsedAttr::AT_DLLExport) {
10973 DLLImportExplicitInstantiationDef =
true;
10985 false, SugaredConverted, CanonicalConverted,
10991 void *InsertPos =
nullptr;
10993 ClassTemplate->findSpecialization(CanonicalConverted, InsertPos);
11003 if (AL.getKind() == ParsedAttr::AT_DLLExport) {
11005 diag::warn_attribute_dllexport_explicit_instantiation_def);
11017 bool HasNoEffect =
false;
11020 PrevDecl, PrevDecl_TSK,
11037 PrevDecl =
nullptr;
11041 DLLImportExplicitInstantiationDef) {
11043 HasNoEffect =
false;
11058 if (
const auto *A = PrevDecl->
getAttr<MSInheritanceAttr>()) {
11060 Clone->setInherited(
true);
11066 if (!HasNoEffect && !PrevDecl) {
11079 bool PreviouslyDLLExported =
Specialization->hasAttr<DLLExportAttr>();
11104 = cast_or_null<ClassTemplateSpecializationDecl>(
11114 Def = cast_or_null<ClassTemplateSpecializationDecl>(
11122 DLLImportExplicitInstantiationDef)) {
11132 auto *A = cast<InheritableAttr>(
11134 A->setInherited(
true);
11142 bool NewlyDLLExported =
11143 !PreviouslyDLLExported &&
Specialization->hasAttr<DLLExportAttr>();
11160 "Def and Specialization should match for implicit instantiation");
11168 PrevDecl->
hasAttr<DLLExportAttr>()) {
11193 bool Owned =
false;
11194 bool IsDependent =
false;
11200 assert(!IsDependent &&
"explicit instantiation of dependent name not yet handled");
11205 TagDecl *Tag = cast<TagDecl>(TagD);
11206 assert(!Tag->
isEnum() &&
"shouldn't see enumerations here");
11214 Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
11216 Diag(
Record->getLocation(), diag::note_nontemplate_decl_here);
11227 Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
11242 = cast_or_null<CXXRecordDecl>(
Record->getPreviousDecl());
11247 bool HasNoEffect =
false;
11248 assert(MSInfo &&
"No member specialization information?");
11260 = cast_or_null<CXXRecordDecl>(
Record->getDefinition());
11268 Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
11269 << 0 <<
Record->getDeclName() <<
Record->getDeclContext();
11279 RecordDef = cast_or_null<CXXRecordDecl>(
Record->getDefinition());
11310 diag::err_explicit_instantiation_requires_name)
11317 S = S->getDeclParent();
11349 diag::err_explicit_instantiation_inline :
11350 diag::warn_explicit_instantiation_inline_0x)
11356 diag::err_explicit_instantiation_constexpr);
11392 if (!PrevTemplate) {
11399 Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
11406 diag::err_explicit_instantiation_data_member_not_instantiated)
11421 Diag(
T->getTypeLoc().getBeginLoc(),
11422 diag::err_auto_not_allowed_var_inst);
11431 diag::err_explicit_instantiation_without_template_id)
11433 Diag(PrevTemplate->getLocation(),
11434 diag::note_explicit_instantiation_here);
11457 Prev = cast<VarDecl>(Res.
get());
11472 diag::ext_explicit_instantiation_without_qualified_id)
11480 bool HasNoEffect =
false;
11482 PrevTSK, POI, HasNoEffect))
11485 if (!HasNoEffect) {
11488 if (
auto *VTSD = dyn_cast<VarTemplatePartialSpecializationDecl>(Prev)) {
11489 VTSD->setExternKeywordLoc(ExternLoc);
11490 VTSD->setTemplateKeywordLoc(TemplateLoc);
11504 Diag(
T->getTypeLoc().getBeginLoc(),
11505 diag::err_invalid_var_template_spec_type)
11506 << 0 << PrevTemplate << R << Prev->
getType();
11507 Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
11508 << 2 << PrevTemplate->getDeclName();
11513 return (
Decl*)
nullptr;
11518 bool HasExplicitTemplateArgs =
false;
11522 HasExplicitTemplateArgs =
true;
11536 if (!HasExplicitTemplateArgs) {
11537 if (
CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) {
11541 if (Method->getPrimaryTemplate()) {
11542 TemplateMatches.
addDecl(Method,
P.getAccess());
11545 assert(!NonTemplateMatch &&
"Multiple NonTemplateMatches");
11546 NonTemplateMatch = Method;
11559 FunTmpl, (HasExplicitTemplateArgs ? &TemplateArgs :
nullptr), R,
11593 TemplateMatches.
begin(), TemplateMatches.
end(), FailedCandidates,
11595 PDiag(diag::err_explicit_instantiation_not_known) << Name,
11596 PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
11597 PDiag(diag::note_explicit_instantiation_candidate));
11613 if (FPT->hasExceptionSpec()) {
11615 diag::err_mismatched_exception_spec_explicit_instantiation;
11617 DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;
11620 PDiag(diag::note_explicit_instantiation_here),
11631 diag::err_explicit_instantiation_member_function_not_instantiated)
11640 if (!PrevDecl &&
Specialization->isThisDeclarationADefinition())
11644 bool HasNoEffect =
false;
11655 return (
Decl*)
nullptr;
11666 if (
auto *RD = dyn_cast<CXXRecordDecl>(
Specialization->getDeclContext()))
11667 if (RD->getIdentifier() && RD->getIdentifier()->isStr(
"valarray") &&
11668 RD->isInStdNamespace())
11669 return (
Decl*)
nullptr;
11703 diag::ext_explicit_instantiation_without_qualified_id)
11713 return (
Decl*)
nullptr;
11722 assert(Name &&
"Expected a name in a dependent tag");
11731 Diag(NameLoc, diag::err_dependent_tag_decl)
11758 if (TypenameLoc.
isValid() && S && !S->getTemplateParamParent())
11761 diag::warn_cxx98_compat_typename_outside_of_template :
11762 diag::ext_typename_outside_of_template)
11772 TypenameLoc, QualifierLoc, II, IdLoc, &TSI,
11786 if (TypenameLoc.
isValid() && S && !S->getTemplateParamParent())
11789 diag::warn_cxx98_compat_typename_outside_of_template :
11790 diag::ext_typename_outside_of_template)
11798 if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
11799 Diag(TemplateIILoc,
11800 diag::ext_out_of_line_qualified_id_type_names_constructor)
11802 << (TemplateKWLoc.
isValid() ? 1 : 0 );
11813 assert(DTN &&
"dependent template has non-dependent name?");
11817 DTN->getIdentifier(), TemplateArgs.
arguments());
11829 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
11846 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
11864 if (!II.
isStr(
"type"))
11873 if (!EnableIfTSTLoc || EnableIfTSTLoc.
getNumArgs() == 0)
11886 if (!EnableIfII || !EnableIfII->
isStr(
"enable_if"))
11914 bool DeducedTSTContext) {
11916 DeducedTSTContext);
11921 if (isa<DependentNameType>(
T)) {
11945 SS.
Adopt(QualifierLoc);
11948 if (QualifierLoc) {
11975 unsigned DiagID = 0;
11976 Decl *Referenced =
nullptr;
11977 switch (
Result.getResultKind()) {
11982 Expr *Cond =
nullptr;
11983 if (Ctx &&
isEnableIf(QualifierLoc, II, CondRange, Cond)) {
11988 std::string FailedDescription;
11989 std::tie(FailedCond, FailedDescription) =
11993 diag::err_typename_nested_not_found_requirement)
11994 << FailedDescription
12000 diag::err_typename_nested_not_found_enable_if)
12001 << Ctx << CondRange;
12005 DiagID = Ctx ? diag::err_typename_nested_not_found
12006 : diag::err_unknown_typename;
12015 Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
12016 << Name << Ctx << FullRange;
12018 = dyn_cast<UnresolvedUsingValueDecl>(
Result.getRepresentativeDecl())){
12020 Diag(
Loc, diag::note_using_value_decl_missing_typename)
12050 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(Ctx);
12051 auto *FoundRD = dyn_cast<CXXRecordDecl>(
Type);
12053 FoundRD->isInjectedClassName() &&
12055 Diag(IILoc, diag::ext_out_of_line_qualified_id_type_names_constructor)
12072 if (!DeducedTSTContext) {
12077 Diag(IILoc, diag::err_dependent_deduced_tst)
12080 Diag(IILoc, diag::err_deduced_tst)
12092 DiagID = Ctx ? diag::err_typename_nested_not_type
12093 : diag::err_typename_not_type;
12094 Referenced =
Result.getFoundDecl();
12098 DiagID = Ctx ? diag::err_typename_nested_not_type
12099 : diag::err_typename_not_type;
12100 Referenced = *
Result.begin();
12112 Diag(IILoc, DiagID) << FullRange << Name << Ctx;
12114 Diag(IILoc, DiagID) << FullRange << Name;
12117 Ctx ? diag::note_typename_member_refers_here
12118 : diag::note_typename_refers_here)
12125 class CurrentInstantiationRebuilder
12133 CurrentInstantiationRebuilder(
Sema &SemaRef,
12137 Loc(
Loc), Entity(Entity) { }
12159 this->Entity = Entity;
12201 CurrentInstantiationRebuilder Rebuilder(*
this,
Loc, Name);
12202 return Rebuilder.TransformType(
T);
12206 CurrentInstantiationRebuilder Rebuilder(*
this, E->
getExprLoc(),
12208 return Rebuilder.TransformExpr(E);
12219 = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
12231 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
12235 if (isa<TemplateTypeParmDecl>(Param))
12240 = dyn_cast<TemplateTemplateParmDecl>(Param)) {
12242 TTP->getTemplateParameters()))
12286 unsigned NumArgs) {
12288 llvm::raw_svector_ostream Out(Str);
12290 if (!Params || Params->
size() == 0 || NumArgs == 0)
12291 return std::string();
12293 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
12303 Out <<
Id->getName();
12315 return std::string(Out.str());
12323 auto LPT = std::make_unique<LateParsedTemplate>();
12326 LPT->Toks.swap(Toks);
12373class ExplicitSpecializationVisibilityChecker {
12382 : S(S),
Loc(
Loc), Kind(Kind) {}
12385 if (
auto *FD = dyn_cast<FunctionDecl>(ND))
12386 return checkImpl(FD);
12387 if (
auto *RD = dyn_cast<CXXRecordDecl>(ND))
12388 return checkImpl(RD);
12389 if (
auto *VD = dyn_cast<VarDecl>(ND))
12390 return checkImpl(VD);
12391 if (
auto *ED = dyn_cast<EnumDecl>(ND))
12392 return checkImpl(ED);
12396 void diagnose(
NamedDecl *D,
bool IsPartialSpec) {
12397 auto Kind = IsPartialSpec ? Sema::MissingImportKind::PartialSpecialization
12398 : Sema::MissingImportKind::ExplicitSpecialization;
12399 const bool Recover =
true;
12404 if (Modules.empty())
12410 bool CheckMemberSpecialization(
const NamedDecl *D) {
12411 return Kind == Sema::AcceptableKind::Visible
12416 bool CheckExplicitSpecialization(
const NamedDecl *D) {
12417 return Kind == Sema::AcceptableKind::Visible
12422 bool CheckDeclaration(
const NamedDecl *D) {
12439 template<
typename SpecDecl>
12440 void checkImpl(SpecDecl *Spec) {
12441 bool IsHiddenExplicitSpecialization =
false;
12443 IsHiddenExplicitSpecialization = Spec->getMemberSpecializationInfo()
12444 ? !CheckMemberSpecialization(Spec)
12445 : !CheckExplicitSpecialization(Spec);
12447 checkInstantiated(Spec);
12450 if (IsHiddenExplicitSpecialization)
12451 diagnose(Spec->getMostRecentDecl(),
false);
12460 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
12464 auto From = SD->getSpecializedTemplateOrPartial();
12467 else if (
auto *TD =
12469 if (!CheckDeclaration(TD))
12470 diagnose(TD,
true);
12475 void checkInstantiated(
VarDecl *RD) {
12476 auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
12480 auto From = SD->getSpecializedTemplateOrPartial();
12483 else if (
auto *TD =
12485 if (!CheckDeclaration(TD))
12486 diagnose(TD,
true);
12491 void checkInstantiated(
EnumDecl *FD) {}
12493 template<
typename TemplDecl>
12494 void checkTemplate(TemplDecl *TD) {
12495 if (TD->isMemberSpecialization()) {
12496 if (!CheckMemberSpecialization(TD))
12497 diagnose(TD->getMostRecentDecl(),
false);
12507 ExplicitSpecializationVisibilityChecker(*
this,
Loc,
12517 ExplicitSpecializationVisibilityChecker(*
this,
Loc,
12529 if (
const auto *FD = dyn_cast<FunctionDecl>(N)) {
12537 if (!CSC.isInstantiationRecord() || CSC.PointOfInstantiation.isInvalid())
12539 return CSC.PointOfInstantiation;
Defines the clang::ASTContext interface.
Defines enum values for all the target-independent builtin functions.
static Decl::Kind getKind(const Decl *D)
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Record Record
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
MatchFinder::MatchResult MatchResult
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis for CUDA constructs.
static void SetNestedNameSpecifier(Sema &S, DeclaratorDecl *DD, Declarator &D)
static bool DependsOnTemplateParameters(QualType T, TemplateParameterList *Params)
Determines whether a given type depends on the given parameter list.
static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D)
Determine what kind of template specialization the given declaration is.
static Expr * BuildExpressionFromNonTypeTemplateArgumentValue(Sema &S, QualType T, const APValue &Val, SourceLocation Loc)
static void maybeDiagnoseTemplateParameterShadow(Sema &SemaRef, Scope *S, SourceLocation Loc, const IdentifierInfo *Name)
static TemplateArgumentLoc convertTypeTemplateArgumentToTemplate(ASTContext &Context, TypeLoc TLoc)
Convert a template-argument that we parsed as a type into a template, if possible.
static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized, NamedDecl *PrevDecl, SourceLocation Loc, bool IsPartialSpecialization)
Check whether a specialization is well-formed in the current context.
static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS)
Determine whether the given scope specifier has a template-id in it.
static SourceRange findTemplateParameterInType(unsigned Depth, Expr *E)
static Sema::SemaDiagnosticBuilder noteLocation(Sema &S, const NamedDecl &Decl, unsigned HereDiagID, unsigned ExternalDiagID)
static SourceRange getRangeOfTypeInNestedNameSpecifier(ASTContext &Context, QualType T, const CXXScopeSpec &SS)
static Expr * BuildExpressionFromIntegralTemplateArgumentValue(Sema &S, QualType OrigT, const llvm::APSInt &Int, SourceLocation Loc)
Construct a new expression that refers to the given integral template argument with the given source-...
static SourceRange findTemplateParameter(unsigned Depth, TypeLoc TL)
static NullPointerValueKind isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *Arg, Decl *Entity=nullptr)
Determine whether the given template argument is a null pointer value of the appropriate type.
static ExprResult formImmediatelyDeclaredConstraint(Sema &S, NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, SourceLocation LAngleLoc, SourceLocation RAngleLoc, QualType ConstrainedType, SourceLocation ParamNameLoc, ArgumentLocAppender Appender, SourceLocation EllipsisLoc)
static bool CheckNonTypeTemplatePartialSpecializationArgs(Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param, const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument)
Subroutine of Sema::CheckTemplatePartialSpecializationArgs that checks non-type template partial spec...
static void StripImplicitInstantiation(NamedDecl *D, bool MinGW)
Strips various properties off an implicit instantiation that has just been explicitly specialized.
static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II, SourceRange &CondRange, Expr *&Cond)
Determine whether this failed name lookup should be treated as being disabled by a usage of std::enab...
static void DiagnoseTemplateParameterListArityMismatch(Sema &S, TemplateParameterList *New, TemplateParameterList *Old, Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc)
Diagnose a known arity mismatch when comparing template argument lists.
static bool isTemplateArgumentTemplateParameter(const TemplateArgument &Arg, unsigned Depth, unsigned Index)
static TemplateArgumentListInfo makeTemplateArgumentListInfo(Sema &S, TemplateIdAnnotation &TemplateId)
Convert the parser's template argument list representation into our form.
static bool CheckTemplateArgumentIsCompatibleWithParameter(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn, Expr *Arg, QualType ArgType)
Checks whether the given template argument is compatible with its template parameter.
static bool CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn, TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted)
Checks whether the given template argument is the address of an object or function according to C++ [...
static void collectConjunctionTerms(Expr *Clause, SmallVectorImpl< Expr * > &Terms)
Collect all of the separable terms in the given condition, which might be a conjunction.
static void checkMoreSpecializedThanPrimary(Sema &S, PartialSpecDecl *Partial)
static bool CheckTemplateArgumentPointerToMember(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *&ResultArg, TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted)
Checks whether the given template argument is a pointer to member constant according to C++ [temp....
static SourceLocation DiagLocForExplicitInstantiation(NamedDecl *D, SourceLocation PointOfInstantiation)
Compute the diagnostic location for an explicit instantiation.
static TemplateParameterList * GetTemplateParameterList(TemplateDecl *TD)
static bool isEnableIfAliasTemplate(TypeAliasTemplateDecl *AliasTemplate)
Determine whether this alias template is "enable_if_t".
static bool DiagnoseUnexpandedParameterPacks(Sema &S, TemplateTemplateParmDecl *TTP)
Check for unexpanded parameter packs within the template parameters of a template template parameter,...
static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D, SourceLocation InstLoc, bool WasQualifiedName)
Check the scope of an explicit instantiation.
static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef, const ParsedTemplateArgument &Arg)
static bool isSameAsPrimaryTemplate(TemplateParameterList *Params, ArrayRef< TemplateArgument > Args)
static void checkTemplatePartialSpecialization(Sema &S, PartialSpecDecl *Partial)
static TypeSourceInfo * SubstDefaultTemplateArgument(Sema &SemaRef, TemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, TemplateTypeParmDecl *Param, ArrayRef< TemplateArgument > SugaredConverted, ArrayRef< TemplateArgument > CanonicalConverted)
Substitute template arguments into the default template argument for the given template type paramete...
static bool CheckExplicitInstantiation(Sema &S, NamedDecl *D, SourceLocation InstLoc, bool WasQualifiedName, TemplateSpecializationKind TSK)
Common checks for whether an explicit instantiation of D is valid.
static Expr * lookThroughRangesV3Condition(Preprocessor &PP, Expr *Cond)
static bool DiagnoseDefaultTemplateArgument(Sema &S, Sema::TemplateParamListContext TPC, SourceLocation ParamLoc, SourceRange DefArgRange)
Diagnose the presence of a default template argument on a template parameter, which is ill-formed in ...
static QualType checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD, ArrayRef< TemplateArgument > Converted, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
static void noteNonDeducibleParameters(Sema &S, TemplateParameterList *TemplateParams, const llvm::SmallBitVector &DeducibleParams)
static void completeMemberSpecializationImpl(Sema &S, DeclT *OrigD, SourceLocation Loc)
Complete the explicit specialization of a member of a class template by updating the instantiated mem...
static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc, TemplateDecl *TD, const TemplateParmDecl *D, TemplateArgumentListInfo &Args)
Diagnose a missing template argument.
static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, const Sema::TemplateCompareNewDeclInfo &NewInstFrom, NamedDecl *Old, const NamedDecl *OldInstFrom, bool Complain, Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc)
Match two template parameters within template parameter lists.
static void dllExportImportClassTemplateSpecialization(Sema &S, ClassTemplateSpecializationDecl *Def)
Make a dllexport or dllimport attr on a class template specialization take effect.
Defines the clang::SourceLocation class and associated facilities.
Defines utilities for dealing with stack allocation and stack space.
static const TemplateArgument & getArgument(const TemplateArgument &A)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
const LValueBase getLValueBase() const
APSInt & getComplexIntImag()
ValueKind getKind() const
APFixedPoint & getFixedPoint()
const ValueDecl * getMemberPointerDecl() const
APValue & getVectorElt(unsigned I)
unsigned getVectorLength() const
bool isMemberPointer() const
std::string getAsString(const ASTContext &Ctx, QualType Ty) const
@ Indeterminate
This object has an indeterminate value (C++ [basic.indet]).
@ None
There is no such object (it's outside its lifetime).
bool isNullPointer() const
APSInt & getComplexIntReal()
APFloat & getComplexFloatImag()
APFloat & getComplexFloatReal()
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
unsigned getIntWidth(QualType T) const
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, ArrayRef< TemplateArgumentLoc > Args) const
bool hasSimilarType(QualType T1, QualType T2)
Determine if two types are similar, according to the C++ rules.
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
DeclarationNameTable DeclarationNames
TemplateName getCanonicalTemplateName(const TemplateName &Name) const
Retrieves the "canonical" template name that refers to a given template.
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
const LangOptions & getLangOpts() const
TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl)
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
QualType getCanonicalTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args) const
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
CanQualType UnresolvedTemplateTy
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
bool isSameEntity(const NamedDecl *X, const NamedDecl *Y) const
Determine whether the two declarations refer to the same entity.
TypeSourceInfo * getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc, const TemplateArgumentListInfo &Args, QualType Canon=QualType()) const
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS, const IdentifierInfo *Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template apply.
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
const TargetInfo & getTargetInfo() const
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
QualType getUnconstrainedType(QualType T) const
Remove any type constraints from a template parameter type, for equivalence comparison of template pa...
QualType getLogicalOperationType() const
The result type of logical operations, '<', '>', '!=', etc.
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Underlying=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
void setPrimaryMergedDecl(Decl *D, Decl *Primary)
TemplateName getAssumedTemplateName(DeclarationName Name) const
Retrieve a template name representing an unqualified-id that has been assumed to name a template for ...
Represents a constant array type that does not decay to a pointer when used as a function parameter.
A structure for storing the information associated with a name that has been assumed to be a template...
DeclarationName getDeclName() const
Get the name of the template.
Attr - This represents one attribute.
AutoTypeKeyword getAutoKeyword() const
const NestedNameSpecifierLoc getNestedNameSpecifierLoc() const
SourceLocation getRAngleLoc() const
ConceptDecl * getNamedConcept() const
SourceLocation getLAngleLoc() const
NamedDecl * getFoundDecl() const
DeclarationNameInfo getConceptNameInfo() const
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
bool isDecltypeAuto() const
A fixed int type of a specified bitwidth.
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
BuiltinTemplateKind getBuiltinTemplateKind() const
This class is used for builtin types like 'int'.
static CStyleCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *BasePath, FPOptionsOverride FPO, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R)
static CXXBoolLiteralExpr * Create(const ASTContext &C, bool Val, QualType Ty, SourceLocation Loc)
Represents a C++ constructor within a class.
ExplicitSpecifier getExplicitSpecifier()
Represents a C++ deduction guide declaration.
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation, CXXConstructorDecl *Ctor=nullptr, DeductionCandidate Kind=DeductionCandidate::Normal)
Represents a C++ member access expression where the actual member referenced could not be resolved be...
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents a static or instance method of a struct/union/class.
The null pointer literal (C++11 [lex.nullptr])
Represents a C++ struct/union/class.
CXXRecordDecl * getMostRecentDecl()
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
CXXRecordDecl * getDefinition() const
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
void setDescribedClassTemplate(ClassTemplateDecl *Template)
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization,...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
CXXRecordDecl * getPreviousDecl()
Represents a C++ nested-name-specifier or a global scope specifier.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
char * location_data() const
Retrieve the data associated with the source-location information.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
SourceRange getRange() const
SourceLocation getBeginLoc() const
bool isSet() const
Deprecated.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
bool isEmpty() const
No scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Declaration of a class template.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a class template node.
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template.
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
static ClassTemplatePartialSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, QualType CanonInjectedType, ClassTemplatePartialSpecializationDecl *PrevDecl)
void setMemberSpecialization()
Note that this member template is a specialization.
Represents a class template specialization, which refers to a class template with a given set of temp...
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)
Set the template argument list as written in the sources.
Complex values, per C99 6.2.5p11.
Declaration of a C++20 concept.
Expr * getConstraintExpr() const
bool isTypeConcept() const
static ConceptDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, Expr *ConstraintExpr)
ConceptDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
static ConceptReference * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten)
static ConceptSpecializationExpr * Create(const ASTContext &C, ConceptReference *ConceptRef, ImplicitConceptSpecializationDecl *SpecDecl, const ConstraintSatisfaction *Satisfaction)
const TypeClass * getTypePtr() const
Represents the canonical version of C arrays with a specified constant size.
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
Represents a concrete matrix type with constant number of rows and columns.
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isFileContext() const
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
bool isTransparentContext() const
isTransparentContext - Determines whether this context is a "transparent" context,...
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const
Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
bool isTranslationUnit() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void addDecl(Decl *D)
Add the declaration D into this context.
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
bool isFunctionOrMethod() const
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
A reference to a declared variable, function, enum, etc.
NamedDecl * getFoundDecl()
Get the NamedDecl through which this reference occurred.
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,...
SourceLocation getEndLoc() const LLVM_READONLY
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
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).
unsigned getTemplateDepth() const
Determine the number of levels of template parameter surrounding this declaration.
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.
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.
bool isIdentifier() const
Predicate functions for querying what type of name this is.
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
SourceLocation getBeginLoc() const LLVM_READONLY
void setTypeSourceInfo(TypeSourceInfo *TI)
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
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 the type decltype(expr) (C++11).
Represents a C++17 deduced template specialization type.
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Represents an extended address space qualifier where the input address space value is dependent.
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Represents a qualified type name for which the type name is dependent.
A qualified reference to a name whose declaration cannot yet be resolved.
static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Represents an array type in C++ whose size is a value-dependent expression.
Represents an extended vector type where either the type or size is dependent.
Represents a matrix type where the type and the number of rows and columns is dependent on a template...
Represents a dependent template name that cannot be resolved prior to template instantiation.
bool isIdentifier() const
Determine whether this template name refers to an identifier.
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
unsigned getNumArgs() const
void setTemplateKeywordLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void setLAngleLoc(SourceLocation Loc)
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateNameLoc(SourceLocation Loc)
Represents a template specialization type whose template cannot be resolved, e.g.
Represents a vector type where either the type or size is dependent.
void setElaboratedKeywordLoc(SourceLocation Loc)
TypeLoc getNamedTypeLoc() const
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
RAII object that enters a new expression evaluation context.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
Store information needed for an explicit specifier.
This represents one expression.
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
@ NPC_NeverValueDependent
Specifies that the expression should never be value-dependent.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
ExtVectorType - Extended vector type.
Represents a member of a struct/union/class.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
static FixedPointLiteral * CreateFromRawInt(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l, unsigned Scale)
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, ArrayRef< TemplateParameterList * > FriendTypeTPLists=std::nullopt)
Represents a function declaration or definition.
ConstexprSpecKind getConstexprKind() const
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
SourceLocation getPointOfInstantiation() const
Retrieve the (first) point of instantiation of a function template specialization or a member of a cl...
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
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.
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
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.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
ArrayRef< QualType > param_types() const
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
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.
unsigned getNumParams() const
SourceLocation getLocalRangeEnd() const
void setLocalRangeBegin(SourceLocation L)
void setLParenLoc(SourceLocation Loc)
void setParam(unsigned i, ParmVarDecl *VD)
ArrayRef< ParmVarDecl * > getParams() const
void setRParenLoc(SourceLocation Loc)
void setLocalRangeEnd(SourceLocation L)
void setExceptionSpecRange(SourceRange R)
SourceLocation getLocalRangeBegin() const
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
QualType getReturnType() const
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
StringRef getName() const
Return the actual identifier string.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitConceptSpecializationDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation SL, ArrayRef< TemplateArgument > ConvertedArgs)
Represents a C array with an unspecified size.
const TypeClass * getTypePtr() const
Describes an C or C++ initializer list.
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init)
Create an initialization from an initializer (which, for direct initialization from a parenthesized l...
Describes the sequence of initializations required to initialize a given object or reference with a s...
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
Describes an entity that is being initialized.
static InitializedEntity InitializeTemplateParameter(QualType T, NonTypeTemplateParmDecl *Param)
Create the initialization entity for a template parameter.
Wrapper for source info for injected class names of class templates.
The injected class name of a C++ class template or class template partial specialization.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
An lvalue reference type, per C++11 [dcl.ref].
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Represents a linkage specification.
A stack-allocated class that identifies which local variable declaration instantiations are present i...
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
void InstantiatedLocal(const Decl *D, Decl *Inst)
A class for iterating through a result set and possibly filtering out results.
void erase()
Erase the last element returned from this iterator.
Represents the results of name lookup.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
@ NotFound
No entity found met the criteria.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
@ Found
Name lookup found a single declaration that met the criteria.
bool wasNotFoundInCurrentInstantiation() const
Determine whether no result was found because we could not search into dependent base classes of the ...
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
void setTemplateNameLookup(bool TemplateName)
Sets whether this is a template-name lookup.
DeclClass * getAsSingle() const
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
void setLookupName(DeclarationName Name)
Sets the name to look up.
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.
bool isSuppressingAmbiguousDiagnostics() const
Determines whether this lookup is suppressing ambiguous lookup diagnostics.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
DeclarationName getLookupName() const
Gets the name to look up.
void setNotFoundInCurrentInstantiation()
Note that while no result was found in the current instantiation, there were dependent base classes t...
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 addOuterRetainedLevel()
Add an outermost level that we are not substituting.
void addOuterTemplateArguments(Decl *AssociatedDecl, ArgList Args, bool Final)
Add a new outmost level to the multi-level template argument list.
void setKind(TemplateSubstitutionKind K)
void addOuterRetainedLevels(unsigned Num)
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
NamedDecl * getMostRecentDecl()
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined.
bool hasLinkage() const
Determine whether this declaration has linkage.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
SourceLocation getDefaultArgumentLoc() const
Retrieve the location of the default argument, if any.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
void setDefaultArgument(Expr *DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
unsigned getDepth() const
Get the nesting depth of the template parameter.
void setPlaceholderTypeConstraint(Expr *E)
Interfaces are the core concept in Objective-C for object oriented design.
Represents a pointer to an Objective C object.
Represents a class type in Objective C.
static OpaquePtr make(TemplateName P)
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
A structure for storing the information associated with an overloaded template name.
NamedDecl *const * iterator
Represents a C++11 pack expansion that produces a sequence of expressions.
Represents a pack expansion of types.
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
ParenExpr - This represents a parethesized expression, e.g.
Represents a parameter to a function.
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
SourceRange getDefaultArgRange() const
Retrieve the source range that covers the entire default argument.
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
unsigned getFunctionScopeDepth() const
ParsedAttr - Represents a syntactic attribute.
Represents the parsed form of a C++ template argument.
KindType getKind() const
Determine what kind of template argument we have.
SourceLocation getLocation() const
Retrieve the location of the template argument.
ParsedTemplateTy getAsTemplate() const
Retrieve the template template argument's template name.
ParsedTemplateArgument getTemplatePackExpansion(SourceLocation EllipsisLoc) const
Retrieve a pack expansion of the given template template argument.
ParsedType getAsType() const
Retrieve the template type argument's type.
@ Type
A template type parameter, stored as a type.
@ Template
A template template argument, stored as a template name.
@ NonType
A non-type template parameter, stored as an expression.
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis that makes a template template argument into a pack expansion.
Expr * getAsExpr() const
Retrieve the non-type template argument's expression.
const CXXScopeSpec & getScopeSpec() const
Retrieve the nested-name-specifier that precedes the template name in a template template argument.
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
StringRef getImmediateMacroName(SourceLocation Loc)
Retrieve the name of the immediate macro expansion.
A (possibly-)qualified type.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
void * getAsOpaquePtr() const
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
The collection of all-type qualifiers we support.
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
void setObjCLifetime(ObjCLifetime type)
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
Wrapper for source info for record types.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
bool TraverseTemplateName(TemplateName Template)
Recursively visit a template name and dispatch to the appropriate method.
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
void setMemberSpecialization()
Note that this member template is a specialization.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
Scope - A scope is a transient data structure that is used while parsing the program.
unsigned getFlags() const
getFlags - Return the flags for this scope.
const Scope * getParent() const
getParent - Return the scope that this is nested in.
@ TemplateParamScope
This is a scope that corresponds to the template parameters of a C++ template.
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
void inheritTargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD)
Copies target attributes from the template TD to the function FD.
RAII object used to change the argument pack substitution index within a Sema object.
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
Whether and why a template name is required in this lookup.
SourceLocation getTemplateKeywordLoc() const
bool hasTemplateKeyword() const
Abstract base class used for diagnosing integer constant expression violations.
Sema - This implements semantic analysis and AST building for C.
bool hasReachableDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a reachable definition.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
VarTemplateSpecializationDecl * BuildVarTemplateInstantiation(VarTemplateDecl *VarTemplate, VarDecl *FromVar, const TemplateArgumentList *PartialSpecArgs, const TemplateArgumentListInfo &TemplateArgsInfo, SmallVectorImpl< TemplateArgument > &Converted, SourceLocation PointOfInstantiation, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *StartingScope=nullptr)
bool SubstTypeConstraint(TemplateTypeParmDecl *Inst, const TypeConstraint *TC, const MultiLevelTemplateArgumentList &TemplateArgs, bool EvaluateConstraint)
DeclResult ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, SourceLocation ModulePrivateLoc, CXXScopeSpec &SS, TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr, MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody=nullptr)
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
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.
Scope * getCurScope() const
Retrieve the parser's current scope.
bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false) const
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
LookupNameKind
Describes the kind of name lookup to perform.
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
ExprResult ActOnConstantExpression(ExprResult Res)
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
bool LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, RequiredTemplateKind RequiredTemplate=SourceLocation(), AssumedTemplateKind *ATK=nullptr, bool AllowTypoCorrection=true)
bool SetMemberAccessSpecifier(NamedDecl *MemberDecl, NamedDecl *PrevMemberDecl, AccessSpecifier LexicalAS)
SetMemberAccessSpecifier - Set the access specifier of a member.
bool BuildTypeConstraint(const CXXScopeSpec &SS, TemplateIdAnnotation *TypeConstraint, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc, bool AllowUnexpandedPack)
bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc, TemplateIdAnnotation *TemplateId, bool IsMemberSpecialization)
Diagnose a declaration whose declarator-id has the given nested-name-specifier.
TemplateParameterList * ActOnTemplateParameterList(unsigned Depth, SourceLocation ExportLoc, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
ActOnTemplateParameterList - Builds a TemplateParameterList, optionally constrained by RequiresClause...
TypeResult ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, const IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false, bool IsClassName=false, ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No)
NamedDecl * ActOnTemplateTemplateParameter(Scope *S, SourceLocation TmpLoc, TemplateParameterList *Params, bool Typename, SourceLocation EllipsisLoc, IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth, unsigned Position, SourceLocation EqualLoc, ParsedTemplateArgument DefaultArg)
ActOnTemplateTemplateParameter - Called when a C++ template template parameter (e....
bool ActOnTypeConstraint(const CXXScopeSpec &SS, TemplateIdAnnotation *TypeConstraint, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
bool hasVisibleDeclaration(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine whether any declaration of an entity is visible.
bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info)
DiagnoseClassNameShadow - Implement C++ [class.mem]p13: If T is the name of a class,...
void NoteAllFoundTemplates(TemplateName Name)
bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation, NamedDecl *Instantiation, bool InstantiatedFromMember, const NamedDecl *Pattern, const NamedDecl *PatternDef, TemplateSpecializationKind TSK, bool Complain=true)
Determine whether we would be unable to instantiate this template (because it either has no definitio...
TypeResult ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK, const CXXScopeSpec &SS, const IdentifierInfo *Name, SourceLocation TagLoc, SourceLocation NameLoc)
TemplateDecl * AdjustDeclIfTemplate(Decl *&Decl)
AdjustDeclIfTemplate - If the given decl happens to be a template, reset the parameter D to reference...
void InstantiateClassTemplateSpecializationMembers(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK)
Instantiate the definitions of all of the members of the given class template specialization,...
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
bool TemplateParameterListsAreEqual(const TemplateCompareNewDeclInfo &NewInstFrom, TemplateParameterList *New, const NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
TemplateArgumentLoc SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, Decl *Param, ArrayRef< TemplateArgument > SugaredConverted, ArrayRef< TemplateArgument > CanonicalConverted, bool &HasDefaultArg)
If the given template parameter has a default template argument, substitute into that default templat...
Decl * ActOnConceptDefinition(Scope *S, MultiTemplateParamsArg TemplateParameterLists, const IdentifierInfo *Name, SourceLocation NameLoc, Expr *ConstraintExpr, const ParsedAttributesView &Attrs)
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 ...
FunctionTemplateDecl * DeclareAggregateDeductionGuideFromInitList(TemplateDecl *Template, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc)
FunctionDecl * getMoreConstrainedFunction(FunctionDecl *FD1, FunctionDecl *FD2)
Returns the more constrained function according to the rules of partial ordering by constraints (C++ ...
FunctionDecl * InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD, const TemplateArgumentList *Args, SourceLocation Loc, CodeSynthesisContext::SynthesisKind CSC=CodeSynthesisContext::ExplicitTemplateArgumentSubstitution)
Instantiate (or find existing instantiation of) a function template with a given set of template argu...
void referenceDLLExportedClassMethods()
static NamedDecl * getAsTemplateNameDecl(NamedDecl *D, bool AllowFunctionTemplates=true, bool AllowDependent=true)
Try to interpret the lookup result D as a template-name.
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
TemplateParameterList * MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, ArrayRef< TemplateParameterList * > ParamLists, bool IsFriend, bool &IsMemberSpecialization, bool &Invalid, bool SuppressDiagnostic=false)
Match the given template parameter lists to the given scope specifier, returning the template paramet...
void AddAlignmentAttributesForRecord(RecordDecl *RD)
AddAlignmentAttributesForRecord - Adds any needed alignment attributes to a the record decl,...
bool RequireStructuralType(QualType T, SourceLocation Loc)
Require the given type to be a structural type, and diagnose if it is not.
ExprResult EvaluateConvertedConstantExpression(Expr *E, QualType T, APValue &Value, CCEKind CCE, bool RequireInt, const APValue &PreNarrowingValue)
EvaluateConvertedConstantExpression - Evaluate an Expression That is a converted constant expression ...
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.
LateParsedTemplateMapT LateParsedTemplateMap
void UnmarkAsLateParsedTemplate(FunctionDecl *FD)
CheckTemplateArgumentKind
Specifies the context in which a particular template argument is being checked.
@ CTAK_Specified
The template argument was specified in the code or was instantiated with some deduced template argume...
@ CTAK_Deduced
The template argument was deduced via template argument deduction.
void CheckTemplatePartialSpecialization(ClassTemplatePartialSpecializationDecl *Partial)
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization, bool Disambiguation=false)
ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType)
Convert a parsed type into a parsed template argument.
bool DiagnoseUnknownTemplateName(const IdentifierInfo &II, SourceLocation IILoc, Scope *S, const CXXScopeSpec *SS, TemplateTy &SuggestedTemplate, TemplateNameKind &SuggestedKind)
bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)
IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...
bool ConstraintExpressionDependsOnEnclosingTemplate(const FunctionDecl *Friend, unsigned TemplateDepth, const Expr *Constraint)
bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc, TemplateDecl *PrimaryTemplate, unsigned NumExplicitArgs, ArrayRef< TemplateArgument > Args)
Check the non-type template arguments of a class template partial specialization according to C++ [te...
QualType BuildFunctionType(QualType T, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc, DeclarationName Entity, const FunctionProtoType::ExtProtoInfo &EPI)
Build a function type.
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
DiagnosticsEngine & getDiagnostics() const
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, std::optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
ExprResult BuildExpressionFromNonTypeTemplateArgument(const TemplateArgument &Arg, SourceLocation Loc)
void propagateDLLAttrToBaseClassTemplate(CXXRecordDecl *Class, Attr *ClassAttr, ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc)
Perform propagation of DLL attributes from a derived class to a templated base class for MS compatibi...
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over....
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
void checkSpecializationReachability(SourceLocation Loc, NamedDecl *Spec)
bool hasVisibleDefaultArgument(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if the template parameter D has a visible default argument.
ASTContext & getASTContext() const
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
UnresolvedSetIterator getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd, TemplateSpecCandidateSet &FailedCandidates, SourceLocation Loc, const PartialDiagnostic &NoneDiag, const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag, bool Complain=true, QualType TargetType=QualType())
Retrieve the most specialized of the given function template specializations.
bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
IsIntegralPromotion - Determines whether the conversion from the expression From (whose potentially-a...
TypeSourceInfo * SubstType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, bool AllowDeducedTST=false)
Perform substitution on the type T with a given set of template arguments.
bool IsRedefinitionInModule(const NamedDecl *New, const NamedDecl *Old) const
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param, TemplateParameterList *Params, TemplateArgumentLoc &Arg, bool IsDeduced)
Check a template argument against its corresponding template template parameter.
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD, CachedTokens &Toks)
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)
Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
bool isTemplateTemplateParameterAtLeastAsSpecializedAs(TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc, bool IsDeduced)
TemplateParameterListEqualKind
Enumeration describing how template parameter lists are compared for equality.
@ TPL_TemplateTemplateParmMatch
We are matching the template parameter lists of two template template parameters as part of matching ...
@ TPL_TemplateTemplateArgumentMatch
We are matching the template parameter lists of a template template argument against the template par...
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
@ TPL_TemplateParamsEquivalent
We are determining whether the template-parameters are equivalent according to C++ [temp....
NamedDecl * ActOnTypeParameter(Scope *S, bool Typename, SourceLocation EllipsisLoc, SourceLocation KeyLoc, IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth, unsigned Position, SourceLocation EqualLoc, ParsedType DefaultArg, bool HasTypeConstraint)
ActOnTypeParameter - Called when a C++ template type parameter (e.g., "typename T") has been parsed.
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend=false)
Perform semantic analysis for the given function template specialization.
@ FoundFunctions
This is assumed to be a template name because lookup found one or more functions (but no function tem...
@ None
This is not assumed to be a template name.
@ FoundNothing
This is assumed to be a template name because lookup found nothing.
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true)
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
ArrayRef< InventedTemplateParameterInfo > getInventedParameterInfos() const
void inferGslOwnerPointerAttribute(CXXRecordDecl *Record)
Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
FPOptions & getCurFPFeatures()
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template, const MultiLevelTemplateArgumentList &TemplateArgs, SourceRange TemplateIDRange)
Ensure that the given template arguments satisfy the constraints associated with the given template,...
@ UPPC_PartialSpecialization
Partial specialization.
@ UPPC_DefaultArgument
A default argument.
@ UPPC_ExplicitSpecialization
Explicit specialization.
@ UPPC_NonTypeTemplateParameterType
The type of a non-type template parameter.
@ UPPC_TypeConstraint
A type constraint.
const LangOptions & getLangOpts() const
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl, bool SupportedForCompatibility=false)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter 'PrevD...
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
bool RebuildTemplateParamsInCurrentInstantiation(TemplateParameterList *Params)
Rebuild the template parameters now that we know we're in a current instantiation.
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, QualType ObjectType, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee, SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, std::optional< unsigned > NumExpansions)
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool hasVisibleMemberSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a visible declaration of D that is a member specialization declaration (as oppo...
void checkClassLevelDLLAttribute(CXXRecordDecl *Class)
Check class-level dllimport/dllexport attribute.
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
const LangOptions & LangOpts
void InstantiateClassMembers(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiates the definitions of all of the member of the given class, which is an instantiation of a ...
std::pair< Expr *, std::string > findFailedBooleanCondition(Expr *Cond)
Find the failed Boolean condition within a given Boolean constant expression, and describe it with a ...
llvm::DenseMap< unsigned, CXXDeductionGuideDecl * > AggregateDeductionCandidates
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, bool UpdateArgsWithConversions=true, bool *ConstraintsNotSatisfied=nullptr, bool PartialOrderingTTP=false)
Check that the given template arguments can be provided to the given template, converting the argumen...
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
bool hasAnyAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true, bool AllowNonTemplateFunctions=false)
ExprResult BuildConvertedConstantExpression(Expr *From, QualType T, CCEKind CCE, NamedDecl *Dest=nullptr)
bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD, const TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous)
Perform semantic analysis for the given dependent function template specialization.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
bool hasExplicitCallingConv(QualType T)
NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK)
Given a non-tag type declaration, returns an enum useful for indicating what kind of non-tag type thi...
bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, TemplateArgumentLoc &Arg, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted)
bool AreConstraintExpressionsEqual(const NamedDecl *Old, const Expr *OldConstr, const TemplateCompareNewDeclInfo &New, const Expr *NewConstr)
void AddPushedVisibilityAttribute(Decl *RD)
AddPushedVisibilityAttribute - If '#pragma GCC visibility' was used, add an appropriate visibility at...
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1, ArrayRef< const Expr * > AC1, NamedDecl *D2, ArrayRef< const Expr * > AC2)
If D1 was not at least as constrained as D2, but would've been if a pair of atomic constraints involv...
ExprResult DefaultLvalueConversion(Expr *E)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
void NoteOverloadCandidate(const NamedDecl *Found, const FunctionDecl *Fn, OverloadCandidateRewriteKind RewriteKind=OverloadCandidateRewriteKind(), QualType DestType=QualType(), bool TakingAddress=false)
bool hasReachableDefaultArgument(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if the template parameter D has a reachable default argument.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
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.
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.
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
DeclContext * getFunctionLevelDeclContext(bool AllowLambda=false) const
If AllowLambda is true, treat lambda as function.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
void notePreviousDefinition(const NamedDecl *Old, SourceLocation New)
bool CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, TemplateSpecializationKind ActOnExplicitInstantiationNewTSK, NamedDecl *PrevDecl, TemplateSpecializationKind PrevTSK, SourceLocation PrevPtOfInstantiation, bool &SuppressNew)
Diagnose cases where we have an explicit template specialization before/after an explicit template in...
bool CheckTypeConstraint(TemplateIdAnnotation *TypeConstraint)
TemplateNameKind ActOnTemplateName(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool AllowInjectedClassName=false)
Form a template name from a name that is syntactically required to name a template,...
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName, SourceLocation Less, SourceLocation Greater)
void DeclareImplicitDeductionGuides(TemplateDecl *Template, SourceLocation Loc)
Declare implicit deduction guides for a class template if we've not already done so.
ExprResult FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
DeclResult CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation TemplateNameLoc, const TemplateArgumentListInfo &TemplateArgs)
Get the specialization of the given variable template corresponding to the specified argument list,...
Decl * SubstDecl(Decl *D, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs)
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI, SourceLocation Loc)
Check that the type of a non-type template parameter is well-formed.
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
void diagnoseMissingImport(SourceLocation Loc, const NamedDecl *Decl, MissingImportKind MIK, bool Recover=true)
Diagnose that the specified declaration needs to be visible but isn't, and suggest a module import th...
void FilterAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true, bool AllowDependent=true)
TypeSourceInfo * SubstAutoTypeSourceInfoDependent(TypeSourceInfo *TypeWithAuto)
bool IsAtLeastAsConstrained(NamedDecl *D1, MutableArrayRef< const Expr * > AC1, NamedDecl *D2, MutableArrayRef< const Expr * > AC2, bool &Result)
Check whether the given declaration's associated constraints are at least as constrained than another...
bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams)
Check whether a template can be declared within this scope.
void AddMsStructLayoutForRecord(RecordDecl *RD)
AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
TemplateParameterList * SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs, bool EvaluateConstraints=true)
SourceLocation getTopMostPointOfInstantiation(const NamedDecl *) const
Returns the top most location responsible for the definition of N.
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg, SourceLocation EllipsisLoc)
Invoked when parsing a template argument followed by an ellipsis, which creates a pack expansion.
void ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &Name, TemplateNameKind &TNK, SourceLocation NameLoc, IdentifierInfo *&II)
Try to resolve an undeclared template name as a type template.
bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
Perform semantic analysis for the given non-template member specialization.
TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc, ImplicitTypenameContext IsImplicitTypename=ImplicitTypenameContext::No)
Called when the parser has parsed a C++ typename specifier, e.g., "typename T::type".
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)
Instantiate the definition of a class from a given pattern.
bool hasReachableMemberSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a reachable declaration of D that is a member specialization declaration (as op...
RedeclarationKind forRedeclarationInCurContext() const
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given function from its template.
@ CCEK_TemplateArg
Value of a non-type template parameter.
void InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
void MarkUnusedFileScopedDecl(const DeclaratorDecl *D)
If it's a file scoped decl that must warn if not used, keep track of it.
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)
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
QualType BuildDecltypeType(Expr *E, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
DeclResult ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, OffsetOfKind OOK, SkipBodyInfo *SkipBody=nullptr)
This is invoked when we see 'struct foo' or 'struct {'.
bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, CheckTemplateArgumentKind CTAK)
Check that the given template argument corresponds to the given template parameter.
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
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.
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
bool hasReachableExplicitSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a reachable declaration of D that is an explicit specialization declaration for...
bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name, SourceLocation NameLoc, CXXScopeSpec &SS, ParsedTemplateTy *Template=nullptr)
Determine whether a particular identifier might be the name in a C++1z deduction-guide declaration.
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
NamedDecl * ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, unsigned Depth, unsigned Position, SourceLocation EqualLoc, Expr *DefaultArg)
void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc)
void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D)
Common checks for a parameter-declaration that should apply to both function parameters and non-type ...
TemplateParamListContext
The context in which we are checking a template parameter list.
@ TPC_FriendFunctionTemplate
@ TPC_ClassTemplateMember
@ TPC_FriendClassTemplate
@ TPC_FriendFunctionTemplateDefinition
void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We've found a use of a templated declaration that would trigger an implicit instantiation.
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope.
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, ArrayRef< TemplateArgument > TemplateArgs, sema::TemplateDeductionInfo &Info)
bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name, SourceLocation NameLoc, bool Diagnose=true)
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope.
ExprResult CheckConceptTemplateId(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const TemplateArgumentListInfo *TemplateArgs)
sema::LambdaScopeInfo * getEnclosingLambda() const
Get the innermost lambda enclosing the current location, if any.
void CheckConceptRedefinition(ConceptDecl *NewDecl, LookupResult &Previous, bool &AddToScope)
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
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 BuildBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
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)
bool SubstTemplateArgument(const TemplateArgumentLoc &Input, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentLoc &Output)
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
unsigned getTemplateDepth(Scope *S) const
Determine the number of levels of enclosing template parameters.
ExprResult BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, QualType ParamType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Given a non-type template argument that refers to a declaration and the type of its corresponding non...
TemplateDeductionResult DeduceAutoType(TypeLoc AutoTypeLoc, Expr *Initializer, QualType &Result, sema::TemplateDeductionInfo &Info, bool DependentDeduction=false, bool IgnoreConstraints=false, TemplateSpecCandidateSet *FailedTSC=nullptr)
Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, bool AdjustExceptionSpec=false)
Adjust the type ArgFunctionType to match the calling convention, noreturn, and optionally the excepti...
void NoteTemplateParameterLocation(const NamedDecl &Decl)
IdentifierResolver IdResolver
ArrayRef< sema::FunctionScopeInfo * > getFunctionScopes() const
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD)
bool IsFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy)
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
TypeResult ActOnTagTemplateIdType(TagUseKind TUK, TypeSpecifierType TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy TemplateD, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc)
Parsed an elaborated-type-specifier that refers to a template-id, such as class T::template apply.
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)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
bool hasReachableDeclaration(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine whether any declaration of an entity is reachable.
void MarkDeducedTemplateParameters(const FunctionTemplateDecl *FunctionTemplate, llvm::SmallBitVector &Deduced)
bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc, UnexpandedParameterPackContext UPPC, ArrayRef< UnexpandedParameterPack > Unexpanded)
Diagnose unexpanded parameter packs.
void warnOnReservedIdentifier(const NamedDecl *D)
void inferNullableClassAttribute(CXXRecordDecl *CRD)
Add _Nullable attributes for std:: types.
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Represents the result of substituting a set of types for a template type parameter pack.
Represents the result of substituting a type for a template type parameter.
Represents the declaration of a struct/union/class/enum.
StringRef getKindName() const
void startDefinition()
Starts the definition of this tag declaration.
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type?
TagKind getTagKind() const
bool isBeingDefined() const
Determines whether this type is in the process of being defined.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
A convenient class for passing around template argument information.
SourceLocation getRAngleLoc() const
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void addArgument(const TemplateArgumentLoc &Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
SourceLocation getLAngleLoc() const
A template argument list.
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Location wrapper for a TemplateArgument.
SourceLocation getLocation() const
SourceLocation getTemplateEllipsisLoc() const
const TemplateArgument & getArgument() const
SourceLocation getTemplateNameLoc() const
TypeSourceInfo * getTypeSourceInfo() const
SourceRange getSourceRange() const LLVM_READONLY
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Expr * getSourceExpression() const
Represents a template argument.
QualType getStructuralValueType() const
Get the type of a StructuralValue.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
bool isDependent() const
Whether this template argument is dependent on a template parameter such that its result can change f...
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
QualType getNonTypeTemplateArgumentType() const
If this is a non-type template argument, get its type.
QualType getAsType() const
Retrieve the type for a type template argument.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
static TemplateArgument CreatePackCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument pack by copying the given set of template arguments.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
bool isNull() const
Determine whether this template argument has no value.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
void print(const PrintingPolicy &Policy, raw_ostream &Out, bool IncludeType) const
Print this template argument to the given output stream.
QualType getIntegralType() const
Retrieve the type of the integral value.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion,...
const APValue & getAsStructuralValue() const
Get the value of a StructuralValue.
The base class of all kinds of template declarations (e.g., class, function, etc.).
bool hasAssociatedConstraints() const
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr * > &AC) const
Get the total constraint-expression associated with this template, including constraint-expressions d...
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
bool isNull() const
Determine whether this template name is NULL.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
AssumedTemplateStorage * getAsAssumedTemplateName() const
Retrieve information on a name that has been assumed to be a template-name in order to permit a call ...
UsingShadowDecl * getAsUsingShadowDecl() const
Retrieve the using shadow declaration through which the underlying template declaration is introduced...
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
SourceRange getSourceRange() const LLVM_READONLY
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
bool hasAssociatedConstraints() const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
NamedDecl *const * const_iterator
Iterates through the template parameters in this list.
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr * > &AC) const
All associated constraints derived from this template parameter list, including the requires clause a...
static bool shouldIncludeTypeForArgument(const PrintingPolicy &Policy, const TemplateParameterList *TPL, unsigned Idx)
SourceLocation getTemplateLoc() const
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
void NoteCandidates(Sema &S, SourceLocation Loc)
NoteCandidates - When no template specialization match is found, prints diagnostic messages containin...
SourceLocation getLocation() const
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set.
unsigned getNumArgs() const
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateKeywordLoc(SourceLocation Loc)
TemplateArgumentLoc getArgLoc(unsigned i) const
void setTemplateNameLoc(SourceLocation Loc)
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
Represents a type template specialization; the template must be a class template, a type alias templa...
ArrayRef< TemplateArgument > template_arguments() const
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
static bool anyDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, ArrayRef< TemplateArgument > Converted)
Determine whether any of the given template arguments are dependent.
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
TemplateParameterList * getExpansionTemplateParameters(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
void setInheritedDefaultArgument(const ASTContext &C, TemplateTemplateParmDecl *Prev)
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
unsigned getDepth() const
Get the nesting depth of the template parameter.
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, bool Typename, TemplateParameterList *Params)
void removeDefaultArgument()
Removes the default argument of this template parameter.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Declaration of a template type parameter.
bool wasDeclaredWithTypename() const
Whether this template type parameter was declared with the 'typename' keyword.
SourceLocation getDefaultArgumentLoc() const
Retrieves the location of the default argument declaration.
unsigned getIndex() const
Retrieve the index of the template parameter.
bool hasTypeConstraint() const
Determine whether this template parameter has a type-constraint.
TypeSourceInfo * getDefaultArgumentInfo() const
Retrieves the default argument's source information, if any.
const TypeConstraint * getTypeConstraint() const
Returns the type constraint associated with this template parameter (if any).
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool isExpandedParameterPack() const
Whether this parameter is a template type parameter pack that has a known list of different type-cons...
void removeDefaultArgument()
Removes the default argument of this template parameter.
void setDefaultArgument(TypeSourceInfo *DefArg)
Set the default argument for this template parameter.
bool isParameterPack() const
Returns whether this is a parameter pack.
unsigned getDepth() const
Retrieve the depth of the template parameter.
void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint)
unsigned getNumExpansionParameters() const
Retrieves the number of parameters in an expanded parameter pack.
Wrapper for template type parameters.
TemplateTypeParmDecl * getDecl() const
TemplateTypeParmDecl * getDecl() const
unsigned getIndex() const
unsigned getDepth() const
Represents the declaration of a typedef-name via a C++11 alias-declaration.
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
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 ...
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceLocation getBeginLoc() const
Get the begin source location.
Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expre...
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
A reasonable base class for TypeLocs that correspond to types that are written as a type-specifier.
SourceLocation getNameLoc() const
void setNameLoc(SourceLocation Loc)
static TypeTraitExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, TypeTrait Kind, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc, bool Value)
Create a new type trait expression.
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
The base class of the type hierarchy.
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBooleanType() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
bool isRValueReferenceType() const
bool isVoidPointerType() const
bool isPointerType() const
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isScalarType() const
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
const Type * getArrayElementTypeNoTypeQual() const
If this is an array type, return the element type of the array, potentially with type qualifiers miss...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
bool isObjCObjectOrInterfaceType() const
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isLValueReferenceType() const
bool isBitIntType() const
bool isStructuralType() const
Determine if this type is a structural type, per C++20 [temp.param]p7.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isChar16Type() const
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
QualType getCanonicalTypeInternal() const
bool isMemberPointerType() const
bool isChar32Type() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool hasUnnamedOrLocalType() const
Whether this type is or contains a local or unnamed type.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isVectorType() const
bool isWideCharType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isNullPtrType() const
bool isRecordType() const
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
Base class for declarations which introduce a typedef-name.
TypeSourceInfo * getTypeSourceInfo() const
QualType getUnderlyingType() const
Wrapper for source info for typedefs.
TypedefNameDecl * getTypedefNameDecl() const
Simple class containing the result of Sema::CorrectTypo.
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
DeclClass * getCorrectionDeclAs() const
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represents a C++ unqualified-id that has been parsed.
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)
void addDecl(NamedDecl *D)
The iterator over UnresolvedSets.
A set of unresolved declarations.
Represents the dependent type named by a dependently-scoped typename using declaration,...
Represents a dependent using declaration which was not marked with typename.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
Represents a variable declaration or definition.
TLSKind getTLSKind() const
bool isStaticDataMember() const
Determines whether this is a static data member.
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization,...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template,...
StorageClass getStorageClass() const
Returns the storage class as written in the source.
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
Declaration of a variable template.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > & getPartialSpecializations() const
Retrieve the set of partial specializations of this class template.
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
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 * takeCanonical()
bool hasSFINAEDiagnostic() const
Is a SFINAE diagnostic available?
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
Defines the clang::TargetInfo interface.
The JSON file list parser is used to communicate input to InstallAPI.
TypeSpecifierType
Specifies the kind of type.
bool isa(CodeGen::Address addr)
@ Rewrite
We are substituting template parameters for (typically) other template parameters in order to rewrite...
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
@ IK_OperatorFunctionId
An overloaded operator name, e.g., operator+.
StorageClass
Storage classes.
@ CRK_None
Candidate is not a rewritten candidate.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
@ Result
The result type of a method or function.
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
ActionResult< Expr * > ExprResult
TagTypeKind
The kind of a tag type.
@ Enum
The "enum" keyword.
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema's representation of template deduction information to the form used in overload-can...
@ BTK__type_pack_element
This names the __type_pack_element BuiltinTemplateDecl.
@ BTK__make_integer_seq
This names the __make_integer_seq BuiltinTemplateDecl.
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
CastKind
CastKind - The kind of operation required for a conversion.
std::optional< unsigned > getExpandedPackSize(const NamedDecl *Param)
Check whether the template parameter is a pack expansion, and if so, determine the number of paramete...
SourceRange getTemplateParamsRange(TemplateParameterList const *const *Params, unsigned NumParams)
Retrieves the range of the given template parameter lists.
bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg, const NamedDecl *Param, ArrayRef< TemplateArgument > Args, unsigned Depth)
Make a best-effort determination of whether the type T can be produced by substituting Args into the ...
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
@ TNK_Var_template
The name refers to a variable template whose specialization produces a variable.
@ TNK_Type_template
The name refers to a template whose specialization produces a type.
@ TNK_Dependent_template_name
The name refers to a dependent template name:
@ TNK_Function_template
The name refers to a function template or a set of overloaded functions that includes at least one fu...
@ TNK_Concept_template
The name refers to a concept.
@ TNK_Non_template
The name does not refer to a template.
@ TNK_Undeclared_template
Lookup for the name failed, but we're assuming it was a template name anyway.
ActionResult< ParsedType > TypeResult
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
const FunctionProtoType * T
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
TemplateDeductionResult
Describes the result of template argument deduction.
@ ConstraintsNotSatisfied
The deduced arguments did not satisfy the constraints associated with the template.
@ CUDATargetMismatch
CUDA Target attributes do not match.
@ Success
Template argument deduction was successful.
@ AlreadyDiagnosed
Some error which was already diagnosed.
ActionResult< Decl * > DeclResult
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ None
No keyword precedes the qualified type name.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
@ Parens
New-expression has a C++98 paren-delimited initializer.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
SourceLocation getEndLoc() const LLVM_READONLY
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.
unsigned HasTrailingReturn
Describes how types, statements, expressions, and declarations should be printed.
unsigned PrintCanonicalTypes
Whether to print types as written or canonically.
unsigned TerseOutput
Provide a 'terse' output.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
@ BuildingDeductionGuides
We are building deduction guides for a class.
A stack object to be created when performing template instantiation.
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
Location information for a TemplateArgument.
Information about a template-id annotation token.
const IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
unsigned NumArgs
NumArgs - The number of template arguments.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info)
Contains all information for a given match.