Skip to content

Commit ed7251b

Browse files
metaflowmetaflow
committed
Revert "[clang] Implement TTP P0522 pack matching for deduced function template calls. (#111457)"
See discussion in #111711 This reverts commit 4dadf42.
1 parent c8da225 commit ed7251b

File tree

7 files changed

+69
-189
lines changed

7 files changed

+69
-189
lines changed

‎clang/include/clang/Sema/Overload.h

Lines changed: 2 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -925,11 +925,6 @@ class Sema;
925925

926926
bool TookAddressOfOverload : 1;
927927

928-
/// Have we matched any packs on the parameter side, versus any non-packs on
929-
/// the argument side, in a context where the opposite matching is also
930-
/// allowed?
931-
bool HasMatchedPackOnParmToNonPackOnArg : 1;
932-
933928
/// True if the candidate was found using ADL.
934929
CallExpr::ADLCallKind IsADLCandidate : 1;
935930

@@ -1004,9 +999,8 @@ class Sema;
1004999
friend class OverloadCandidateSet;
10051000
OverloadCandidate()
10061001
: IsSurrogate(false), IgnoreObjectArgument(false),
1007-
TookAddressOfOverload(false),
1008-
HasMatchedPackOnParmToNonPackOnArg(false),
1009-
IsADLCandidate(CallExpr::NotADL), RewriteKind(CRK_None) {}
1002+
TookAddressOfOverload(false), IsADLCandidate(CallExpr::NotADL),
1003+
RewriteKind(CRK_None) {}
10101004
};
10111005

10121006
/// OverloadCandidateSet - A set of overload candidates, used in C++

‎clang/include/clang/Sema/Sema.h

Lines changed: 9 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -10134,8 +10134,7 @@ class Sema final : public SemaBase {
1013410134
ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
1013510135
ConversionSequenceList EarlyConversions = std::nullopt,
1013610136
OverloadCandidateParamOrder PO = {},
10137-
bool AggregateCandidateDeduction = false,
10138-
bool HasMatchedPackOnParmToNonPackOnArg = false);
10137+
bool AggregateCandidateDeduction = false);
1013910138

1014010139
/// Add all of the function declarations in the given function set to
1014110140
/// the overload candidate set.
@@ -10170,8 +10169,7 @@ class Sema final : public SemaBase {
1017010169
bool SuppressUserConversions = false,
1017110170
bool PartialOverloading = false,
1017210171
ConversionSequenceList EarlyConversions = std::nullopt,
10173-
OverloadCandidateParamOrder PO = {},
10174-
bool HasMatchedPackOnParmToNonPackOnArg = false);
10172+
OverloadCandidateParamOrder PO = {});
1017510173

1017610174
/// Add a C++ member function template as a candidate to the candidate
1017710175
/// set, using template argument deduction to produce an appropriate member
@@ -10217,8 +10215,7 @@ class Sema final : public SemaBase {
1021710215
CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
1021810216
CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
1021910217
OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
10220-
bool AllowExplicit, bool AllowResultConversion = true,
10221-
bool HasMatchedPackOnParmToNonPackOnArg = false);
10218+
bool AllowExplicit, bool AllowResultConversion = true);
1022210219

1022310220
/// Adds a conversion function template specialization
1022410221
/// candidate to the overload set, using template argument deduction
@@ -11641,7 +11638,7 @@ class Sema final : public SemaBase {
1164111638
SourceLocation RAngleLoc, unsigned ArgumentPackIndex,
1164211639
SmallVectorImpl<TemplateArgument> &SugaredConverted,
1164311640
SmallVectorImpl<TemplateArgument> &CanonicalConverted,
11644-
CheckTemplateArgumentKind CTAK, bool PartialOrdering,
11641+
CheckTemplateArgumentKind CTAK,
1164511642
bool *MatchedPackOnParmToNonPackOnArg);
1164611643

1164711644
/// Check that the given template arguments can be provided to
@@ -11724,8 +11721,7 @@ class Sema final : public SemaBase {
1172411721
/// It returns true if an error occurred, and false otherwise.
1172511722
bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
1172611723
TemplateParameterList *Params,
11727-
TemplateArgumentLoc &Arg,
11728-
bool PartialOrdering,
11724+
TemplateArgumentLoc &Arg, bool IsDeduced,
1172911725
bool *MatchedPackOnParmToNonPackOnArg);
1173011726

