[clang] ed7251b - Revert "[clang] Implement TTP P0522 pack matching for deduced function template calls. (#111457)"
Mikhail Goncharov via cfe-commits
cfe-commits at lists.llvm.org
Fri Oct 11 05:47:56 PDT 2024
Author: Mikhail Goncharov
Date: 2024-10-11T14:46:46+02:00
New Revision: ed7251b3aeb7c471dc50e9409e83a9ec01f40df5
URL: https://github.com/llvm/llvm-project/commit/ed7251b3aeb7c471dc50e9409e83a9ec01f40df5
DIFF: https://github.com/llvm/llvm-project/commit/ed7251b3aeb7c471dc50e9409e83a9ec01f40df5.diff
LOG: Revert "[clang] Implement TTP P0522 pack matching for deduced function template calls. (#111457)"
See discussion in https://github.com/llvm/llvm-project/pull/111711
This reverts commit 4dadf42c1a74dd4e37db9ffd6fbb3027f59751a7.
Added:
Modified:
clang/include/clang/Sema/Overload.h
clang/include/clang/Sema/Sema.h
clang/lib/Sema/SemaLookup.cpp
clang/lib/Sema/SemaOverload.cpp
clang/lib/Sema/SemaTemplate.cpp
clang/lib/Sema/SemaTemplateDeduction.cpp
clang/test/SemaTemplate/cwg2398.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/Sema/Overload.h b/clang/include/clang/Sema/Overload.h
index d38278c5041118..c716a25bb673b8 100644
--- a/clang/include/clang/Sema/Overload.h
+++ b/clang/include/clang/Sema/Overload.h
@@ -925,11 +925,6 @@ class Sema;
bool TookAddressOfOverload : 1;
- /// 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;
-
/// True if the candidate was found using ADL.
CallExpr::ADLCallKind IsADLCandidate : 1;
@@ -1004,9 +999,8 @@ class Sema;
friend class OverloadCandidateSet;
OverloadCandidate()
: IsSurrogate(false), IgnoreObjectArgument(false),
- TookAddressOfOverload(false),
- HasMatchedPackOnParmToNonPackOnArg(false),
- IsADLCandidate(CallExpr::NotADL), RewriteKind(CRK_None) {}
+ TookAddressOfOverload(false), IsADLCandidate(CallExpr::NotADL),
+ RewriteKind(CRK_None) {}
};
/// OverloadCandidateSet - A set of overload candidates, used in C++
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index f8118ca64ad3f2..66b0846f286a81 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -10134,8 +10134,7 @@ class Sema final : public SemaBase {
ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
ConversionSequenceList EarlyConversions = std::nullopt,
OverloadCandidateParamOrder PO = {},
- bool AggregateCandidateDeduction = false,
- bool HasMatchedPackOnParmToNonPackOnArg = false);
+ bool AggregateCandidateDeduction = false);
/// Add all of the function declarations in the given function set to
/// the overload candidate set.
@@ -10170,8 +10169,7 @@ class Sema final : public SemaBase {
bool SuppressUserConversions = false,
bool PartialOverloading = false,
ConversionSequenceList EarlyConversions = std::nullopt,
- OverloadCandidateParamOrder PO = {},
- bool HasMatchedPackOnParmToNonPackOnArg = false);
+ OverloadCandidateParamOrder PO = {});
/// Add a C++ member function template as a candidate to the candidate
/// set, using template argument deduction to produce an appropriate member
@@ -10217,8 +10215,7 @@ class Sema final : public SemaBase {
CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
- bool AllowExplicit, bool AllowResultConversion = true,
- bool HasMatchedPackOnParmToNonPackOnArg = false);
+ bool AllowExplicit, bool AllowResultConversion = true);
/// Adds a conversion function template specialization
/// candidate to the overload set, using template argument deduction
@@ -11641,7 +11638,7 @@ class Sema final : public SemaBase {
SourceLocation RAngleLoc, unsigned ArgumentPackIndex,
SmallVectorImpl<TemplateArgument> &SugaredConverted,
SmallVectorImpl<TemplateArgument> &CanonicalConverted,
- CheckTemplateArgumentKind CTAK, bool PartialOrdering,
+ CheckTemplateArgumentKind CTAK,
bool *MatchedPackOnParmToNonPackOnArg);
/// Check that the given template arguments can be provided to
@@ -11724,8 +11721,7 @@ class Sema final : public SemaBase {
/// It returns true if an error occurred, and false otherwise.
bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
TemplateParameterList *Params,
- TemplateArgumentLoc &Arg,
- bool PartialOrdering,
+ TemplateArgumentLoc &Arg, bool IsDeduced,
bool *MatchedPackOnParmToNonPackOnArg);
void NoteTemplateLocation(const NamedDecl &Decl,
@@ -12237,8 +12233,8 @@ class Sema final : public SemaBase {
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,
sema::TemplateDeductionInfo &Info,
- SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs,
- bool PartialOverloading, bool PartialOrdering,
+ SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs = nullptr,
+ bool PartialOverloading = false,
llvm::function_ref<bool()> CheckNonDependent = [] { return false; });
/// Perform template argument deduction from a function call
@@ -12272,8 +12268,7 @@ class Sema final : public SemaBase {
TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info,
bool PartialOverloading, bool AggregateDeductionCandidate,
- bool PartialOrdering, QualType ObjectType,
- Expr::Classification ObjectClassification,
+ QualType ObjectType, Expr::Classification ObjectClassification,
llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent);
/// Deduce template arguments when taking the address of a function
@@ -12428,7 +12423,7 @@ class Sema final : public SemaBase {
bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
TemplateParameterList *PParam, TemplateDecl *PArg, TemplateDecl *AArg,
const DefaultArguments &DefaultArgs, SourceLocation ArgLoc,
- bool PartialOrdering, bool *MatchedPackOnParmToNonPackOnArg);
+ bool IsDeduced, bool *MatchedPackOnParmToNonPackOnArg);
/// Mark which template parameters are used in a given expression.
///
diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp
index 60fa195221c938..31422c213ac249 100644
--- a/clang/lib/Sema/SemaLookup.cpp
+++ b/clang/lib/Sema/SemaLookup.cpp
@@ -3667,7 +3667,6 @@ Sema::LookupLiteralOperator(Scope *S, LookupResult &R,
if (CheckTemplateArgument(
Params->getParam(0), Arg, FD, R.getNameLoc(), R.getNameLoc(),
0, SugaredChecked, CanonicalChecked, CTAK_Specified,
- /*PartialOrdering=*/false,
/*MatchedPackOnParmToNonPackOnArg=*/nullptr) ||
Trap.hasErrorOccurred())
IsTemplate = false;
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index f545e9341e1ae6..2cde8131108fbe 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -6864,8 +6864,7 @@ void Sema::AddOverloadCandidate(
OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
bool PartialOverloading, bool AllowExplicit, bool AllowExplicitConversions,
ADLCallKind IsADLCandidate, ConversionSequenceList EarlyConversions,
- OverloadCandidateParamOrder PO, bool AggregateCandidateDeduction,
- bool HasMatchedPackOnParmToNonPackOnArg) {
+ OverloadCandidateParamOrder PO, bool AggregateCandidateDeduction) {
const FunctionProtoType *Proto
= dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
assert(Proto && "Functions without a prototype cannot be overloaded");
@@ -6884,8 +6883,7 @@ void Sema::AddOverloadCandidate(
AddMethodCandidate(Method, FoundDecl, Method->getParent(), QualType(),
Expr::Classification::makeSimpleLValue(), Args,
CandidateSet, SuppressUserConversions,
- PartialOverloading, EarlyConversions, PO,
- HasMatchedPackOnParmToNonPackOnArg);
+ PartialOverloading, EarlyConversions, PO);
return;
}
// We treat a constructor like a non-member function, since its object
@@ -6928,8 +6926,6 @@ void Sema::AddOverloadCandidate(
CandidateSet.getRewriteInfo().getRewriteKind(Function, PO);
Candidate.IsADLCandidate = IsADLCandidate;
Candidate.ExplicitCallArguments = Args.size();
- Candidate.HasMatchedPackOnParmToNonPackOnArg =
- HasMatchedPackOnParmToNonPackOnArg;
// 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
@@ -7457,13 +7453,16 @@ void Sema::AddMethodCandidate(DeclAccessPair FoundDecl, QualType ObjectType,
}
}
-void Sema::AddMethodCandidate(
- CXXMethodDecl *Method, DeclAccessPair FoundDecl,
- CXXRecordDecl *ActingContext, QualType ObjectType,
- Expr::Classification ObjectClassification, ArrayRef<Expr *> Args,
- OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
- bool PartialOverloading, ConversionSequenceList EarlyConversions,
- OverloadCandidateParamOrder PO, bool HasMatchedPackOnParmToNonPackOnArg) {
+void
+Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
+ CXXRecordDecl *ActingContext, QualType ObjectType,
+ Expr::Classification ObjectClassification,
+ ArrayRef<Expr *> Args,
+ OverloadCandidateSet &CandidateSet,
+ bool SuppressUserConversions,
+ bool PartialOverloading,
+ ConversionSequenceList EarlyConversions,
+ OverloadCandidateParamOrder PO) {
const FunctionProtoType *Proto
= dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
assert(Proto && "Methods without a prototype cannot be overloaded");
@@ -7494,8 +7493,6 @@ void Sema::AddMethodCandidate(
Candidate.TookAddressOfOverload =
CandidateSet.getKind() == OverloadCandidateSet::CSK_AddressOfOverloadSet;
Candidate.ExplicitCallArguments = Args.size();
- Candidate.HasMatchedPackOnParmToNonPackOnArg =
- HasMatchedPackOnParmToNonPackOnArg;
bool IgnoreExplicitObject =
(Method->isExplicitObjectMemberFunction() &&
@@ -7666,8 +7663,8 @@ void Sema::AddMethodTemplateCandidate(
ConversionSequenceList Conversions;
if (TemplateDeductionResult Result = DeduceTemplateArguments(
MethodTmpl, ExplicitTemplateArgs, Args, Specialization, Info,
- PartialOverloading, /*AggregateDeductionCandidate=*/false,
- /*PartialOrdering=*/false, ObjectType, ObjectClassification,
+ PartialOverloading, /*AggregateDeductionCandidate=*/false, ObjectType,
+ ObjectClassification,
[&](ArrayRef<QualType> ParamTypes) {
return CheckNonDependentConversions(
MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
@@ -7705,8 +7702,7 @@ void Sema::AddMethodTemplateCandidate(
AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
ActingContext, ObjectType, ObjectClassification, Args,
CandidateSet, SuppressUserConversions, PartialOverloading,
- Conversions, PO,
- Info.hasMatchedPackOnParmToNonPackOnArg());
+ Conversions, PO);
}
/// Determine whether a given function template has a simple explicit specifier
@@ -7752,7 +7748,6 @@ void Sema::AddTemplateOverloadCandidate(
if (TemplateDeductionResult Result = DeduceTemplateArguments(
FunctionTemplate, ExplicitTemplateArgs, Args, Specialization, Info,
PartialOverloading, AggregateCandidateDeduction,
- /*PartialOrdering=*/false,
/*ObjectType=*/QualType(),
/*ObjectClassification=*/Expr::Classification(),
[&](ArrayRef<QualType> ParamTypes) {
@@ -7793,8 +7788,7 @@ void Sema::AddTemplateOverloadCandidate(
Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
PartialOverloading, AllowExplicit,
/*AllowExplicitConversions=*/false, IsADLCandidate, Conversions, PO,
- Info.AggregateDeductionCandidateHasMismatchedArity,
- Info.hasMatchedPackOnParmToNonPackOnArg());
+ Info.AggregateDeductionCandidateHasMismatchedArity);
}
bool Sema::CheckNonDependentConversions(
@@ -7916,8 +7910,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) {
assert(!Conversion->getDescribedFunctionTemplate() &&
"Conversion function templates use AddTemplateConversionCandidate");
QualType ConvType = Conversion->getConversionType().getNonReferenceType();
@@ -7962,8 +7955,6 @@ void Sema::AddConversionCandidate(
Candidate.FinalConversion.setAllToTypes(ToType);
Candidate.Viable = true;
Candidate.ExplicitCallArguments = 1;
- Candidate.HasMatchedPackOnParmToNonPackOnArg =
- HasMatchedPackOnParmToNonPackOnArg;
// 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
@@ -8165,8 +8156,7 @@ void Sema::AddTemplateConversionCandidate(
assert(Specialization && "Missing function template specialization?");
AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
CandidateSet, AllowObjCConversionOnExplicit,
- AllowExplicit, AllowResultConversion,
- Info.hasMatchedPackOnParmToNonPackOnArg());
+ AllowExplicit, AllowResultConversion);
}
void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
@@ -10519,10 +10509,6 @@ bool clang::isBetterOverloadCandidate(
isa<CXXConstructorDecl>(Cand2.Function))
return isa<CXXConstructorDecl>(Cand1.Function);
- if (Cand1.HasMatchedPackOnParmToNonPackOnArg !=
- Cand2.HasMatchedPackOnParmToNonPackOnArg)
- return Cand2.HasMatchedPackOnParmToNonPackOnArg;
-
// -- F1 is a non-template function and F2 is a function template
// specialization, or, if not that,
bool Cand1IsSpecialization = Cand1.Function &&
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 62d0d0914fa306..4f13669c2490c0 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -5179,8 +5179,7 @@ bool Sema::CheckTemplateArgument(
unsigned ArgumentPackIndex,
SmallVectorImpl<TemplateArgument> &SugaredConverted,
SmallVectorImpl<TemplateArgument> &CanonicalConverted,
- CheckTemplateArgumentKind CTAK, bool PartialOrdering,
- bool *MatchedPackOnParmToNonPackOnArg) {
+ CheckTemplateArgumentKind CTAK, bool *MatchedPackOnParmToNonPackOnArg) {
// Check template type parameters.
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
return CheckTemplateTypeArgument(TTP, Arg, SugaredConverted,
@@ -5395,7 +5394,8 @@ bool Sema::CheckTemplateArgument(
case TemplateArgument::Template:
case TemplateArgument::TemplateExpansion:
- if (CheckTemplateTemplateArgument(TempParm, Params, Arg, PartialOrdering,
+ if (CheckTemplateTemplateArgument(TempParm, Params, Arg,
+ /*IsDeduced=*/CTAK != CTAK_Specified,
MatchedPackOnParmToNonPackOnArg))
return true;
@@ -5546,11 +5546,10 @@ bool Sema::CheckTemplateArgumentList(
if (ArgIdx < NumArgs) {
// Check the template argument we were given.
- if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template, TemplateLoc,
- RAngleLoc, SugaredArgumentPack.size(),
- SugaredConverted, CanonicalConverted,
- CTAK_Specified, /*PartialOrdering=*/false,
- MatchedPackOnParmToNonPackOnArg))
+ if (CheckTemplateArgument(
+ *Param, NewArgs[ArgIdx], Template, TemplateLoc, RAngleLoc,
+ SugaredArgumentPack.size(), SugaredConverted, CanonicalConverted,
+ CTAK_Specified, MatchedPackOnParmToNonPackOnArg))
return true;
CanonicalConverted.back().setIsDefaulted(
@@ -5708,7 +5707,7 @@ bool Sema::CheckTemplateArgumentList(
// Check the default template argument.
if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc, RAngleLoc, 0,
SugaredConverted, CanonicalConverted,
- CTAK_Specified, /*PartialOrdering=*/false,
+ CTAK_Specified,
/*MatchedPackOnParmToNonPackOnArg=*/nullptr))
return true;
@@ -7294,7 +7293,7 @@ static void DiagnoseTemplateParameterListArityMismatch(
bool Sema::CheckTemplateTemplateArgument(
TemplateTemplateParmDecl *Param, TemplateParameterList *Params,
- TemplateArgumentLoc &Arg, bool PartialOrdering,
+ TemplateArgumentLoc &Arg, bool IsDeduced,
bool *MatchedPackOnParmToNonPackOnArg) {
TemplateName Name = Arg.getArgument().getAsTemplateOrTemplatePattern();
auto [Template, DefaultArgs] = Name.getTemplateDeclAndDefaultArgs();
@@ -7339,8 +7338,8 @@ bool Sema::CheckTemplateTemplateArgument(
// A template-argument matches a template template-parameter P when P
// is at least as specialized as the template-argument A.
if (!isTemplateTemplateParameterAtLeastAsSpecializedAs(
- Params, Param, Template, DefaultArgs, Arg.getLocation(),
- PartialOrdering, MatchedPackOnParmToNonPackOnArg))
+ Params, Param, Template, DefaultArgs, Arg.getLocation(), IsDeduced,
+ MatchedPackOnParmToNonPackOnArg))
return true;
// P2113
// C++20[temp.func.order]p2
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index e49d315f7186bc..48a39a90f72a8b 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -2955,7 +2955,7 @@ Sema::getIdentityTemplateArgumentLoc(NamedDecl *TemplateParm,
/// fully-converted template arguments.
static bool ConvertDeducedTemplateArgument(
Sema &S, NamedDecl *Param, DeducedTemplateArgument Arg, NamedDecl *Template,
- TemplateDeductionInfo &Info, bool IsDeduced, bool PartialOrdering,
+ TemplateDeductionInfo &Info, bool IsDeduced,
SmallVectorImpl<TemplateArgument> &SugaredOutput,
SmallVectorImpl<TemplateArgument> &CanonicalOutput) {
auto ConvertArg = [&](DeducedTemplateArgument Arg,
@@ -2976,7 +2976,7 @@ static bool ConvertDeducedTemplateArgument(
? (Arg.wasDeducedFromArrayBound() ? Sema::CTAK_DeducedFromArrayBound
: Sema::CTAK_Deduced)
: Sema::CTAK_Specified,
- PartialOrdering, &MatchedPackOnParmToNonPackOnArg);
+ &MatchedPackOnParmToNonPackOnArg);
if (MatchedPackOnParmToNonPackOnArg)
Info.setMatchedPackOnParmToNonPackOnArg();
return Res;
@@ -3062,9 +3062,9 @@ static TemplateDeductionResult ConvertDeducedTemplateArguments(
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
TemplateDeductionInfo &Info,
SmallVectorImpl<TemplateArgument> &SugaredBuilder,
- SmallVectorImpl<TemplateArgument> &CanonicalBuilder, bool PartialOrdering,
- LocalInstantiationScope *CurrentInstantiationScope,
- unsigned NumAlreadyConverted, bool *IsIncomplete) {
+ SmallVectorImpl<TemplateArgument> &CanonicalBuilder,
+ LocalInstantiationScope *CurrentInstantiationScope = nullptr,
+ unsigned NumAlreadyConverted = 0, bool *IsIncomplete = nullptr) {
TemplateParameterList *TemplateParams = Template->getTemplateParameters();
for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
@@ -3107,8 +3107,8 @@ static TemplateDeductionResult ConvertDeducedTemplateArguments(
// We may have deduced this argument, so it still needs to be
// checked and converted.
if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Template, Info,
- IsDeduced, PartialOrdering,
- SugaredBuilder, CanonicalBuilder)) {
+ IsDeduced, SugaredBuilder,
+ CanonicalBuilder)) {
Info.Param = makeTemplateParameter(Param);
// FIXME: These template arguments are temporary. Free them!
Info.reset(
@@ -3174,8 +3174,7 @@ static TemplateDeductionResult ConvertDeducedTemplateArguments(
// Check whether we can actually use the default argument.
if (S.CheckTemplateArgument(
Param, DefArg, TD, TD->getLocation(), TD->getSourceRange().getEnd(),
- /*ArgumentPackIndex=*/0, SugaredBuilder, CanonicalBuilder,
- Sema::CTAK_Specified, /*PartialOrdering=*/false,
+ 0, SugaredBuilder, CanonicalBuilder, Sema::CTAK_Specified,
/*MatchedPackOnParmToNonPackOnArg=*/nullptr)) {
Info.Param = makeTemplateParameter(
const_cast<NamedDecl *>(TemplateParams->getParam(I)));
@@ -3284,9 +3283,7 @@ FinishTemplateArgumentDeduction(
SmallVector<TemplateArgument, 4> SugaredBuilder, CanonicalBuilder;
if (auto Result = ConvertDeducedTemplateArguments(
S, Partial, IsPartialOrdering, Deduced, Info, SugaredBuilder,
- CanonicalBuilder, IsPartialOrdering,
- /*CurrentInstantiationScope=*/nullptr, /*NumAlreadyConverted=*/0,
- /*IsIncomplete=*/nullptr);
+ CanonicalBuilder);
Result != TemplateDeductionResult::Success)
return Result;
@@ -3386,10 +3383,10 @@ static TemplateDeductionResult FinishTemplateArgumentDeduction(
// explicitly specified, template argument deduction fails.
SmallVector<TemplateArgument, 4> SugaredBuilder, CanonicalBuilder;
if (auto Result = ConvertDeducedTemplateArguments(
- S, Template, /*IsDeduced=*/PartialOrdering, Deduced, Info,
- SugaredBuilder, CanonicalBuilder, PartialOrdering,
+ S, Template, /*IsDeduced*/ PartialOrdering, Deduced, Info,
+ SugaredBuilder, CanonicalBuilder,
/*CurrentInstantiationScope=*/nullptr,
- /*NumAlreadyConverted=*/0U, /*IsIncomplete=*/nullptr);
+ /*NumAlreadyConverted=*/0U);
Result != TemplateDeductionResult::Success)
return Result;
@@ -3454,9 +3451,7 @@ static TemplateDeductionResult FinishTemplateArgumentDeduction(
SmallVector<TemplateArgument, 4> SugaredBuilder, CanonicalBuilder;
if (auto Result = ConvertDeducedTemplateArguments(
S, TD, /*IsDeduced=*/false, Deduced, Info, SugaredBuilder,
- CanonicalBuilder, /*PartialOrdering=*/false,
- /*CurrentInstantiationScope=*/nullptr, /*NumAlreadyConverted=*/0,
- /*IsIncomplete=*/nullptr);
+ CanonicalBuilder);
Result != TemplateDeductionResult::Success)
return Result;
@@ -3994,8 +3989,7 @@ TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(
unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,
TemplateDeductionInfo &Info,
SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs,
- bool PartialOverloading, bool PartialOrdering,
- llvm::function_ref<bool()> CheckNonDependent) {
+ bool PartialOverloading, llvm::function_ref<bool()> CheckNonDependent) {
// Unevaluated SFINAE context.
EnterExpressionEvaluationContext Unevaluated(
*this, Sema::ExpressionEvaluationContext::Unevaluated);
@@ -4018,10 +4012,9 @@ TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(
bool IsIncomplete = false;
SmallVector<TemplateArgument, 4> SugaredBuilder, CanonicalBuilder;
if (auto Result = ConvertDeducedTemplateArguments(
- *this, FunctionTemplate, /*IsDeduced=*/true, Deduced, Info,
- SugaredBuilder, CanonicalBuilder, PartialOrdering,
- CurrentInstantiationScope, NumExplicitlySpecified,
- PartialOverloading ? &IsIncomplete : nullptr);
+ *this, FunctionTemplate, /*IsDeduced*/ true, Deduced, Info,
+ SugaredBuilder, CanonicalBuilder, CurrentInstantiationScope,
+ NumExplicitlySpecified, PartialOverloading ? &IsIncomplete : nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -4553,8 +4546,7 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
FunctionDecl *&Specialization, TemplateDeductionInfo &Info,
bool PartialOverloading, bool AggregateDeductionCandidate,
- bool PartialOrdering, QualType ObjectType,
- Expr::Classification ObjectClassification,
+ QualType ObjectType, Expr::Classification ObjectClassification,
llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent) {
if (FunctionTemplate->isInvalidDecl())
return TemplateDeductionResult::Invalid;
@@ -4769,8 +4761,7 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
runWithSufficientStackSpace(Info.getLocation(), [&] {
Result = FinishTemplateArgumentDeduction(
FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info,
- &OriginalCallArgs, PartialOverloading, PartialOrdering,
- [&, CallingCtx]() {
+ &OriginalCallArgs, PartialOverloading, [&, CallingCtx]() {
ContextRAII SavedContext(*this, CallingCtx);
return CheckNonDependent(ParamTypesForArgChecking);
});
@@ -4882,10 +4873,9 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
TemplateDeductionResult Result;
runWithSufficientStackSpace(Info.getLocation(), [&] {
- Result = FinishTemplateArgumentDeduction(
- FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info,
- /*OriginalCallArgs=*/nullptr, /*PartialOverloading=*/false,
- /*PartialOrdering=*/true);
+ Result = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
+ NumExplicitlySpecified,
+ Specialization, Info);
});
if (Result != TemplateDeductionResult::Success)
return Result;
@@ -5065,10 +5055,9 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
FunctionDecl *ConversionSpecialized = nullptr;
TemplateDeductionResult Result;
runWithSufficientStackSpace(Info.getLocation(), [&] {
- Result = FinishTemplateArgumentDeduction(
- ConversionTemplate, Deduced, 0, ConversionSpecialized, Info,
- &OriginalCallArgs, /*PartialOverloading=*/false,
- /*PartialOrdering=*/false);
+ Result = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0,
+ ConversionSpecialized, Info,
+ &OriginalCallArgs);
});
Specialization = cast_or_null<CXXConversionDecl>(ConversionSpecialized);
return Result;
@@ -5645,8 +5634,7 @@ static TemplateDeductionResult FinishTemplateArgumentDeduction(
SmallVector<TemplateArgument, 4> SugaredBuilder, CanonicalBuilder;
if (auto Result = ConvertDeducedTemplateArguments(
S, FTD, /*IsDeduced=*/true, Deduced, Info, SugaredBuilder,
- CanonicalBuilder, /*PartialOrdering=*/true,
- /*CurrentInstantiationScope=*/nullptr,
+ CanonicalBuilder, /*CurrentInstantiationScope=*/nullptr,
/*NumAlreadyConverted=*/0, &IsIncomplete);
Result != TemplateDeductionResult::Success)
return Result;
@@ -6491,8 +6479,8 @@ bool Sema::isMoreSpecializedThanPrimary(
bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
TemplateParameterList *P, TemplateDecl *PArg, TemplateDecl *AArg,
- const DefaultArguments &DefaultArgs, SourceLocation ArgLoc,
- bool PartialOrdering, bool *MatchedPackOnParmToNonPackOnArg) {
+ const DefaultArguments &DefaultArgs, SourceLocation ArgLoc, bool IsDeduced,
+ bool *MatchedPackOnParmToNonPackOnArg) {
// 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
@@ -6571,7 +6559,7 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
switch (::DeduceTemplateArguments(
*this, A, AArgs, PArgs, Info, Deduced,
/*NumberOfArgumentsMustMatch=*/false, /*PartialOrdering=*/true,
- PartialOrdering ? PackFold::ArgumentToParameter : PackFold::Both,
+ IsDeduced ? PackFold::ArgumentToParameter : PackFold::Both,
/*HasDeducedAnyParam=*/nullptr)) {
case clang::TemplateDeductionResult::Success:
if (MatchedPackOnParmToNonPackOnArg &&
diff --git a/clang/test/SemaTemplate/cwg2398.cpp b/clang/test/SemaTemplate/cwg2398.cpp
index 3825239de4a285..56091e84cf4e95 100644
--- a/clang/test/SemaTemplate/cwg2398.cpp
+++ b/clang/test/SemaTemplate/cwg2398.cpp
@@ -405,87 +405,6 @@ namespace packs {
} // namespace t4
} // namespace packs
-namespace fun_tmpl_call {
- namespace match_func {
- template <template <class> class TT> void f(TT<int>) {};
- // old-note at -1 {{has
diff erent template parameters}}
- template <class...> struct A {};
- void test() { f(A<int>()); }
- // old-error at -1 {{no matching function for call to 'f'}}
- } // namespace match_func
- namespace order_func_nonpack {
- template <template <class> class TT> void f(TT<int>) {}
- template <template <class...> class TT> void f(TT<int>) = delete;
-
- template <class> struct A {};
- void test() { f(A<int>()); }
- } // namespace order_func_nonpack
- namespace order_func_pack {
- template <template <class> class TT> void f(TT<int>) = delete;
- template <template <class...> class TT> void f(TT<int>) {}
-
- template <class...> struct A {};
- void test() { f(A<int>()); }
- } // namespace order_func_pack
- namespace match_method {
- struct A {
- template <template <class> class TT> void f(TT<int>) {};
- // old-note at -1 {{has
diff erent template parameters}}
- };
- template <class...> struct B {};
- void test() { A().f(B<int>()); }
- // old-error at -1 {{no matching member function for call to 'f'}}
- } // namespace t2
- namespace order_method_nonpack {
- struct A {
- template <template <class> class TT> void f(TT<int>) {}
- template <template <class...> class TT> void f(TT<int>) = delete;
- };
- template <class> struct B {};
- void test() { A().f(B<int>()); }
- } // namespace order_method_nonpack
- namespace order_method_pack {
- struct A {
- template <template <class> class TT> void f(TT<int>) = delete;
- template <template <class...> class TT> void f(TT<int>) {}
- };
- template <class...> struct B {};
- void test() { A().f(B<int>()); }
- } // namespace order_method_pack
- namespace match_conv {
- struct A {
- template <template <class> class TT> operator TT<int>() { return {}; }
- // old-note at -1 {{
diff erent template parameters}}
- };
- template <class...> struct B {};
- // old-note at -1 2{{not viable}}
- void test() { B<int> b = A(); }
- // old-error at -1 {{no viable conversion from 'A' to 'B<int>'}}
- } // namespace match_conv
- namespace order_conv_nonpack {
- struct A {
- template <template <class> class TT> operator TT<int>() { return {}; };
- template <template <class...> class TT> operator TT<int>() = delete;
- };
- template <class> struct B {};
- void test() { B<int> b = A(); }
- } // namespace order_conv_nonpack
- namespace order_conv_pack {
- struct A {
- template <template <class> class TT> operator TT<int>() = delete;
- template <template <class...> class TT> operator TT<int>() { return {}; }
- };
- template <class...> struct B {};
- void test() { B<int> b = A(); }
- } // namespace order_conv_pack
- namespace regression1 {
- template <template <class, class...> class TT, class T1, class... T2s>
- void f(TT<T1, T2s...>) {}
- template <class> struct A {};
- void test() { f(A<int>()); }
- } // namespace regression1
-} // namespace fun_tmpl_packs
-
namespace partial {
namespace t1 {
template<template<class... T1s> class TT1> struct A {};
More information about the cfe-commits
mailing list