[llvm-branch-commits] [clang] [clang] NFC: rename MatchedPackOnParmToNonPackOnArg to StrictPackMatch (PR #125418)
Matheus Izvekov via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Feb 4 05:19:46 PST 2025
https://github.com/mizvekov updated https://github.com/llvm/llvm-project/pull/125418
>From f558c5838c48e47b62d3d0a3b5118c96d9ff47ec Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Sun, 2 Feb 2025 13:31:20 -0300
Subject: [PATCH] [clang] NFC: rename MatchedPackOnParmToNonPackOnArg to
StrictPackMatch
This rename follows the proposed wording in P3310R5, which introduces
the term 'strict pack match' to refer to the same thing.
---
clang/include/clang/AST/DeclTemplate.h | 12 +++----
clang/include/clang/Sema/Overload.h | 5 ++-
clang/include/clang/Sema/Sema.h | 33 +++++++++----------
clang/include/clang/Sema/TemplateDeduction.h | 10 ++----
clang/lib/AST/ASTImporter.cpp | 8 ++---
clang/lib/AST/DeclTemplate.cpp | 18 ++++------
clang/lib/AST/JSONNodeDumper.cpp | 2 +-
clang/lib/AST/TextNodeDumper.cpp | 2 +-
clang/lib/Sema/SemaOverload.cpp | 30 +++++++----------
clang/lib/Sema/SemaTemplate.cpp | 29 ++++++++--------
clang/lib/Sema/SemaTemplateDeduction.cpp | 21 ++++++------
clang/lib/Sema/SemaTemplateInstantiate.cpp | 16 ++++-----
.../lib/Sema/SemaTemplateInstantiateDecl.cpp | 2 +-
clang/lib/Sema/SemaType.cpp | 3 +-
clang/lib/Serialization/ASTReaderDecl.cpp | 2 +-
clang/lib/Serialization/ASTWriterDecl.cpp | 2 +-
16 files changed, 85 insertions(+), 110 deletions(-)
diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h
index 03c43765206b18..87406b0e030df1 100644
--- a/clang/include/clang/AST/DeclTemplate.h
+++ b/clang/include/clang/AST/DeclTemplate.h
@@ -1842,11 +1842,11 @@ class ClassTemplateSpecializationDecl : public CXXRecordDecl,
unsigned SpecializationKind : 3;
/// Indicate that we have matched a parameter pack with a non pack
- /// argument, when the opposite match is also allowed (strict pack match).
+ /// argument, when the opposite match is also allowed.
/// This needs to be cached as deduction is performed during declaration,
/// and we need the information to be preserved so that it is consistent
/// during instantiation.
- bool MatchedPackOnParmToNonPackOnArg : 1;
+ bool StrictPackMatch : 1;
protected:
ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
@@ -1854,7 +1854,7 @@ class ClassTemplateSpecializationDecl : public CXXRecordDecl,
SourceLocation IdLoc,
ClassTemplateDecl *SpecializedTemplate,
ArrayRef<TemplateArgument> Args,
- bool MatchedPackOnParmToNonPackOnArg,
+ bool StrictPackMatch,
ClassTemplateSpecializationDecl *PrevDecl);
ClassTemplateSpecializationDecl(ASTContext &C, Kind DK);
@@ -1867,7 +1867,7 @@ class ClassTemplateSpecializationDecl : public CXXRecordDecl,
Create(ASTContext &Context, TagKind TK, DeclContext *DC,
SourceLocation StartLoc, SourceLocation IdLoc,
ClassTemplateDecl *SpecializedTemplate,
- ArrayRef<TemplateArgument> Args, bool MatchedPackOnParmToNonPackOnArg,
+ ArrayRef<TemplateArgument> Args, bool StrictPackMatch,
ClassTemplateSpecializationDecl *PrevDecl);
static ClassTemplateSpecializationDecl *CreateDeserialized(ASTContext &C,
GlobalDeclID ID);
@@ -1938,9 +1938,7 @@ class ClassTemplateSpecializationDecl : public CXXRecordDecl,
SpecializationKind = TSK;
}
- bool hasMatchedPackOnParmToNonPackOnArg() const {
- return MatchedPackOnParmToNonPackOnArg;
- }
+ bool hasStrictPackMatch() const { return StrictPackMatch; }
/// Get the point of instantiation (if any), or null if none.
SourceLocation getPointOfInstantiation() const {
diff --git a/clang/include/clang/Sema/Overload.h b/clang/include/clang/Sema/Overload.h
index c7f2422b542dd1..c03ec00d03dc50 100644
--- a/clang/include/clang/Sema/Overload.h
+++ b/clang/include/clang/Sema/Overload.h
@@ -933,7 +933,7 @@ class Sema;
/// Have we matched any packs on the parameter side, versus any non-packs on
/// the argument side, in a context where the opposite matching is also
/// allowed?
- bool HasMatchedPackOnParmToNonPackOnArg : 1;
+ bool StrictPackMatch : 1;
/// True if the candidate was found using ADL.
LLVM_PREFERRED_TYPE(CallExpr::ADLCallKind)
@@ -1010,8 +1010,7 @@ class Sema;
friend class OverloadCandidateSet;
OverloadCandidate()
: IsSurrogate(false), IgnoreObjectArgument(false),
- TookAddressOfOverload(false),
- HasMatchedPackOnParmToNonPackOnArg(false),
+ TookAddressOfOverload(false), StrictPackMatch(false),
IsADLCandidate(llvm::to_underlying(CallExpr::NotADL)),
RewriteKind(CRK_None) {}
};
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 79bf6c04ee4969..9fae6bfa58d254 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -10174,18 +10174,15 @@ class Sema final : public SemaBase {
/// \param PartialOverloading true if we are performing "partial" overloading
/// based on an incomplete set of function arguments. This feature is used by
/// code completion.
- void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl,
- ArrayRef<Expr *> Args,
- OverloadCandidateSet &CandidateSet,
- bool SuppressUserConversions = false,
- bool PartialOverloading = false,
- bool AllowExplicit = true,
- bool AllowExplicitConversion = false,
- ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
- ConversionSequenceList EarlyConversions = {},
- OverloadCandidateParamOrder PO = {},
- bool AggregateCandidateDeduction = false,
- bool HasMatchedPackOnParmToNonPackOnArg = false);
+ void AddOverloadCandidate(
+ FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef<Expr *> Args,
+ OverloadCandidateSet &CandidateSet, bool SuppressUserConversions = false,
+ bool PartialOverloading = false, bool AllowExplicit = true,
+ bool AllowExplicitConversion = false,
+ ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
+ ConversionSequenceList EarlyConversions = {},
+ OverloadCandidateParamOrder PO = {},
+ bool AggregateCandidateDeduction = false, bool StrictPackMatch = false);
/// Add all of the function declarations in the given function set to
/// the overload candidate set.
@@ -10221,7 +10218,7 @@ class Sema final : public SemaBase {
bool PartialOverloading = false,
ConversionSequenceList EarlyConversions = {},
OverloadCandidateParamOrder PO = {},
- bool HasMatchedPackOnParmToNonPackOnArg = false);
+ bool StrictPackMatch = false);
/// Add a C++ member function template as a candidate to the candidate
/// set, using template argument deduction to produce an appropriate member
@@ -10268,7 +10265,7 @@ class Sema final : public SemaBase {
CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
bool AllowExplicit, bool AllowResultConversion = true,
- bool HasMatchedPackOnParmToNonPackOnArg = false);
+ bool StrictPackMatch = false);
/// Adds a conversion function template specialization
/// candidate to the overload set, using template argument deduction
@@ -11688,7 +11685,7 @@ class Sema final : public SemaBase {
/// Is set to true when, in the context of TTP matching, a pack parameter
/// matches non-pack arguments.
- bool MatchedPackOnParmToNonPackOnArg = false;
+ bool StrictPackMatch = false;
};
/// Check that the given template argument corresponds to the given
@@ -11797,7 +11794,7 @@ class Sema final : public SemaBase {
TemplateParameterList *Params,
TemplateArgumentLoc &Arg,
bool PartialOrdering,
- bool *MatchedPackOnParmToNonPackOnArg);
+ bool *StrictPackMatch);
void NoteTemplateLocation(const NamedDecl &Decl,
std::optional<SourceRange> ParamRange = {});
@@ -12491,7 +12488,7 @@ class Sema final : public SemaBase {
bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
TemplateParameterList *PParam, TemplateDecl *PArg, TemplateDecl *AArg,
const DefaultArguments &DefaultArgs, SourceLocation ArgLoc,
- bool PartialOrdering, bool *MatchedPackOnParmToNonPackOnArg);
+ bool PartialOrdering, bool *StrictPackMatch);
/// Mark which template parameters are used in a given expression.
///
@@ -13494,7 +13491,7 @@ class Sema final : public SemaBase {
SourceLocation PointOfInstantiation,
ClassTemplateSpecializationDecl *ClassTemplateSpec,
TemplateSpecializationKind TSK, bool Complain,
- bool PrimaryHasMatchedPackOnParmToNonPackOnArg);
+ bool PrimaryStrictPackMatch);
/// Instantiates the definitions of all of the member
/// of the given class, which is an instantiation of a class template
diff --git a/clang/include/clang/Sema/TemplateDeduction.h b/clang/include/clang/Sema/TemplateDeduction.h
index 9c12eef5c42a06..020e19bc7a6089 100644
--- a/clang/include/clang/Sema/TemplateDeduction.h
+++ b/clang/include/clang/Sema/TemplateDeduction.h
@@ -54,7 +54,7 @@ class TemplateDeductionInfo {
/// Have we matched any packs on the parameter side, versus any non-packs on
/// the argument side, in a context where the opposite matching is also
/// allowed?
- bool MatchedPackOnParmToNonPackOnArg = false;
+ bool StrictPackMatch = false;
/// The template parameter depth for which we're performing deduction.
unsigned DeducedDepth;
@@ -92,13 +92,9 @@ class TemplateDeductionInfo {
return DeducedDepth;
}
- bool hasMatchedPackOnParmToNonPackOnArg() const {
- return MatchedPackOnParmToNonPackOnArg;
- }
+ bool hasStrictPackMatch() const { return StrictPackMatch; }
- void setMatchedPackOnParmToNonPackOnArg() {
- MatchedPackOnParmToNonPackOnArg = true;
- }
+ void setStrictPackMatch() { StrictPackMatch = true; }
/// Get the number of explicitly-specified arguments.
unsigned getNumExplicitArgs() const {
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index 1057f09deda073..c27ebbf838ad16 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -6320,10 +6320,10 @@ ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
updateLookupTableForTemplateParameters(*ToTPList);
} else { // Not a partial specialization.
- if (GetImportedOrCreateDecl(
- D2, D, Importer.getToContext(), D->getTagKind(), DC, *BeginLocOrErr,
- *IdLocOrErr, ClassTemplate, TemplateArgs,
- D->hasMatchedPackOnParmToNonPackOnArg(), PrevDecl))
+ if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), D->getTagKind(),
+ DC, *BeginLocOrErr, *IdLocOrErr, ClassTemplate,
+ TemplateArgs, D->hasStrictPackMatch(),
+ PrevDecl))
return D2;
// Update InsertPos, because preceding import calls may have invalidated
diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp
index fe8734d262a961..7fb89bf5b499fa 100644
--- a/clang/lib/AST/DeclTemplate.cpp
+++ b/clang/lib/AST/DeclTemplate.cpp
@@ -961,16 +961,13 @@ ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(
ASTContext &Context, Kind DK, TagKind TK, DeclContext *DC,
SourceLocation StartLoc, SourceLocation IdLoc,
ClassTemplateDecl *SpecializedTemplate, ArrayRef<TemplateArgument> Args,
- bool MatchedPackOnParmToNonPackOnArg,
- ClassTemplateSpecializationDecl *PrevDecl)
+ bool StrictPackMatch, ClassTemplateSpecializationDecl *PrevDecl)
: CXXRecordDecl(DK, TK, Context, DC, StartLoc, IdLoc,
SpecializedTemplate->getIdentifier(), PrevDecl),
SpecializedTemplate(SpecializedTemplate),
TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
- SpecializationKind(TSK_Undeclared),
- MatchedPackOnParmToNonPackOnArg(MatchedPackOnParmToNonPackOnArg) {
- assert(DK == Kind::ClassTemplateSpecialization ||
- MatchedPackOnParmToNonPackOnArg == false);
+ SpecializationKind(TSK_Undeclared), StrictPackMatch(StrictPackMatch) {
+ assert(DK == Kind::ClassTemplateSpecialization || StrictPackMatch == false);
}
ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(ASTContext &C,
@@ -982,11 +979,11 @@ ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(ASTContext &C,
ClassTemplateSpecializationDecl *ClassTemplateSpecializationDecl::Create(
ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc,
SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate,
- ArrayRef<TemplateArgument> Args, bool MatchedPackOnParmToNonPackOnArg,
+ ArrayRef<TemplateArgument> Args, bool StrictPackMatch,
ClassTemplateSpecializationDecl *PrevDecl) {
auto *Result = new (Context, DC) ClassTemplateSpecializationDecl(
Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
- SpecializedTemplate, Args, MatchedPackOnParmToNonPackOnArg, PrevDecl);
+ SpecializedTemplate, Args, StrictPackMatch, PrevDecl);
Result->setMayHaveOutOfDateDef(false);
// If the template decl is incomplete, copy the external lexical storage from
@@ -1173,10 +1170,9 @@ ClassTemplatePartialSpecializationDecl::ClassTemplatePartialSpecializationDecl(
ClassTemplatePartialSpecializationDecl *PrevDecl)
: ClassTemplateSpecializationDecl(
Context, ClassTemplatePartialSpecialization, TK, DC, StartLoc, IdLoc,
- // Tracking MatchedPackOnParmToNonPackOnArg for Partial
+ // Tracking StrictPackMatch for Partial
// Specializations is not needed.
- SpecializedTemplate, Args, /*MatchedPackOnParmToNonPackOnArg=*/false,
- PrevDecl),
+ SpecializedTemplate, Args, /*StrictPackMatch=*/false, PrevDecl),
TemplateParams(Params), InstantiatedFromMember(nullptr, false) {
if (AdoptTemplateParameterList(Params, this))
setInvalidDecl();
diff --git a/clang/lib/AST/JSONNodeDumper.cpp b/clang/lib/AST/JSONNodeDumper.cpp
index 4ab0e7cb5815b6..169e3ee94c221b 100644
--- a/clang/lib/AST/JSONNodeDumper.cpp
+++ b/clang/lib/AST/JSONNodeDumper.cpp
@@ -1004,7 +1004,7 @@ void JSONNodeDumper::VisitCXXRecordDecl(const CXXRecordDecl *RD) {
VisitRecordDecl(RD);
if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
- if (CTSD->hasMatchedPackOnParmToNonPackOnArg())
+ if (CTSD->hasStrictPackMatch())
JOS.attribute("strict-pack-match", true);
}
diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp
index 7f5a825b687983..0ad96425b50193 100644
--- a/clang/lib/AST/TextNodeDumper.cpp
+++ b/clang/lib/AST/TextNodeDumper.cpp
@@ -2527,7 +2527,7 @@ void TextNodeDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
}
if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
dumpTemplateSpecializationKind(CTSD->getSpecializationKind());
- if (CTSD->hasMatchedPackOnParmToNonPackOnArg())
+ if (CTSD->hasStrictPackMatch())
OS << " strict-pack-match";
}
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index 16ecea67aea972..8d5b5ac190b5bf 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -6927,7 +6927,7 @@ void Sema::AddOverloadCandidate(
bool PartialOverloading, bool AllowExplicit, bool AllowExplicitConversions,
ADLCallKind IsADLCandidate, ConversionSequenceList EarlyConversions,
OverloadCandidateParamOrder PO, bool AggregateCandidateDeduction,
- bool HasMatchedPackOnParmToNonPackOnArg) {
+ bool StrictPackMatch) {
const FunctionProtoType *Proto
= dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
assert(Proto && "Functions without a prototype cannot be overloaded");
@@ -6947,7 +6947,7 @@ void Sema::AddOverloadCandidate(
Expr::Classification::makeSimpleLValue(), Args,
CandidateSet, SuppressUserConversions,
PartialOverloading, EarlyConversions, PO,
- HasMatchedPackOnParmToNonPackOnArg);
+ StrictPackMatch);
return;
}
// We treat a constructor like a non-member function, since its object
@@ -6990,8 +6990,7 @@ void Sema::AddOverloadCandidate(
CandidateSet.getRewriteInfo().getRewriteKind(Function, PO);
Candidate.IsADLCandidate = llvm::to_underlying(IsADLCandidate);
Candidate.ExplicitCallArguments = Args.size();
- Candidate.HasMatchedPackOnParmToNonPackOnArg =
- HasMatchedPackOnParmToNonPackOnArg;
+ Candidate.StrictPackMatch = StrictPackMatch;
// Explicit functions are not actually candidates at all if we're not
// allowing them in this context, but keep them around so we can point
@@ -7563,7 +7562,7 @@ void Sema::AddMethodCandidate(
Expr::Classification ObjectClassification, ArrayRef<Expr *> Args,
OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
bool PartialOverloading, ConversionSequenceList EarlyConversions,
- OverloadCandidateParamOrder PO, bool HasMatchedPackOnParmToNonPackOnArg) {
+ OverloadCandidateParamOrder PO, bool StrictPackMatch) {
const FunctionProtoType *Proto
= dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
assert(Proto && "Methods without a prototype cannot be overloaded");
@@ -7594,8 +7593,7 @@ void Sema::AddMethodCandidate(
Candidate.TookAddressOfOverload =
CandidateSet.getKind() == OverloadCandidateSet::CSK_AddressOfOverloadSet;
Candidate.ExplicitCallArguments = Args.size();
- Candidate.HasMatchedPackOnParmToNonPackOnArg =
- HasMatchedPackOnParmToNonPackOnArg;
+ Candidate.StrictPackMatch = StrictPackMatch;
bool IgnoreExplicitObject =
(Method->isExplicitObjectMemberFunction() &&
@@ -7805,8 +7803,7 @@ void Sema::AddMethodTemplateCandidate(
AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
ActingContext, ObjectType, ObjectClassification, Args,
CandidateSet, SuppressUserConversions, PartialOverloading,
- Conversions, PO,
- Info.hasMatchedPackOnParmToNonPackOnArg());
+ Conversions, PO, Info.hasStrictPackMatch());
}
/// Determine whether a given function template has a simple explicit specifier
@@ -7894,7 +7891,7 @@ void Sema::AddTemplateOverloadCandidate(
PartialOverloading, AllowExplicit,
/*AllowExplicitConversions=*/false, IsADLCandidate, Conversions, PO,
Info.AggregateDeductionCandidateHasMismatchedArity,
- Info.hasMatchedPackOnParmToNonPackOnArg());
+ Info.hasStrictPackMatch());
}
bool Sema::CheckNonDependentConversions(
@@ -8016,8 +8013,7 @@ void Sema::AddConversionCandidate(
CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
- bool AllowExplicit, bool AllowResultConversion,
- bool HasMatchedPackOnParmToNonPackOnArg) {
+ bool AllowExplicit, bool AllowResultConversion, bool StrictPackMatch) {
assert(!Conversion->getDescribedFunctionTemplate() &&
"Conversion function templates use AddTemplateConversionCandidate");
QualType ConvType = Conversion->getConversionType().getNonReferenceType();
@@ -8062,8 +8058,7 @@ void Sema::AddConversionCandidate(
Candidate.FinalConversion.setAllToTypes(ToType);
Candidate.Viable = true;
Candidate.ExplicitCallArguments = 1;
- Candidate.HasMatchedPackOnParmToNonPackOnArg =
- HasMatchedPackOnParmToNonPackOnArg;
+ Candidate.StrictPackMatch = StrictPackMatch;
// Explicit functions are not actually candidates at all if we're not
// allowing them in this context, but keep them around so we can point
@@ -8266,7 +8261,7 @@ void Sema::AddTemplateConversionCandidate(
AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
CandidateSet, AllowObjCConversionOnExplicit,
AllowExplicit, AllowResultConversion,
- Info.hasMatchedPackOnParmToNonPackOnArg());
+ Info.hasStrictPackMatch());
}
void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
@@ -10618,9 +10613,8 @@ bool clang::isBetterOverloadCandidate(
isa<CXXConstructorDecl>(Cand2.Function))
return isa<CXXConstructorDecl>(Cand1.Function);
- if (Cand1.HasMatchedPackOnParmToNonPackOnArg !=
- Cand2.HasMatchedPackOnParmToNonPackOnArg)
- return Cand2.HasMatchedPackOnParmToNonPackOnArg;
+ if (Cand1.StrictPackMatch != Cand2.StrictPackMatch)
+ return Cand2.StrictPackMatch;
// -- F1 is a non-template function and F2 is a function template
// specialization, or, if not that,
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index f180be2c1a5e15..9e68972b33f0a0 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -3651,7 +3651,7 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
ClassTemplate->getDeclContext(),
ClassTemplate->getTemplatedDecl()->getBeginLoc(),
ClassTemplate->getLocation(), ClassTemplate, CTAI.CanonicalConverted,
- CTAI.MatchedPackOnParmToNonPackOnArg, nullptr);
+ CTAI.StrictPackMatch, nullptr);
ClassTemplate->AddSpecialization(Decl, InsertPos);
if (ClassTemplate->isOutOfLine())
Decl->setLexicalDeclContext(ClassTemplate->getLexicalDeclContext());
@@ -5436,7 +5436,7 @@ bool Sema::CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &ArgLoc,
case TemplateArgument::TemplateExpansion:
if (CheckTemplateTemplateArgument(TempParm, Params, ArgLoc,
CTAI.PartialOrdering,
- &CTAI.MatchedPackOnParmToNonPackOnArg))
+ &CTAI.StrictPackMatch))
return true;
CTAI.SugaredConverted.push_back(Arg);
@@ -5762,7 +5762,7 @@ bool Sema::CheckTemplateArgumentList(
SaveAndRestore _1(CTAI.PartialOrdering, false);
SaveAndRestore _2(CTAI.MatchingTTP, false);
- SaveAndRestore _3(CTAI.MatchedPackOnParmToNonPackOnArg, {});
+ SaveAndRestore _3(CTAI.StrictPackMatch, {});
// Check the default template argument.
if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc, RAngleLoc, 0,
CTAI, CTAK_Specified))
@@ -7361,10 +7361,11 @@ static void DiagnoseTemplateParameterListArityMismatch(
Sema &S, TemplateParameterList *New, TemplateParameterList *Old,
Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc);
-bool Sema::CheckTemplateTemplateArgument(
- TemplateTemplateParmDecl *Param, TemplateParameterList *Params,
- TemplateArgumentLoc &Arg, bool PartialOrdering,
- bool *MatchedPackOnParmToNonPackOnArg) {
+bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
+ TemplateParameterList *Params,
+ TemplateArgumentLoc &Arg,
+ bool PartialOrdering,
+ bool *StrictPackMatch) {
TemplateName Name = Arg.getArgument().getAsTemplateOrTemplatePattern();
auto [Template, DefaultArgs] = Name.getTemplateDeclAndDefaultArgs();
if (!Template) {
@@ -7404,7 +7405,7 @@ bool Sema::CheckTemplateTemplateArgument(
// is at least as specialized as the template-argument A.
if (!isTemplateTemplateParameterAtLeastAsSpecializedAs(
Params, Param, Template, DefaultArgs, Arg.getLocation(),
- PartialOrdering, MatchedPackOnParmToNonPackOnArg))
+ PartialOrdering, StrictPackMatch))
return true;
// P2113
// C++20[temp.func.order]p2
@@ -8526,8 +8527,7 @@ DeclResult Sema::ActOnClassTemplateSpecialization(
// this explicit specialization or friend declaration.
Specialization = ClassTemplateSpecializationDecl::Create(
Context, Kind, DC, KWLoc, TemplateNameLoc, ClassTemplate,
- CTAI.CanonicalConverted, CTAI.MatchedPackOnParmToNonPackOnArg,
- PrevDecl);
+ CTAI.CanonicalConverted, CTAI.StrictPackMatch, PrevDecl);
Specialization->setTemplateArgsAsWritten(TemplateArgs);
SetNestedNameSpecifier(*this, Specialization, SS);
if (TemplateParameterLists.size() > 0) {
@@ -9870,8 +9870,7 @@ DeclResult Sema::ActOnExplicitInstantiation(
// this explicit specialization.
Specialization = ClassTemplateSpecializationDecl::Create(
Context, Kind, ClassTemplate->getDeclContext(), KWLoc, TemplateNameLoc,
- ClassTemplate, CTAI.CanonicalConverted,
- CTAI.MatchedPackOnParmToNonPackOnArg, PrevDecl);
+ ClassTemplate, CTAI.CanonicalConverted, CTAI.StrictPackMatch, PrevDecl);
SetNestedNameSpecifier(*this, Specialization, SS);
// A MSInheritanceAttr attached to the previous declaration must be
@@ -9926,9 +9925,9 @@ DeclResult Sema::ActOnExplicitInstantiation(
= cast_or_null<ClassTemplateSpecializationDecl>(
Specialization->getDefinition());
if (!Def)
- InstantiateClassTemplateSpecialization(
- TemplateNameLoc, Specialization, TSK,
- /*Complain=*/true, CTAI.MatchedPackOnParmToNonPackOnArg);
+ InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK,
+ /*Complain=*/true,
+ CTAI.StrictPackMatch);
else if (TSK == TSK_ExplicitInstantiationDefinition) {
MarkVTableUsed(TemplateNameLoc, Specialization, true);
Specialization->setPointOfInstantiation(Def->getPointOfInstantiation());
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index 425c41f0f62367..096844f55374bc 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -2776,7 +2776,7 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
if (!FoldPackParameter)
return TemplateDeductionResult::MiscellaneousDeductionFailure;
if (FoldPackArgument)
- Info.setMatchedPackOnParmToNonPackOnArg();
+ Info.setStrictPackMatch();
}
// Deduce template arguments from the pattern.
if (auto Result = DeduceTemplateArguments(
@@ -2972,7 +2972,7 @@ ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param,
Arg, QualType(), Info.getLocation(), Param);
SaveAndRestore _1(CTAI.MatchingTTP, false);
- SaveAndRestore _2(CTAI.MatchedPackOnParmToNonPackOnArg, false);
+ SaveAndRestore _2(CTAI.StrictPackMatch, false);
// Check the template argument, converting it as necessary.
auto Res = S.CheckTemplateArgument(
Param, ArgLoc, Template, Template->getLocation(),
@@ -2981,8 +2981,8 @@ ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param,
? (Arg.wasDeducedFromArrayBound() ? Sema::CTAK_DeducedFromArrayBound
: Sema::CTAK_Deduced)
: Sema::CTAK_Specified);
- if (CTAI.MatchedPackOnParmToNonPackOnArg)
- Info.setMatchedPackOnParmToNonPackOnArg();
+ if (CTAI.StrictPackMatch)
+ Info.setStrictPackMatch();
return Res;
};
@@ -3177,7 +3177,7 @@ static TemplateDeductionResult ConvertDeducedTemplateArguments(
SaveAndRestore _1(CTAI.PartialOrdering, false);
SaveAndRestore _2(CTAI.MatchingTTP, false);
- SaveAndRestore _3(CTAI.MatchedPackOnParmToNonPackOnArg, false);
+ SaveAndRestore _3(CTAI.StrictPackMatch, false);
// Check whether we can actually use the default argument.
if (S.CheckTemplateArgument(
Param, DefArg, TD, TD->getLocation(), TD->getSourceRange().getEnd(),
@@ -6512,7 +6512,7 @@ bool Sema::isMoreSpecializedThanPrimary(
bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
TemplateParameterList *P, TemplateDecl *PArg, TemplateDecl *AArg,
const DefaultArguments &DefaultArgs, SourceLocation ArgLoc,
- bool PartialOrdering, bool *MatchedPackOnParmToNonPackOnArg) {
+ bool PartialOrdering, bool *StrictPackMatch) {
// C++1z [temp.arg.template]p4: (DR 150)
// A template template-parameter P is at least as specialized as a
// template template-argument A if, given the following rewrite to two
@@ -6570,8 +6570,8 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
/*ConstraintsNotSatisfied=*/nullptr))
return false;
PArgs = std::move(CTAI.SugaredConverted);
- if (MatchedPackOnParmToNonPackOnArg)
- *MatchedPackOnParmToNonPackOnArg |= CTAI.MatchedPackOnParmToNonPackOnArg;
+ if (StrictPackMatch)
+ *StrictPackMatch |= CTAI.StrictPackMatch;
}
// Determine whether P1 is at least as specialized as P2.
@@ -6596,9 +6596,8 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
PartialOrdering ? PackFold::ArgumentToParameter : PackFold::Both,
/*HasDeducedAnyParam=*/nullptr)) {
case clang::TemplateDeductionResult::Success:
- if (MatchedPackOnParmToNonPackOnArg &&
- Info.hasMatchedPackOnParmToNonPackOnArg())
- *MatchedPackOnParmToNonPackOnArg = true;
+ if (StrictPackMatch && Info.hasStrictPackMatch())
+ *StrictPackMatch = true;
break;
case TemplateDeductionResult::MiscellaneousDeductionFailure:
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index dc3bfa97eff399..db97892c06d6dc 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -4059,8 +4059,7 @@ bool Sema::usesPartialOrExplicitSpecialization(
static ActionResult<CXXRecordDecl *> getPatternForClassTemplateSpecialization(
Sema &S, SourceLocation PointOfInstantiation,
ClassTemplateSpecializationDecl *ClassTemplateSpec,
- TemplateSpecializationKind TSK,
- bool PrimaryHasMatchedPackOnParmToNonPackOnArg) {
+ TemplateSpecializationKind TSK, bool PrimaryStrictPackMatch) {
Sema::InstantiatingTemplate Inst(S, PointOfInstantiation, ClassTemplateSpec);
if (Inst.isInvalid())
return {/*Invalid=*/true};
@@ -4113,12 +4112,11 @@ static ActionResult<CXXRecordDecl *> getPatternForClassTemplateSpecialization(
MakeDeductionFailureInfo(S.Context, Result, Info));
(void)Result;
} else {
- auto &List =
- Info.hasMatchedPackOnParmToNonPackOnArg() ? ExtraMatched : Matched;
+ auto &List = Info.hasStrictPackMatch() ? ExtraMatched : Matched;
List.push_back(MatchResult{Partial, Info.takeCanonical()});
}
}
- if (Matched.empty() && PrimaryHasMatchedPackOnParmToNonPackOnArg)
+ if (Matched.empty() && PrimaryStrictPackMatch)
Matched = std::move(ExtraMatched);
// If we're dealing with a member template where the template parameters
@@ -4223,7 +4221,7 @@ bool Sema::InstantiateClassTemplateSpecialization(
SourceLocation PointOfInstantiation,
ClassTemplateSpecializationDecl *ClassTemplateSpec,
TemplateSpecializationKind TSK, bool Complain,
- bool PrimaryHasMatchedPackOnParmToNonPackOnArg) {
+ bool PrimaryStrictPackMatch) {
// Perform the actual instantiation on the canonical declaration.
ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
ClassTemplateSpec->getCanonicalDecl());
@@ -4231,9 +4229,9 @@ bool Sema::InstantiateClassTemplateSpecialization(
return true;
ActionResult<CXXRecordDecl *> Pattern =
- getPatternForClassTemplateSpecialization(
- *this, PointOfInstantiation, ClassTemplateSpec, TSK,
- PrimaryHasMatchedPackOnParmToNonPackOnArg);
+ getPatternForClassTemplateSpecialization(*this, PointOfInstantiation,
+ ClassTemplateSpec, TSK,
+ PrimaryStrictPackMatch);
if (!Pattern.isUsable())
return Pattern.isInvalid();
diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
index 31611695eba7e4..595369661917ce 100644
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -4038,7 +4038,7 @@ TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
ClassTemplateSpecializationDecl::Create(
SemaRef.Context, D->getTagKind(), Owner, D->getBeginLoc(),
D->getLocation(), InstClassTemplate, CTAI.CanonicalConverted,
- CTAI.MatchedPackOnParmToNonPackOnArg, PrevDecl);
+ CTAI.StrictPackMatch, PrevDecl);
InstD->setTemplateArgsAsWritten(InstTemplateArgs);
// Add this partial specialization to the set of class template partial
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 58c72e2ac8935c..6a65facf02a150 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -9397,8 +9397,7 @@ bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
runWithSufficientStackSpace(Loc, [&] {
Diagnosed = InstantiateClassTemplateSpecialization(
Loc, ClassTemplateSpec, TSK_ImplicitInstantiation,
- /*Complain=*/Diagnoser,
- ClassTemplateSpec->hasMatchedPackOnParmToNonPackOnArg());
+ /*Complain=*/Diagnoser, ClassTemplateSpec->hasStrictPackMatch());
});
Instantiated = true;
}
diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp
index 963122160ff4d0..c8c514f5c123c0 100644
--- a/clang/lib/Serialization/ASTReaderDecl.cpp
+++ b/clang/lib/Serialization/ASTReaderDecl.cpp
@@ -2532,7 +2532,7 @@ RedeclarableResult ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
D->PointOfInstantiation = readSourceLocation();
D->SpecializationKind = (TemplateSpecializationKind)Record.readInt();
- D->MatchedPackOnParmToNonPackOnArg = Record.readBool();
+ D->StrictPackMatch = Record.readBool();
bool writtenAsCanonicalDecl = Record.readInt();
if (writtenAsCanonicalDecl) {
diff --git a/clang/lib/Serialization/ASTWriterDecl.cpp b/clang/lib/Serialization/ASTWriterDecl.cpp
index 3505db441e829e..d8ce3c2fb964a7 100644
--- a/clang/lib/Serialization/ASTWriterDecl.cpp
+++ b/clang/lib/Serialization/ASTWriterDecl.cpp
@@ -1843,7 +1843,7 @@ void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
Record.AddTemplateArgumentList(&D->getTemplateArgs());
Record.AddSourceLocation(D->getPointOfInstantiation());
Record.push_back(D->getSpecializationKind());
- Record.push_back(D->hasMatchedPackOnParmToNonPackOnArg());
+ Record.push_back(D->hasStrictPackMatch());
Record.push_back(D->isCanonicalDecl());
if (D->isCanonicalDecl()) {
More information about the llvm-branch-commits
mailing list