1173111727
void NoteTemplateLocation(const NamedDecl &Decl,
@@ -12237,8 +12233,8 @@ class Sema final : public SemaBase {
1223712233
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
1223812234
unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,
1223912235
sema::TemplateDeductionInfo &Info,
12240-
SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs,
12241-
bool PartialOverloading, bool PartialOrdering,
12236+
SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs = nullptr,
12237+
bool PartialOverloading = false,
1224212238
llvm::function_ref<bool()> CheckNonDependent = [] { return false; });
1224312239

1224412240
/// Perform template argument deduction from a function call
@@ -12272,8 +12268,7 @@ class Sema final : public SemaBase {
1227212268
TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
1227312269
FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info,
1227412270
bool PartialOverloading, bool AggregateDeductionCandidate,
12275-
bool PartialOrdering, QualType ObjectType,
12276-
Expr::Classification ObjectClassification,
12271+
QualType ObjectType, Expr::Classification ObjectClassification,
1227712272
llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent);
1227812273

1227912274
/// Deduce template arguments when taking the address of a function
@@ -12428,7 +12423,7 @@ class Sema final : public SemaBase {
1242812423
bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
1242912424
TemplateParameterList *PParam, TemplateDecl *PArg, TemplateDecl *AArg,
1243012425
const DefaultArguments &DefaultArgs, SourceLocation ArgLoc,
12431-
bool PartialOrdering, bool *MatchedPackOnParmToNonPackOnArg);
12426+
bool IsDeduced, bool *MatchedPackOnParmToNonPackOnArg);
1243212427

1243312428
/// Mark which template parameters are used in a given expression.
1243412429
///

‎clang/lib/Sema/SemaLookup.cpp

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3667,7 +3667,6 @@ Sema::LookupLiteralOperator(Scope *S, LookupResult &R,
36673667
if (CheckTemplateArgument(
36683668
Params->getParam(0), Arg, FD, R.getNameLoc(), R.getNameLoc(),
36693669
0, SugaredChecked, CanonicalChecked, CTAK_Specified,
3670-
/*PartialOrdering=*/false,
36713670
/*MatchedPackOnParmToNonPackOnArg=*/nullptr) ||
36723671
Trap.hasErrorOccurred())
36733672
IsTemplate = false;

‎clang/lib/Sema/SemaOverload.cpp

Lines changed: 18 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -6864,8 +6864,7 @@ void Sema::AddOverloadCandidate(
68646864
OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
68656865
bool PartialOverloading, bool AllowExplicit, bool AllowExplicitConversions,
68666866
ADLCallKind IsADLCandidate, ConversionSequenceList EarlyConversions,
6867-
OverloadCandidateParamOrder PO, bool AggregateCandidateDeduction,
6868-
bool HasMatchedPackOnParmToNonPackOnArg) {
6867+
OverloadCandidateParamOrder PO, bool AggregateCandidateDeduction) {
68696868
const FunctionProtoType *Proto
68706869
= dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
68716870
assert(Proto && "Functions without a prototype cannot be overloaded");
@@ -6884,8 +6883,7 @@ void Sema::AddOverloadCandidate(
68846883
AddMethodCandidate(Method, FoundDecl, Method->getParent(), QualType(),
68856884
Expr::Classification::makeSimpleLValue(), Args,
68866885
CandidateSet, SuppressUserConversions,
6887-
PartialOverloading, EarlyConversions, PO,
6888-
HasMatchedPackOnParmToNonPackOnArg);
6886+
PartialOverloading, EarlyConversions, PO);
68896887
return;
68906888
}
68916889
// We treat a constructor like a non-member function, since its object
@@ -6928,8 +6926,6 @@ void Sema::AddOverloadCandidate(
69286926
CandidateSet.getRewriteInfo().getRewriteKind(Function, PO);
69296927
Candidate.IsADLCandidate = IsADLCandidate;
69306928
Candidate.ExplicitCallArguments = Args.size();
6931-
Candidate.HasMatchedPackOnParmToNonPackOnArg =
6932-
HasMatchedPackOnParmToNonPackOnArg;
69336929

69346930
// Explicit functions are not actually candidates at all if we're not
69356931
// allowing them in this context, but keep them around so we can point
@@ -7457,13 +7453,16 @@ void Sema::AddMethodCandidate(DeclAccessPair FoundDecl, QualType ObjectType,
74577453
}
74587454
}
74597455

7460-
void Sema::AddMethodCandidate(
7461-
CXXMethodDecl *Method, DeclAccessPair FoundDecl,
7462-
CXXRecordDecl *ActingContext, QualType ObjectType,
7463-
Expr::Classification ObjectClassification, ArrayRef<Expr *> Args,
7464-
OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
7465-
bool PartialOverloading, ConversionSequenceList EarlyConversions,
7466-
OverloadCandidateParamOrder PO, bool HasMatchedPackOnParmToNonPackOnArg) {
7456+
void
7457+
Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
7458+
CXXRecordDecl *ActingContext, QualType ObjectType,
7459+
Expr::Classification ObjectClassification,
7460+
ArrayRef<Expr *> Args,
7461+
OverloadCandidateSet &CandidateSet,
7462+
bool SuppressUserConversions,
7463+
bool PartialOverloading,
7464+
ConversionSequenceList EarlyConversions,
7465+
OverloadCandidateParamOrder PO) {
74677466
const FunctionProtoType *Proto
74687467
= dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
74697468
assert(Proto && "Methods without a prototype cannot be overloaded");
@@ -7494,8 +7493,6 @@ void Sema::AddMethodCandidate(
74947493
Candidate.TookAddressOfOverload =
74957494
CandidateSet.getKind() == OverloadCandidateSet::CSK_AddressOfOverloadSet;
74967495
Candidate.ExplicitCallArguments = Args.size();
7497-
Candidate.HasMatchedPackOnParmToNonPackOnArg =
7498-
HasMatchedPackOnParmToNonPackOnArg;
74997496

75007497
bool IgnoreExplicitObject =
75017498
(Method->isExplicitObjectMemberFunction() &&
@@ -7666,8 +7663,8 @@ void Sema::AddMethodTemplateCandidate(
76667663
ConversionSequenceList Conversions;
76677664
if (TemplateDeductionResult Result = DeduceTemplateArguments(
76687665
MethodTmpl, ExplicitTemplateArgs, Args, Specialization, Info,
7669-
PartialOverloading, /*AggregateDeductionCandidate=*/false,
7670-
/*PartialOrdering=*/false, ObjectType, ObjectClassification,
7666+
PartialOverloading, /*AggregateDeductionCandidate=*/false, ObjectType,
7667+
ObjectClassification,
76717668
[&](ArrayRef<QualType> ParamTypes) {
76727669
return CheckNonDependentConversions(
76737670
MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
@@ -7705,8 +7702,7 @@ void Sema::AddMethodTemplateCandidate(
77057702
AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
77067703
ActingContext, ObjectType, ObjectClassification, Args,
77077704
CandidateSet, SuppressUserConversions, PartialOverloading,
7708-
Conversions, PO,
7709-
Info.hasMatchedPackOnParmToNonPackOnArg());
7705+
Conversions, PO);
77107706
}
77117707

77127708
/// Determine whether a given function template has a simple explicit specifier
@@ -7752,7 +7748,6 @@ void Sema::AddTemplateOverloadCandidate(
77527748
if (TemplateDeductionResult Result = DeduceTemplateArguments(
77537749
FunctionTemplate, ExplicitTemplateArgs, Args, Specialization, Info,
77547750
PartialOverloading, AggregateCandidateDeduction,
7755-
/*PartialOrdering=*/false,
77567751
/*ObjectType=*/QualType(),
77577752
/*ObjectClassification=*/Expr::Classification(),
77587753
[&](ArrayRef<QualType> ParamTypes) {
@@ -7793,8 +7788,7 @@ void Sema::AddTemplateOverloadCandidate(
77937788
Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
77947789
PartialOverloading, AllowExplicit,
77957790
/*AllowExplicitConversions=*/false, IsADLCandidate, Conversions, PO,
7796-
Info.AggregateDeductionCandidateHasMismatchedArity,
7797-
Info.hasMatchedPackOnParmToNonPackOnArg());
7791+
Info.AggregateDeductionCandidateHasMismatchedArity);
77987792
}
77997793

78007794
bool Sema::CheckNonDependentConversions(
@@ -7916,8 +7910,7 @@ void Sema::AddConversionCandidate(
79167910
CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
79177911
CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
79187912
OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
7919-
bool AllowExplicit, bool AllowResultConversion,
7920-
bool HasMatchedPackOnParmToNonPackOnArg) {
7913+
bool AllowExplicit, bool AllowResultConversion) {
79217914
assert(!Conversion->getDescribedFunctionTemplate() &&
79227915
"Conversion function templates use AddTemplateConversionCandidate");
79237916
QualType ConvType = Conversion->getConversionType().getNonReferenceType();
@@ -7962,8 +7955,6 @@ void Sema::AddConversionCandidate(
79627955
Candidate.FinalConversion.setAllToTypes(ToType);
79637956
Candidate.Viable = true;
79647957
Candidate.ExplicitCallArguments = 1;
7965-
Candidate.HasMatchedPackOnParmToNonPackOnArg =
7966-
HasMatchedPackOnParmToNonPackOnArg;
79677958

79687959
// Explicit functions are not actually candidates at all if we're not
79697960
// allowing them in this context, but keep them around so we can point
@@ -8165,8 +8156,7 @@ void Sema::AddTemplateConversionCandidate(
81658156
assert(Specialization && "Missing function template specialization?");
81668157
AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
81678158
CandidateSet, AllowObjCConversionOnExplicit,
8168-
AllowExplicit, AllowResultConversion,
8169-
Info.hasMatchedPackOnParmToNonPackOnArg());
8159+
AllowExplicit, AllowResultConversion);
81708160
}
81718161

81728162
void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
@@ -10519,10 +10509,6 @@ bool clang::isBetterOverloadCandidate(
1051910509
isa<CXXConstructorDecl>(Cand2.Function))
1052010510
return isa<CXXConstructorDecl>(Cand1.Function);
1052110511

10522-
if (Cand1.HasMatchedPackOnParmToNonPackOnArg !=
10523-
Cand2.HasMatchedPackOnParmToNonPackOnArg)
10524-
return Cand2.HasMatchedPackOnParmToNonPackOnArg;
10525-
1052610512
// -- F1 is a non-template function and F2 is a function template
1052710513
// specialization, or, if not that,
1052810514
bool Cand1IsSpecialization = Cand1.Function &&

‎clang/lib/Sema/SemaTemplate.cpp

Lines changed: 11 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -5179,8 +5179,7 @@ bool Sema::CheckTemplateArgument(
51795179
unsigned ArgumentPackIndex,
51805180
SmallVectorImpl<TemplateArgument> &SugaredConverted,
51815181
SmallVectorImpl<TemplateArgument> &CanonicalConverted,
5182-
CheckTemplateArgumentKind CTAK, bool PartialOrdering,
5183-
bool *MatchedPackOnParmToNonPackOnArg) {
5182+
CheckTemplateArgumentKind CTAK, bool *MatchedPackOnParmToNonPackOnArg) {
51845183
// Check template type parameters.
51855184
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
51865185
return CheckTemplateTypeArgument(TTP, Arg, SugaredConverted,
@@ -5395,7 +5394,8 @@ bool Sema::CheckTemplateArgument(
53955394

53965395
case TemplateArgument::Template:
53975396
case TemplateArgument::TemplateExpansion:
5398-
if (CheckTemplateTemplateArgument(TempParm, Params, Arg, PartialOrdering,
5397+
if (CheckTemplateTemplateArgument(TempParm, Params, Arg,
5398+
/*IsDeduced=*/CTAK != CTAK_Specified,
53995399
MatchedPackOnParmToNonPackOnArg))
54005400
return true;
54015401

@@ -5546,11 +5546,10 @@ bool Sema::CheckTemplateArgumentList(
55465546

55475547
if (ArgIdx < NumArgs) {
55485548
// Check the template argument we were given.
5549-
if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template, TemplateLoc,
5550-
RAngleLoc, SugaredArgumentPack.size(),
5551-
SugaredConverted, CanonicalConverted,
5552-
CTAK_Specified, /*PartialOrdering=*/false,
5553-
MatchedPackOnParmToNonPackOnArg))
5549+
if (CheckTemplateArgument(
5550+
*Param, NewArgs[ArgIdx], Template, TemplateLoc, RAngleLoc,
5551+
SugaredArgumentPack.size(), SugaredConverted, CanonicalConverted,
5552+
CTAK_Specified, MatchedPackOnParmToNonPackOnArg))
55545553
return true;
55555554

55565555
CanonicalConverted.back().setIsDefaulted(
@@ -5708,7 +5707,7 @@ bool Sema::CheckTemplateArgumentList(
57085707
// Check the default template argument.
57095708
if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc, RAngleLoc, 0,
57105709
SugaredConverted, CanonicalConverted,
5711-
CTAK_Specified, /*PartialOrdering=*/false,
5710+
CTAK_Specified,
57125711
/*MatchedPackOnParmToNonPackOnArg=*/nullptr))
57135712
return true;
57145713

@@ -7294,7 +7293,7 @@ static void DiagnoseTemplateParameterListArityMismatch(
72947293

72957294
bool Sema::CheckTemplateTemplateArgument(
72967295
TemplateTemplateParmDecl *Param, TemplateParameterList *Params,
7297-
TemplateArgumentLoc &Arg, bool PartialOrdering,
7296+
TemplateArgumentLoc &Arg, bool IsDeduced,
72987297
bool *MatchedPackOnParmToNonPackOnArg) {
72997298
TemplateName Name = Arg.getArgument().getAsTemplateOrTemplatePattern();
73007299
auto [Template, DefaultArgs] = Name.getTemplateDeclAndDefaultArgs();
@@ -7339,8 +7338,8 @@ bool Sema::CheckTemplateTemplateArgument(
73397338
// A template-argument matches a template template-parameter P when P
73407339
// is at least as specialized as the template-argument A.
73417340
if (!isTemplateTemplateParameterAtLeastAsSpecializedAs(
7342-
Params, Param, Template, DefaultArgs, Arg.getLocation(),
7343-
PartialOrdering, MatchedPackOnParmToNonPackOnArg))
7341+
Params, Param, Template, DefaultArgs, Arg.getLocation(), IsDeduced,
7342+
MatchedPackOnParmToNonPackOnArg))
73447343
return true;
73457344
// P2113
73467345
// C++20[temp.func.order]p2

0 commit comments

Comments
 (0)