https://github.com/mizvekov updated
https://github.com/llvm/llvm-project/pull/100692
>From 1aa99ba557fd563dc55c9cd4c6d8ce7f05b3bd6d Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizve...@gmail.com>
Date: Wed, 24 Jul 2024 03:59:41 -0300
Subject: [PATCH] [clang] check deduction consistency when partial ordering
function templates
This makes partial ordering of function templates consistent with
other entities.
Fixes #18291
---
clang/docs/ReleaseNotes.rst | 2 +
clang/lib/AST/ExprConstant.cpp | 1 -
clang/lib/Sema/SemaTemplateDeduction.cpp | 814 ++++++++++++------
.../test/CodeCompletion/variadic-template.cpp | 2 +-
clang/test/SemaTemplate/GH18291.cpp | 16 +
clang/test/SemaTemplate/cwg2398.cpp | 14 +
clang/test/SemaTemplate/temp_arg_nontype.cpp | 14 +-
clang/test/SemaTemplate/temp_arg_type.cpp | 7 +-
.../Templight/templight-empty-entries-fix.cpp | 140 ++-
9 files changed, 712 insertions(+), 298 deletions(-)
create mode 100644 clang/test/SemaTemplate/GH18291.cpp
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 5dddd8f1c5af5..6098101a73a62 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -153,6 +153,8 @@ Bug Fixes to C++ Support
- Fixed a crash when an expression with a dependent ``__typeof__`` type is
used as the operand of a unary operator. (#GH97646)
- Fixed a failed assertion when checking invalid delete operator declaration.
(#GH96191)
+- When performing partial ordering of function templates, clang now checks that
+ the deduction was consistent. Fixes (#GH18291).
Bug Fixes to AST Handling
^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
index 558e20ed3e423..2512cd575fbdd 100644
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/lib/AST/ExprConstant.cpp
@@ -5346,7 +5346,6 @@ static EvalStmtResult EvaluateStmt(StmtResult &Result,
EvalInfo &Info,
const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue();
FullExpressionRAII Scope(Info);
if (RetExpr && RetExpr->isValueDependent()) {
- EvaluateDependentExpr(RetExpr, Info);
// We know we returned, but we don't know what the value is.
return ESR_Failed;
}
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp
b/clang/lib/Sema/SemaTemplateDeduction.cpp
index b7b857ebf804b..de700ae5cc4b4 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -137,7 +137,7 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
Sema &S, TemplateParameterList *TemplateParams, QualType Param,
QualType Arg, TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
- bool PartialOrdering = false, bool DeducedFromArrayBound = false);
+ bool PartialOrdering, bool DeducedFromArrayBound, bool
*HasDeducedAnyParam);
enum class PackFold { ParameterToArgument, ArgumentToParameter };
static TemplateDeductionResult
@@ -146,8 +146,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList
*TemplateParams,
ArrayRef<TemplateArgument> As,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
- bool NumberOfArgumentsMustMatch,
- PackFold PackFold = PackFold::ParameterToArgument);
+ bool NumberOfArgumentsMustMatch, PackFold PackFold,
+ bool *HasDeducedAnyParam);
static void MarkUsedTemplateParameters(ASTContext &Ctx,
const TemplateArgument &TemplateArg,
@@ -395,12 +395,13 @@ checkDeducedTemplateArguments(ASTContext &Context,
/// Deduce the value of the given non-type template parameter
/// as the given deduced template argument. All non-type template parameter
/// deduction is funneled through here.
-static TemplateDeductionResult DeduceNonTypeTemplateArgument(
- Sema &S, TemplateParameterList *TemplateParams,
- const NonTypeTemplateParmDecl *NTTP,
- const DeducedTemplateArgument &NewDeduced, QualType ValueType,
- TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+static TemplateDeductionResult
+DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
+ const NonTypeTemplateParmDecl *NTTP,
+ const DeducedTemplateArgument &NewDeduced,
+ QualType ValueType, TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument>
&Deduced,
+ bool *HasDeducedAnyParam) {
assert(NTTP->getDepth() == Info.getDeducedDepth() &&
"deducing non-type template argument with wrong depth");
@@ -444,7 +445,7 @@ static TemplateDeductionResult
DeduceNonTypeTemplateArgument(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, ParamType, ValueType, Info, Deduced,
TDF_SkipNonDependent, /*PartialOrdering=*/false,
- /*ArrayBound=*/NewDeduced.wasDeducedFromArrayBound());
+ /*ArrayBound=*/NewDeduced.wasDeducedFromArrayBound(),
HasDeducedAnyParam);
}
/// Deduce the value of the given non-type template parameter
@@ -453,21 +454,23 @@ static TemplateDeductionResult
DeduceNonTypeTemplateArgument(
Sema &S, TemplateParameterList *TemplateParams,
const NonTypeTemplateParmDecl *NTTP, const llvm::APSInt &Value,
QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo
&Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP,
DeducedTemplateArgument(S.Context, Value, ValueType,
DeducedFromArrayBound),
- ValueType, Info, Deduced);
+ ValueType, Info, Deduced, HasDeducedAnyParam);
}
/// Deduce the value of the given non-type template parameter
/// from the given null pointer template argument type.
-static TemplateDeductionResult DeduceNullPtrTemplateArgument(
- Sema &S, TemplateParameterList *TemplateParams,
- const NonTypeTemplateParmDecl *NTTP, QualType NullPtrType,
- TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+static TemplateDeductionResult
+DeduceNullPtrTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
+ const NonTypeTemplateParmDecl *NTTP,
+ QualType NullPtrType, TemplateDeductionInfo
&Info,
+ SmallVectorImpl<DeducedTemplateArgument>
&Deduced,
+ bool *HasDeducedAnyParam) {
Expr *Value = S.ImpCastExprToType(
new (S.Context) CXXNullPtrLiteralExpr(S.Context.NullPtrTy,
NTTP->getLocation()),
@@ -475,38 +478,41 @@ static TemplateDeductionResult
DeduceNullPtrTemplateArgument(
NullPtrType->isMemberPointerType() ?
CK_NullToMemberPointer
: CK_NullToPointer)
.get();
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- DeducedTemplateArgument(Value),
- Value->getType(), Info, Deduced);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, DeducedTemplateArgument(Value),
Value->getType(),
+ Info, Deduced, HasDeducedAnyParam);
}
/// Deduce the value of the given non-type template parameter
/// from the given type- or value-dependent expression.
///
/// \returns true if deduction succeeded, false otherwise.
-static TemplateDeductionResult DeduceNonTypeTemplateArgument(
- Sema &S, TemplateParameterList *TemplateParams,
- const NonTypeTemplateParmDecl *NTTP, Expr *Value,
- TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- DeducedTemplateArgument(Value),
- Value->getType(), Info, Deduced);
+static TemplateDeductionResult
+DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
+ const NonTypeTemplateParmDecl *NTTP, Expr *Value,
+ TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument>
&Deduced,
+ bool *HasDeducedAnyParam) {
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, DeducedTemplateArgument(Value),
Value->getType(),
+ Info, Deduced, HasDeducedAnyParam);
}
/// Deduce the value of the given non-type template parameter
/// from the given declaration.
///
/// \returns true if deduction succeeded, false otherwise.
-static TemplateDeductionResult DeduceNonTypeTemplateArgument(
- Sema &S, TemplateParameterList *TemplateParams,
- const NonTypeTemplateParmDecl *NTTP, ValueDecl *D, QualType T,
- TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+static TemplateDeductionResult
+DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
+ const NonTypeTemplateParmDecl *NTTP, ValueDecl
*D,
+ QualType T, TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument>
&Deduced,
+ bool *HasDeducedAnyParam) {
D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
TemplateArgument New(D, T);
- return DeduceNonTypeTemplateArgument(
- S, TemplateParams, NTTP, DeducedTemplateArgument(New), T, Info, Deduced);
+ return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+ DeducedTemplateArgument(New), T, Info,
+ Deduced, HasDeducedAnyParam);
}
/// Create a shallow copy of a given template parameter declaration, with
@@ -569,7 +575,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList
*TemplateParams,
TemplateName Param, TemplateName Arg,
TemplateDeductionInfo &Info,
ArrayRef<TemplateArgument> DefaultArguments,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
TemplateDecl *ParamDecl = Param.getAsTemplateDecl();
if (!ParamDecl) {
// The parameter type is dependent and is not a template template
parameter,
@@ -626,6 +633,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList
*TemplateParams,
}
Deduced[TempParam->getIndex()] = Result;
+ if (HasDeducedAnyParam)
+ *HasDeducedAnyParam = true;
return TemplateDeductionResult::Success;
}
@@ -673,7 +682,8 @@ static TemplateDeductionResult
DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams,
const QualType P, QualType A,
TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced)
{
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
QualType UP = P;
if (const auto *IP = P->getAs<InjectedClassNameType>())
UP = IP->getInjectedSpecializationType();
@@ -720,17 +730,19 @@ DeduceTemplateSpecArguments(Sema &S,
TemplateParameterList *TemplateParams,
->template_arguments();
// Perform template argument deduction for the template name.
- if (auto Result = DeduceTemplateArguments(S, TemplateParams, TNP, TNA,
Info,
- AResolved, Deduced);
+ if (auto Result =
+ DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info,
+ AResolved, Deduced, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
// Perform template argument deduction on each template
// argument. Ignore any missing/extra arguments, since they could be
// filled in by default arguments.
- return DeduceTemplateArguments(S, TemplateParams, PResolved, AResolved,
- Info, Deduced,
- /*NumberOfArgumentsMustMatch=*/false);
+ return DeduceTemplateArguments(
+ S, TemplateParams, PResolved, AResolved, Info, Deduced,
+ /*NumberOfArgumentsMustMatch=*/false, PackFold::ParameterToArgument,
+ HasDeducedAnyParam);
}
// If the argument type is a class template specialization, we
@@ -751,16 +763,18 @@ DeduceTemplateSpecArguments(Sema &S,
TemplateParameterList *TemplateParams,
*NNS, false, TemplateName(SA->getSpecializedTemplate()));
// Perform template argument deduction for the template name.
- if (auto Result =
- DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info,
- SA->getTemplateArgs().asArray(), Deduced);
+ if (auto Result = DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info,
+ SA->getTemplateArgs().asArray(),
+ Deduced, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
// Perform template argument deduction for the template arguments.
return DeduceTemplateArguments(S, TemplateParams, PResolved,
SA->getTemplateArgs().asArray(), Info,
Deduced,
- /*NumberOfArgumentsMustMatch=*/true);
+ /*NumberOfArgumentsMustMatch=*/true,
+ PackFold::ParameterToArgument,
+ HasDeducedAnyParam);
}
static bool IsPossiblyOpaquelyQualifiedTypeInternal(const Type *T) {
@@ -834,12 +848,16 @@ namespace {
class PackDeductionScope {
public:
/// Prepare to deduce the packs named within Pattern.
+ /// \param FinishingDeduction Don't attempt to deduce the pack. Useful when
+ /// just checking a previous deduction of the pack.
PackDeductionScope(Sema &S, TemplateParameterList *TemplateParams,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
TemplateDeductionInfo &Info, TemplateArgument Pattern,
- bool DeducePackIfNotAlreadyDeduced = false)
+ bool DeducePackIfNotAlreadyDeduced = false,
+ bool FinishingDeduction = false)
: S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info),
- DeducePackIfNotAlreadyDeduced(DeducePackIfNotAlreadyDeduced){
+ DeducePackIfNotAlreadyDeduced(DeducePackIfNotAlreadyDeduced),
+ FinishingDeduction(FinishingDeduction) {
unsigned NumNamedPacks = addPacks(Pattern);
finishConstruction(NumNamedPacks);
}
@@ -859,8 +877,10 @@ class PackDeductionScope {
// by this pack expansion, then clear out the deduction.
DeducedFromEarlierParameter = !Deduced[Index].isNull();
DeducedPack Pack(Index);
- Pack.Saved = Deduced[Index];
- Deduced[Index] = TemplateArgument();
+ if (!FinishingDeduction) {
+ Pack.Saved = Deduced[Index];
+ Deduced[Index] = TemplateArgument();
+ }
// FIXME: What if we encounter multiple packs with different numbers of
// pre-expanded expansions? (This should already have been diagnosed
@@ -974,7 +994,7 @@ class PackDeductionScope {
// FIXME: If we could represent a "depth i, index j, pack elem k"
// parameter, we could substitute the partially-substituted pack
// everywhere and avoid this.
- if (!IsPartiallyExpanded)
+ if (!FinishingDeduction && !IsPartiallyExpanded)
Deduced[Pack.Index] = Pack.New[PackElements];
}
}
@@ -1024,18 +1044,20 @@ class PackDeductionScope {
// Capture the deduced template arguments for each parameter pack expanded
// by this pack expansion, add them to the list of arguments we've deduced
// for that pack, then clear out the deduced argument.
- for (auto &Pack : Packs) {
- DeducedTemplateArgument &DeducedArg = Deduced[Pack.Index];
- if (!Pack.New.empty() || !DeducedArg.isNull()) {
- while (Pack.New.size() < PackElements)
- Pack.New.push_back(DeducedTemplateArgument());
- if (Pack.New.size() == PackElements)
- Pack.New.push_back(DeducedArg);
- else
- Pack.New[PackElements] = DeducedArg;
- DeducedArg = Pack.New.size() > PackElements + 1
- ? Pack.New[PackElements + 1]
- : DeducedTemplateArgument();
+ if (!FinishingDeduction) {
+ for (auto &Pack : Packs) {
+ DeducedTemplateArgument &DeducedArg = Deduced[Pack.Index];
+ if (!Pack.New.empty() || !DeducedArg.isNull()) {
+ while (Pack.New.size() < PackElements)
+ Pack.New.push_back(DeducedTemplateArgument());
+ if (Pack.New.size() == PackElements)
+ Pack.New.push_back(DeducedArg);
+ else
+ Pack.New[PackElements] = DeducedArg;
+ DeducedArg = Pack.New.size() > PackElements + 1
+ ? Pack.New[PackElements + 1]
+ : DeducedTemplateArgument();
+ }
}
}
++PackElements;
@@ -1045,11 +1067,14 @@ class PackDeductionScope {
/// producing the argument packs and checking for consistency with prior
/// deductions.
TemplateDeductionResult finish() {
+ if (FinishingDeduction)
+ return TemplateDeductionResult::Success;
// Build argument packs for each of the parameter packs expanded by this
// pack expansion.
for (auto &Pack : Packs) {
// Put back the old value for this pack.
- Deduced[Pack.Index] = Pack.Saved;
+ if (!FinishingDeduction)
+ Deduced[Pack.Index] = Pack.Saved;
// Always make sure the size of this pack is correct, even if we didn't
// deduce any values for it.
@@ -1149,6 +1174,7 @@ class PackDeductionScope {
bool IsPartiallyExpanded = false;
bool DeducePackIfNotAlreadyDeduced = false;
bool DeducedFromEarlierParameter = false;
+ bool FinishingDeduction = false;
/// The number of expansions, if we have a fully-expanded pack in this scope.
std::optional<unsigned> FixedNumExpansions;
@@ -1157,43 +1183,13 @@ class PackDeductionScope {
} // namespace
-/// Deduce the template arguments by comparing the list of parameter
-/// types to the list of argument types, as in the parameter-type-lists of
-/// function types (C++ [temp.deduct.type]p10).
-///
-/// \param S The semantic analysis object within which we are deducing
-///
-/// \param TemplateParams The template parameters that we are deducing
-///
-/// \param Params The list of parameter types
-///
-/// \param NumParams The number of types in \c Params
-///
-/// \param Args The list of argument types
-///
-/// \param NumArgs The number of types in \c Args
-///
-/// \param Info information about the template argument deduction itself
-///
-/// \param Deduced the deduced template arguments
-///
-/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
-/// how template argument deduction is performed.
-///
-/// \param PartialOrdering If true, we are performing template argument
-/// deduction for during partial ordering for a call
-/// (C++0x [temp.deduct.partial]).
-///
-/// \returns the result of template argument deduction so far. Note that a
-/// "success" result means that template argument deduction has not yet failed,
-/// but it may still fail, later, for other reasons.
-static TemplateDeductionResult
-DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
- const QualType *Params, unsigned NumParams,
- const QualType *Args, unsigned NumArgs,
- TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced,
- unsigned TDF, bool PartialOrdering = false) {
+template <class T>
+static TemplateDeductionResult DeduceForEachType(
+ Sema &S, TemplateParameterList *TemplateParams, const QualType *Params,
+ unsigned NumParams, const QualType *Args, unsigned NumArgs,
+ TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced, bool PartialOrdering,
+ bool FinishingDeduction, T &&DeductFunc) {
// C++0x [temp.deduct.type]p10:
// Similarly, if P has a form that contains (T), then each parameter type
// Pi of the respective parameter-type- list of P is compared with the
@@ -1219,11 +1215,11 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList
*TemplateParams,
return TemplateDeductionResult::MiscellaneousDeductionFailure;
}
- if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, Params[ParamIdx].getUnqualifiedType(),
- Args[ArgIdx].getUnqualifiedType(), Info, Deduced, TDF,
- PartialOrdering,
- /*DeducedFromArrayBound=*/false);
+ if (TemplateDeductionResult Result =
+ DeductFunc(S, TemplateParams, ParamIdx, ArgIdx,
+ Params[ParamIdx].getUnqualifiedType(),
+ Args[ArgIdx].getUnqualifiedType(), Info, Deduced,
+ PartialOrdering);
Result != TemplateDeductionResult::Success)
return Result;
@@ -1239,20 +1235,21 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList
*TemplateParams,
// template parameter packs expanded by the function parameter pack.
QualType Pattern = Expansion->getPattern();
- PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
+ PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern,
+ /*DeducePackIfNotAlreadyDeduced=*/false,
+ FinishingDeduction);
// A pack scope with fixed arity is not really a pack any more, so is not
// a non-deduced context.
if (ParamIdx + 1 == NumParams || PackScope.hasFixedArity()) {
for (; ArgIdx < NumArgs && PackScope.hasNextElement(); ++ArgIdx) {
// Deduce template arguments from the pattern.
- if (TemplateDeductionResult Result =
DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, Pattern.getUnqualifiedType(),
- Args[ArgIdx].getUnqualifiedType(), Info, Deduced, TDF,
- PartialOrdering, /*DeducedFromArrayBound=*/false);
+ if (TemplateDeductionResult Result = DeductFunc(
+ S, TemplateParams, ParamIdx, ArgIdx,
+ Pattern.getUnqualifiedType(),
Args[ArgIdx].getUnqualifiedType(),
+ Info, Deduced, PartialOrdering);
Result != TemplateDeductionResult::Success)
return Result;
-
PackScope.nextPackElement();
}
} else {
@@ -1305,6 +1302,62 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList
*TemplateParams,
return TemplateDeductionResult::Success;
}
+/// Deduce the template arguments by comparing the list of parameter
+/// types to the list of argument types, as in the parameter-type-lists of
+/// function types (C++ [temp.deduct.type]p10).
+///
+/// \param S The semantic analysis object within which we are deducing
+///
+/// \param TemplateParams The template parameters that we are deducing
+///
+/// \param Params The list of parameter types
+///
+/// \param NumParams The number of types in \c Params
+///
+/// \param Args The list of argument types
+///
+/// \param NumArgs The number of types in \c Args
+///
+/// \param Info information about the template argument deduction itself
+///
+/// \param Deduced the deduced template arguments
+///
+/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
+/// how template argument deduction is performed.
+///
+/// \param PartialOrdering If true, we are performing template argument
+/// deduction for during partial ordering for a call
+/// (C++0x [temp.deduct.partial]).
+///
+/// \returns the result of template argument deduction so far. Note that a
+/// "success" result means that template argument deduction has not yet failed,
+/// but it may still fail, later, for other reasons.
+static TemplateDeductionResult DeduceTemplateArguments(
+ Sema &S, TemplateParameterList *TemplateParams, const QualType *Params,
+ unsigned NumParams, const QualType *Args, unsigned NumArgs,
+ TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
+ bool PartialOrdering, bool *HasDeducedAnyParam,
+ llvm::SmallBitVector *HasDeducedParam) {
+ return ::DeduceForEachType(
+ S, TemplateParams, Params, NumParams, Args, NumArgs, Info, Deduced,
+ PartialOrdering, /*FinishingDeduction=*/false,
+ [&](Sema &S, TemplateParameterList *TemplateParams, int ParamIdx,
+ int ArgIdx, QualType P, QualType A, TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool PartialOrdering) {
+ bool HasDeducedAnyParamCopy = false;
+ TemplateDeductionResult TDR = DeduceTemplateArgumentsByTypeMatch(
+ S, TemplateParams, P, A, Info, Deduced, TDF, PartialOrdering,
+ /*DeducedFromArrayBound=*/false, &HasDeducedAnyParamCopy);
+ if (HasDeducedAnyParam && HasDeducedAnyParamCopy)
+ *HasDeducedAnyParam = true;
+ if (HasDeducedParam && HasDeducedAnyParamCopy)
+ (*HasDeducedParam)[ParamIdx] = true;
+ return TDR;
+ });
+}
+
/// Determine whether the parameter has qualifiers that the argument
/// lacks. Put another way, determine whether there is no way to add
/// a deduced set of qualifiers to the ParamType that would result in
@@ -1405,7 +1458,8 @@ static TemplateDeductionResult
DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD,
TemplateParameterList *TemplateParams, QualType P,
TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
// C++14 [temp.deduct.call] p4b3:
// If P is a class and P has the form simple-template-id, then the
// transformed A can be a derived class of the deduced A. Likewise if
@@ -1430,7 +1484,7 @@ DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD,
// We iterate over this later, so we have to use MapVector to ensure
// determinism.
llvm::MapVector<const CXXRecordDecl *,
- SmallVector<DeducedTemplateArgument, 8>>
+ std::tuple<SmallVector<DeducedTemplateArgument, 8>, bool>>
Matches;
auto AddBases = [&Visited, &ToVisit](const CXXRecordDecl *RD) {
@@ -1453,14 +1507,16 @@ DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD,
SmallVector<DeducedTemplateArgument, 8> DeducedCopy(Deduced.begin(),
Deduced.end());
TemplateDeductionInfo BaseInfo(TemplateDeductionInfo::ForBase, Info);
- TemplateDeductionResult BaseResult = DeduceTemplateSpecArguments(
- S, TemplateParams, P, NextT, BaseInfo, DeducedCopy);
+ bool HasDeducedAnyParamCopy = false;
+ TemplateDeductionResult BaseResult =
+ DeduceTemplateSpecArguments(S, TemplateParams, P, NextT, BaseInfo,
+ DeducedCopy, &HasDeducedAnyParamCopy);
// If this was a successful deduction, add it to the list of matches,
// otherwise we need to continue searching its bases.
const CXXRecordDecl *RD = ::getCanonicalRD(NextT);
if (BaseResult == TemplateDeductionResult::Success)
- Matches.insert({RD, DeducedCopy});
+ Matches.insert({RD, {DeducedCopy, HasDeducedAnyParamCopy}});
else
AddBases(RD);
}
@@ -1493,7 +1549,10 @@ DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD,
if (Matches.size() > 1)
return TemplateDeductionResult::MiscellaneousDeductionFailure;
- std::swap(Matches.front().second, Deduced);
+ std::swap(std::get<0>(Matches.front().second), Deduced);
+ if (bool HasDeducedAnyParamCopy = std::get<1>(Matches.front().second);
+ HasDeducedAnyParamCopy && HasDeducedAnyParam)
+ *HasDeducedAnyParam = HasDeducedAnyParamCopy;
return TemplateDeductionResult::Success;
}
@@ -1525,7 +1584,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
Sema &S, TemplateParameterList *TemplateParams, QualType P, QualType A,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
- bool PartialOrdering, bool DeducedFromArrayBound) {
+ bool PartialOrdering, bool DeducedFromArrayBound,
+ bool *HasDeducedAnyParam) {
// If the argument type is a pack expansion, look at its pattern.
// This isn't explicitly called out
@@ -1707,6 +1767,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
}
Deduced[Index] = Result;
+ if (HasDeducedAnyParam)
+ *HasDeducedAnyParam = true;
return TemplateDeductionResult::Success;
}
@@ -1805,7 +1867,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::NonDeducedMismatch;
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, CP->getElementType(), CA->getElementType(), Info,
- Deduced, TDF);
+ Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// _Atomic T [extension]
@@ -1815,7 +1878,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::NonDeducedMismatch;
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, PA->getValueType(), AA->getValueType(), Info,
- Deduced, TDF);
+ Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// T *
@@ -1831,7 +1895,9 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, P->castAs<PointerType>()->getPointeeType(),
PointeeType, Info, Deduced,
- TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass));
+ TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass),
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
}
// T &
@@ -1843,7 +1909,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
- Deduced, 0);
+ Deduced, 0, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// T && [C++0x]
@@ -1855,7 +1922,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
- Deduced, 0);
+ Deduced, 0, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// T [] (implied, but not stated explicitly)
@@ -1869,7 +1937,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, IAP->getElementType(), IAA->getElementType(),
Info,
- Deduced, TDF & TDF_IgnoreQualifiers);
+ Deduced, TDF & TDF_IgnoreQualifiers, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// T [integer-constant]
@@ -1882,7 +1951,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, CAP->getElementType(), CAA->getElementType(),
Info,
- Deduced, TDF & TDF_IgnoreQualifiers);
+ Deduced, TDF & TDF_IgnoreQualifiers, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// type [i]
@@ -1896,7 +1966,9 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
assert(DAP);
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, DAP->getElementType(), AA->getElementType(),
- Info, Deduced, TDF & TDF_IgnoreQualifiers);
+ Info, Deduced, TDF & TDF_IgnoreQualifiers,
+ /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -1914,12 +1986,13 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
llvm::APSInt Size(CAA->getSize());
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, Size, S.Context.getSizeType(),
- /*ArrayBound=*/true, Info, Deduced);
+ /*ArrayBound=*/true, Info, Deduced, HasDeducedAnyParam);
}
if (const auto *DAA = dyn_cast<DependentSizedArrayType>(AA))
if (DAA->getSizeExpr())
- return DeduceNonTypeTemplateArgument(
- S, TemplateParams, NTTP, DAA->getSizeExpr(), Info, Deduced);
+ return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+ DAA->getSizeExpr(), Info,
+ Deduced, HasDeducedAnyParam);
// Incomplete type does not match a dependently-sized array type
return TemplateDeductionResult::NonDeducedMismatch;
@@ -1944,7 +2017,7 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, FPP->getReturnType(), FPA->getReturnType(),
Info, Deduced, 0,
/*PartialOrdering=*/false,
- /*DeducedFromArrayBound=*/false);
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -1952,7 +2025,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
if (auto Result = DeduceTemplateArguments(
S, TemplateParams, FPP->param_type_begin(), FPP->getNumParams(),
FPA->param_type_begin(), FPA->getNumParams(), Info, Deduced,
- TDF & TDF_TopLevelParameterTypeList, PartialOrdering);
+ TDF & TDF_TopLevelParameterTypeList, PartialOrdering,
+ HasDeducedAnyParam, /*HasDeducedParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -1980,12 +2054,14 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
// FIXME: Should we?
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, Noexcept, S.Context.BoolTy,
- /*DeducedFromArrayBound=*/true, Info, Deduced);
+ /*DeducedFromArrayBound=*/true, Info, Deduced,
+ HasDeducedAnyParam);
case CT_Dependent:
if (Expr *ArgNoexceptExpr = FPA->getNoexceptExpr())
- return DeduceNonTypeTemplateArgument(
- S, TemplateParams, NTTP, ArgNoexceptExpr, Info, Deduced);
+ return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+ ArgNoexceptExpr, Info,
Deduced,
+ HasDeducedAnyParam);
// Can't deduce anything from throw(T...).
break;
}
@@ -2012,13 +2088,13 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
// arguments from the template-id.
if (!(TDF & TDF_DerivedClass) || !A->isRecordType())
return DeduceTemplateSpecArguments(S, TemplateParams, P, A, Info,
- Deduced);
+ Deduced, HasDeducedAnyParam);
SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(),
Deduced.end());
- auto Result =
- DeduceTemplateSpecArguments(S, TemplateParams, P, A, Info, Deduced);
+ auto Result = DeduceTemplateSpecArguments(S, TemplateParams, P, A, Info,
+ Deduced, HasDeducedAnyParam);
if (Result == TemplateDeductionResult::Success)
return Result;
@@ -2035,8 +2111,9 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
Deduced = DeducedOrig;
// Check bases according to C++14 [temp.deduct.call] p4b3:
- auto BaseResult = DeduceTemplateBases(S, getCanonicalRD(A),
- TemplateParams, P, Info, Deduced);
+ auto BaseResult =
+ DeduceTemplateBases(S, getCanonicalRD(A), TemplateParams, P, Info,
+ Deduced, HasDeducedAnyParam);
return BaseResult != TemplateDeductionResult::Invalid ? BaseResult
: Result;
}
@@ -2067,12 +2144,16 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, PPT, APT, Info, Deduced, SubTDF);
+ S, TemplateParams, PPT, APT, Info, Deduced, SubTDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, QualType(MPP->getClass(), 0),
- QualType(MPA->getClass(), 0), Info, Deduced, SubTDF);
+ QualType(MPA->getClass(), 0), Info, Deduced, SubTDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
}
// (clang extension)
@@ -2087,7 +2168,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::NonDeducedMismatch;
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, BPP->getPointeeType(), BPA->getPointeeType(),
Info,
- Deduced, 0);
+ Deduced, 0, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// (clang extension)
@@ -2112,7 +2194,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the element types.
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), ElementType, Info, Deduced,
- TDF);
+ TDF, /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
}
case Type::DependentVector: {
@@ -2122,7 +2205,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the element types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), VA->getElementType(),
- Info, Deduced, TDF);
+ Info, Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2139,14 +2223,15 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
// we can provide one if necessary.
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
S.Context.UnsignedIntTy, true,
- Info, Deduced);
+ Info, Deduced,
HasDeducedAnyParam);
}
if (const auto *VA = A->getAs<DependentVectorType>()) {
// Perform deduction on the element types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), VA->getElementType(),
- Info, Deduced, TDF);
+ Info, Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2157,7 +2242,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::Success;
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- VA->getSizeExpr(), Info, Deduced);
+ VA->getSizeExpr(), Info, Deduced,
+ HasDeducedAnyParam);
}
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2173,7 +2259,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the element types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), VA->getElementType(),
- Info, Deduced, TDF);
+ Info, Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2190,14 +2277,15 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
// we can provide one if necessary.
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
S.Context.IntTy, true, Info,
- Deduced);
+ Deduced, HasDeducedAnyParam);
}
if (const auto *VA = A->getAs<DependentSizedExtVectorType>()) {
// Perform deduction on the element types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), VA->getElementType(),
- Info, Deduced, TDF);
+ Info, Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2208,7 +2296,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::Success;
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- VA->getSizeExpr(), Info, Deduced);
+ VA->getSizeExpr(), Info, Deduced,
+ HasDeducedAnyParam);
}
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2232,7 +2321,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on element types.
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, MP->getElementType(), MA->getElementType(), Info,
- Deduced, TDF);
+ Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
case Type::DependentSizedMatrix: {
@@ -2244,13 +2334,14 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
// Check the element type of the matrixes.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, MP->getElementType(), MA->getElementType(),
- Info, Deduced, TDF);
+ Info, Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
// Try to deduce a matrix dimension.
auto DeduceMatrixArg =
- [&S, &Info, &Deduced, &TemplateParams](
+ [&S, &Info, &Deduced, &TemplateParams, &HasDeducedAnyParam](
Expr *ParamExpr, const MatrixType *A,
unsigned (ConstantMatrixType::*GetArgDimension)() const,
Expr *(DependentSizedMatrixType::*GetArgDimensionExpr)() const) {
@@ -2287,12 +2378,12 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
ArgConst = (ACM->*GetArgDimension)();
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, ArgConst, S.Context.getSizeType(),
- /*ArrayBound=*/true, Info, Deduced);
+ /*ArrayBound=*/true, Info, Deduced, HasDeducedAnyParam);
}
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- (ADM->*GetArgDimensionExpr)(),
- Info, Deduced);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, (ADM->*GetArgDimensionExpr)(), Info,
+ Deduced, HasDeducedAnyParam);
};
if (auto Result = DeduceMatrixArg(MP->getRowExpr(), MA,
@@ -2316,7 +2407,8 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the pointer type.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, ASP->getPointeeType(),
ASA->getPointeeType(),
- Info, Deduced, TDF);
+ Info, Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2326,8 +2418,9 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
if (!NTTP)
return TemplateDeductionResult::Success;
- return DeduceNonTypeTemplateArgument(
- S, TemplateParams, NTTP, ASA->getAddrSpaceExpr(), Info, Deduced);
+ return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+ ASA->getAddrSpaceExpr(), Info,
+ Deduced, HasDeducedAnyParam);
}
if (isTargetAddressSpace(A.getAddressSpace())) {
@@ -2338,7 +2431,9 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the pointer types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, ASP->getPointeeType(),
- S.Context.removeAddrSpaceQualType(A), Info, Deduced, TDF);
+ S.Context.removeAddrSpaceQualType(A), Info, Deduced, TDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2348,9 +2443,9 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
if (!NTTP)
return TemplateDeductionResult::Success;
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- ArgAddressSpace, S.Context.IntTy,
- true, Info, Deduced);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, ArgAddressSpace, S.Context.IntTy, true,
+ Info, Deduced, HasDeducedAnyParam);
}
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2372,7 +2467,7 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
S.Context.IntTy, true, Info,
- Deduced);
+ Deduced, HasDeducedAnyParam);
}
if (const auto *IA = A->getAs<DependentBitIntType>()) {
@@ -2402,7 +2497,9 @@ static TemplateDeductionResult
DeduceTemplateArgumentsByTypeMatch(
const PackIndexingType *PIT = P->getAs<PackIndexingType>();
if (PIT->hasSelectedType()) {
return DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, PIT->getSelectedType(), A, Info, Deduced, TDF);
+ S, TemplateParams, PIT->getSelectedType(), A, Info, Deduced, TDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
}
return TemplateDeductionResult::IncompletePack;
}
@@ -2415,7 +2512,8 @@ static TemplateDeductionResult
DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
const TemplateArgument &P, TemplateArgument A,
TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
// If the template argument is a pack expansion, perform template argument
// deduction against the pattern of that expansion. This only occurs during
// partial ordering.
@@ -2429,16 +2527,18 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList
*TemplateParams,
case TemplateArgument::Type:
if (A.getKind() == TemplateArgument::Type)
return DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, P.getAsType(), A.getAsType(), Info, Deduced, 0);
+ S, TemplateParams, P.getAsType(), A.getAsType(), Info, Deduced, 0,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
Info.FirstArg = P;
Info.SecondArg = A;
return TemplateDeductionResult::NonDeducedMismatch;
case TemplateArgument::Template:
if (A.getKind() == TemplateArgument::Template)
- return DeduceTemplateArguments(S, TemplateParams, P.getAsTemplate(),
- A.getAsTemplate(), Info,
- /*DefaultArguments=*/{}, Deduced);
+ return DeduceTemplateArguments(
+ S, TemplateParams, P.getAsTemplate(), A.getAsTemplate(), Info,
+ /*DefaultArguments=*/{}, Deduced, HasDeducedAnyParam);
Info.FirstArg = P;
Info.SecondArg = A;
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2489,18 +2589,20 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList
*TemplateParams,
case TemplateArgument::Integral:
case TemplateArgument::Expression:
case TemplateArgument::StructuralValue:
- return DeduceNonTypeTemplateArgument(
- S, TemplateParams, NTTP, DeducedTemplateArgument(A),
- A.getNonTypeTemplateArgumentType(), Info, Deduced);
+ return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+ DeducedTemplateArgument(A),
+
A.getNonTypeTemplateArgumentType(),
+ Info, Deduced,
HasDeducedAnyParam);
case TemplateArgument::NullPtr:
return DeduceNullPtrTemplateArgument(S, TemplateParams, NTTP,
- A.getNullPtrType(), Info,
Deduced);
+ A.getNullPtrType(), Info, Deduced,
+ HasDeducedAnyParam);
case TemplateArgument::Declaration:
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, A.getAsDecl(), A.getParamTypeForDecl(),
- Info, Deduced);
+ Info, Deduced, HasDeducedAnyParam);
case TemplateArgument::Null:
case TemplateArgument::Type:
@@ -2572,7 +2674,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList
*TemplateParams,
ArrayRef<TemplateArgument> As,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
- bool NumberOfArgumentsMustMatch, PackFold PackFold) {
+ bool NumberOfArgumentsMustMatch, PackFold PackFold,
+ bool *HasDeducedAnyParam) {
if (PackFold == PackFold::ArgumentToParameter)
std::swap(Ps, As);
// C++0x [temp.deduct.type]p9:
@@ -2608,8 +2711,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList
*TemplateParams,
TemplateArgument Pi = P, Ai = As[ArgIdx];
if (PackFold == PackFold::ArgumentToParameter)
std::swap(Pi, Ai);
- if (auto Result =
- DeduceTemplateArguments(S, TemplateParams, Pi, Ai, Info,
Deduced);
+ if (auto Result = DeduceTemplateArguments(S, TemplateParams, Pi, Ai,
Info,
+ Deduced, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2640,8 +2743,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList
*TemplateParams,
if (PackFold == PackFold::ArgumentToParameter)
std::swap(Pi, Ai);
// Deduce template arguments from the pattern.
- if (auto Result =
- DeduceTemplateArguments(S, TemplateParams, Pi, Ai, Info,
Deduced);
+ if (auto Result = DeduceTemplateArguments(S, TemplateParams, Pi, Ai,
Info,
+ Deduced, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2663,8 +2766,9 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
ArrayRef<TemplateArgument> As, sema::TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool NumberOfArgumentsMustMatch) {
- return ::DeduceTemplateArguments(*this, TemplateParams, Ps, As, Info,
Deduced,
- NumberOfArgumentsMustMatch);
+ return ::DeduceTemplateArguments(
+ *this, TemplateParams, Ps, As, Info, Deduced, NumberOfArgumentsMustMatch,
+ PackFold::ParameterToArgument, /*HasDeducedAnyParam=*/nullptr);
}
/// Determine whether two template arguments are the same.
@@ -2922,7 +3026,7 @@ static TemplateDeductionResult
ConvertDeducedTemplateArguments(
SmallVectorImpl<TemplateArgument> &SugaredBuilder,
SmallVectorImpl<TemplateArgument> &CanonicalBuilder,
LocalInstantiationScope *CurrentInstantiationScope = nullptr,
- unsigned NumAlreadyConverted = 0, bool PartialOverloading = false) {
+ unsigned NumAlreadyConverted = 0, bool *IsIncomplete = nullptr) {
TemplateParameterList *TemplateParams = Template->getTemplateParameters();
for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
@@ -3008,11 +3112,17 @@ static TemplateDeductionResult
ConvertDeducedTemplateArguments(
// If there was no default argument, deduction is incomplete.
if (DefArg.getArgument().isNull()) {
+ if (IsIncomplete) {
+ *IsIncomplete = true;
+ SugaredBuilder.push_back({});
+ CanonicalBuilder.push_back({});
+ continue;
+ }
+
Info.Param = makeTemplateParameter(
const_cast<NamedDecl *>(TemplateParams->getParam(I)));
Info.reset(TemplateArgumentList::CreateCopy(S.Context, SugaredBuilder),
TemplateArgumentList::CreateCopy(S.Context,
CanonicalBuilder));
- if (PartialOverloading) break;
return HasDefaultArg ? TemplateDeductionResult::SubstitutionFailure
: TemplateDeductionResult::Incomplete;
@@ -3227,7 +3337,7 @@ static TemplateDeductionResult
FinishTemplateArgumentDeduction(
S, Template, /*IsDeduced*/ PartialOrdering, Deduced, Info,
SugaredBuilder, CanonicalBuilder,
/*CurrentInstantiationScope=*/nullptr,
- /*NumAlreadyConverted=*/0U, /*PartialOverloading=*/false);
+ /*NumAlreadyConverted=*/0U);
Result != TemplateDeductionResult::Success)
return Result;
@@ -3321,7 +3431,8 @@ DeduceTemplateArguments(Sema &S, T *Partial,
if (TemplateDeductionResult Result = ::DeduceTemplateArguments(
S, Partial->getTemplateParameters(),
Partial->getTemplateArgs().asArray(), TemplateArgs, Info, Deduced,
- /*NumberOfArgumentsMustMatch=*/false);
+ /*NumberOfArgumentsMustMatch=*/false, PackFold::ParameterToArgument,
+ /*HasDeducedAnyParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -3831,11 +3942,12 @@ TemplateDeductionResult
Sema::FinishTemplateArgumentDeduction(
// C++ [temp.deduct.type]p2:
// [...] or if any template argument remains neither deduced nor
// explicitly specified, template argument deduction fails.
+ bool IsIncomplete = false;
SmallVector<TemplateArgument, 4> SugaredBuilder, CanonicalBuilder;
if (auto Result = ConvertDeducedTemplateArguments(
*this, FunctionTemplate, /*IsDeduced*/ true, Deduced, Info,
SugaredBuilder, CanonicalBuilder, CurrentInstantiationScope,
- NumExplicitlySpecified, PartialOverloading);
+ NumExplicitlySpecified, PartialOverloading ? &IsIncomplete :
nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -3914,9 +4026,7 @@ TemplateDeductionResult
Sema::FinishTemplateArgumentDeduction(
// ([temp.constr.decl]), those constraints are checked for satisfaction
// ([temp.constr.constr]). If the constraints are not satisfied, type
// deduction fails.
- if (!PartialOverloading ||
- (CanonicalBuilder.size() ==
- FunctionTemplate->getTemplateParameters()->size())) {
+ if (!IsIncomplete) {
if (CheckInstantiatedFunctionTemplateConstraints(
Info.getLocation(), Specialization, CanonicalBuilder,
Info.AssociatedConstraintsSatisfaction))
@@ -4126,7 +4236,9 @@ ResolveOverloadForDeduction(Sema &S,
TemplateParameterList *TemplateParams,
Deduced(TemplateParams->size());
TemplateDeductionInfo Info(Ovl->getNameLoc());
TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF);
+ S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr);
if (Result != TemplateDeductionResult::Success)
continue;
if (!Match.isNull())
@@ -4312,7 +4424,8 @@ static TemplateDeductionResult DeduceFromInitializerList(
llvm::APInt Size(S.Context.getIntWidth(T), ILE->getNumInits());
if (auto Result = DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, llvm::APSInt(Size), T,
- /*ArrayBound=*/true, Info, Deduced);
+ /*ArrayBound=*/true, Info, Deduced,
+ /*HasDeducedAnyParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
}
@@ -4355,8 +4468,10 @@ static TemplateDeductionResult
DeduceTemplateArgumentsFromCallArgument(
if (Arg)
OriginalCallArgs.push_back(
Sema::OriginalCallArg(OrigParamType, DecomposedParam, ArgIdx,
ArgType));
- return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
- ArgType, Info, Deduced, TDF);
+ return DeduceTemplateArgumentsByTypeMatch(
+ S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr);
}
TemplateDeductionResult Sema::DeduceTemplateArguments(
@@ -4680,7 +4795,8 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
// Deduce template arguments from the function type.
if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(
*this, TemplateParams, FunctionType, ArgFunctionType, Info,
Deduced,
- TDF);
+ TDF, /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
}
@@ -4860,7 +4976,9 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
}
if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(
- *this, TemplateParams, P, A, Info, Deduced, TDF);
+ *this, TemplateParams, P, A, Info, Deduced, TDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -5399,11 +5517,98 @@ static QualType
GetImplicitObjectParameterType(ASTContext &Context,
return Context.getLValueReferenceType(RawType);
}
+static TemplateDeductionResult CheckDeductionConsistency(
+ Sema &S, FunctionTemplateDecl *FTD, int ArgIdx, QualType P, QualType A,
+ ArrayRef<TemplateArgument> DeducedArgs, bool CheckConsistency) {
+ QualType InstP;
+ {
+ MultiLevelTemplateArgumentList MLTAL(FTD, DeducedArgs,
+ /*Final=*/true);
+ if (ArgIdx != -1)
+ if (auto *MD = dyn_cast<CXXMethodDecl>(FTD->getTemplatedDecl());
+ MD && MD->isImplicitObjectMemberFunction())
+ ArgIdx -= 1;
+ Sema::ArgumentPackSubstitutionIndexRAII PackIndex(
+ S, ArgIdx != -1 ? ::getPackIndexForParam(S, FTD, MLTAL, ArgIdx) : -1);
+ InstP = S.SubstType(P, MLTAL, FTD->getLocation(), FTD->getDeclName());
+ if (InstP.isNull())
+ return TemplateDeductionResult::SubstitutionFailure;
+ }
+
+ // [temp.deduct.call]/4 - Check we produced a consistent deduction.
+ // This handles just the cases that can appear when partial ordering.
+ if (auto *PA = dyn_cast<PackExpansionType>(A);
+ PA && !isa<PackExpansionType>(InstP))
+ A = PA->getPattern();
+ if (CheckConsistency &&
+ !S.Context.hasSameType(
+ S.Context.getUnqualifiedArrayType(InstP.getNonReferenceType()),
+ S.Context.getUnqualifiedArrayType(A.getNonReferenceType())))
+ return TemplateDeductionResult::NonDeducedMismatch;
+ return TemplateDeductionResult::Success;
+}
+
+template <class T>
+static TemplateDeductionResult FinishTemplateArgumentDeduction(
+ Sema &S, FunctionTemplateDecl *FTD,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ TemplateDeductionInfo &Info, T &&CheckDeductionConsistency) {
+ // Unevaluated SFINAE context.
+ EnterExpressionEvaluationContext Unevaluated(
+ S, Sema::ExpressionEvaluationContext::Unevaluated);
+ Sema::SFINAETrap Trap(S);
+
+ Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(FTD));
+
+ // C++ [temp.deduct.type]p2:
+ // [...] or if any template argument remains neither deduced nor
+ // explicitly specified, template argument deduction fails.
+ bool IsIncomplete = false;
+ SmallVector<TemplateArgument, 4> SugaredBuilder, CanonicalBuilder;
+ if (auto Result = ConvertDeducedTemplateArguments(
+ S, FTD, /*IsDeduced=*/true, Deduced, Info, SugaredBuilder,
+ CanonicalBuilder, /*CurrentInstantiationScope=*/nullptr,
+ /*NumAlreadyConverted=*/0, &IsIncomplete);
+ Result != TemplateDeductionResult::Success)
+ return Result;
+
+ // Form the template argument list from the deduced template arguments.
+ TemplateArgumentList *SugaredDeducedArgumentList =
+ TemplateArgumentList::CreateCopy(S.Context, SugaredBuilder);
+ TemplateArgumentList *CanonicalDeducedArgumentList =
+ TemplateArgumentList::CreateCopy(S.Context, CanonicalBuilder);
+
+ Info.reset(SugaredDeducedArgumentList, CanonicalDeducedArgumentList);
+
+ // Substitute the deduced template arguments into the argument
+ // and verify that the instantiated argument is both valid
+ // and equivalent to the parameter.
+ LocalInstantiationScope InstScope(S);
+
+ if (auto TDR = CheckDeductionConsistency(S, FTD, SugaredBuilder);
+ TDR != TemplateDeductionResult::Success)
+ return TDR;
+
+ // C++20 [temp.deduct]p5 - Only check constraints when all parameters have
+ // been deduced.
+ if (!IsIncomplete) {
+ if (auto Result = CheckDeducedArgumentConstraints(S, FTD, SugaredBuilder,
+ CanonicalBuilder, Info);
+ Result != TemplateDeductionResult::Success)
+ return Result;
+ }
+
+ if (Trap.hasErrorOccurred())
+ return TemplateDeductionResult::SubstitutionFailure;
+
+ return TemplateDeductionResult::Success;
+}
+
/// Determine whether the function template \p FT1 is at least as
/// specialized as \p FT2.
static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc,
- const FunctionTemplateDecl *FT1,
- const FunctionTemplateDecl *FT2,
+ FunctionTemplateDecl *FT1,
+ FunctionTemplateDecl *FT2,
TemplatePartialOrderingContext TPOC,
bool Reversed,
const SmallVector<QualType> &Args1,
@@ -5425,34 +5630,135 @@ static bool isAtLeastAsSpecializedAs(Sema &S,
SourceLocation Loc,
// the partial ordering is done:
TemplateDeductionInfo Info(Loc);
switch (TPOC) {
- case TPOC_Call:
- if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(),
- Args1.data(), Args1.size(), Info, Deduced,
- TDF_None, /*PartialOrdering=*/true) !=
- TemplateDeductionResult::Success)
+ case TPOC_Call: {
+ llvm::SmallBitVector HasDeducedParam(Args2.size());
+ if (DeduceTemplateArguments(
+ S, TemplateParams, Args2.data(), Args2.size(), Args1.data(),
+ Args1.size(), Info, Deduced, TDF_None, /*PartialOrdering=*/true,
+ /*HasDeducedAnyParam=*/nullptr,
+ &HasDeducedParam) != TemplateDeductionResult::Success)
return false;
- break;
+ SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
+ Deduced.end());
+ Sema::InstantiatingTemplate Inst(
+ S, Info.getLocation(), FT2, DeducedArgs,
+ Sema::CodeSynthesisContext::DeducedTemplateArgumentSubstitution, Info);
+ if (Inst.isInvalid())
+ return false;
- case TPOC_Conversion:
+ bool AtLeastAsSpecialized = true;
+ S.runWithSufficientStackSpace(Info.getLocation(), [&] {
+ AtLeastAsSpecialized =
+ ::FinishTemplateArgumentDeduction(
+ S, FT2, Deduced, Info,
+ [&](Sema &S, FunctionTemplateDecl *FTD,
+ ArrayRef<TemplateArgument> DeducedArgs) {
+ return ::DeduceForEachType(
+ S, TemplateParams, Args2.data(), Args2.size(),
Args1.data(),
+ Args1.size(), Info, Deduced,
+ /*PartialOrdering=*/true, /*FinishingDeduction=*/true,
+ [&](Sema &S, TemplateParameterList *, int ParamIdx,
+ int ArgIdx, QualType P, QualType A,
+ TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool) {
+ return ::CheckDeductionConsistency(
+ S, FTD, ArgIdx, P, A, DeducedArgs,
+ HasDeducedParam[ParamIdx]);
+ });
+ }) == TemplateDeductionResult::Success;
+ });
+ if (!AtLeastAsSpecialized)
+ return false;
+ } break;
+
+ case TPOC_Conversion: {
// - In the context of a call to a conversion operator, the return types
// of the conversion function templates are used.
if (DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, Proto2->getReturnType(),
Proto1->getReturnType(),
Info, Deduced, TDF_None,
- /*PartialOrdering=*/true) != TemplateDeductionResult::Success)
+ /*PartialOrdering=*/true, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr) !=
TemplateDeductionResult::Success)
return false;
- break;
- case TPOC_Other:
+ SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
+ Deduced.end());
+ Sema::InstantiatingTemplate Inst(
+ S, Info.getLocation(), FT2, DeducedArgs,
+ Sema::CodeSynthesisContext::DeducedTemplateArgumentSubstitution, Info);
+ if (Inst.isInvalid())
+ return false;
+
+ bool AtLeastAsSpecialized;
+ S.runWithSufficientStackSpace(Info.getLocation(), [&] {
+ AtLeastAsSpecialized =
+ ::FinishTemplateArgumentDeduction(
+ S, FT2, Deduced, Info,
+ [&](Sema &S, FunctionTemplateDecl *FTD,
+ ArrayRef<TemplateArgument> DeducedArgs) {
+ return ::CheckDeductionConsistency(
+ S, FTD, /*ArgIdx=*/-1, Proto2->getReturnType(),
+ Proto1->getReturnType(), DeducedArgs,
+ /*CheckConsistency=*/true);
+ }) == TemplateDeductionResult::Success;
+ });
+ if (!AtLeastAsSpecialized)
+ return false;
+ } break;
+
+ case TPOC_Other: {
// - In other contexts (14.6.6.2) the function template's function type
// is used.
if (DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, FD2->getType(), FD1->getType(), Info, Deduced,
TDF_AllowCompatibleFunctionType,
- /*PartialOrdering=*/true) != TemplateDeductionResult::Success)
+ /*PartialOrdering=*/true, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr) !=
TemplateDeductionResult::Success)
return false;
- break;
+
+ SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
+ Deduced.end());
+ Sema::InstantiatingTemplate Inst(
+ S, Info.getLocation(), FT2, DeducedArgs,
+ Sema::CodeSynthesisContext::DeducedTemplateArgumentSubstitution, Info);
+ if (Inst.isInvalid())
+ return false;
+
+ bool AtLeastAsSpecialized;
+ S.runWithSufficientStackSpace(Info.getLocation(), [&] {
+ AtLeastAsSpecialized =
+ ::FinishTemplateArgumentDeduction(
+ S, FT2, Deduced, Info,
+ [&](Sema &S, FunctionTemplateDecl *FTD,
+ ArrayRef<TemplateArgument> DeducedArgs) {
+ if (auto TDR = ::CheckDeductionConsistency(
+ S, FTD, /*ArgIdx=*/-1, Proto2->getReturnType(),
+ Proto1->getReturnType(), DeducedArgs,
+ /*CheckConsistency=*/true);
+ TDR != TemplateDeductionResult::Success)
+ return TDR;
+ return ::DeduceForEachType(
+ S, TemplateParams, Proto2->getParamTypes().data(),
+ Proto2->getParamTypes().size(),
+ Proto1->getParamTypes().data(),
+ Proto1->getParamTypes().size(), Info, Deduced,
+ /*PartialOrdering=*/true, /*FinishingDeduction=*/true,
+ [&](Sema &S, TemplateParameterList *, int ParamIdx,
+ int ArgIdx, QualType P, QualType A,
+ TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool) {
+ return ::CheckDeductionConsistency(
+ S, FTD, ArgIdx, P, A, DeducedArgs,
+ /*CheckConsistency=*/true);
+ });
+ }) == TemplateDeductionResult::Success;
+ });
+ if (!AtLeastAsSpecialized)
+ return false;
+ } break;
}
// C++0x [temp.deduct.partial]p11:
@@ -5466,10 +5772,6 @@ static bool isAtLeastAsSpecializedAs(Sema &S,
SourceLocation Loc,
if (Deduced[ArgIdx].isNull())
break;
- // FIXME: We fail to implement [temp.deduct.type]p1 along this path. We need
- // to substitute the deduced arguments back into the template and check that
- // we get the right type.
-
if (ArgIdx == NumArgs) {
// All template arguments were deduced. FT1 is at least as specialized
// as FT2.
@@ -5558,38 +5860,50 @@ FunctionTemplateDecl *Sema::getMoreSpecializedTemplate(
// "that is a member function with no expicit object argument".
// Otherwise the ordering rules for methods with expicit objet arguments
// against anything else make no sense.
- ShouldConvert1 = Method1 && !Method1->isExplicitObjectMemberFunction();
- ShouldConvert2 = Method2 && !Method2->isExplicitObjectMemberFunction();
- if (ShouldConvert1) {
- bool IsRValRef2 =
- ShouldConvert2
- ? Method2->getRefQualifier() == RQ_RValue
- : Proto2->param_type_begin()[0]->isRValueReferenceType();
- // Compare 'this' from Method1 against first parameter from Method2.
- Obj1Ty = GetImplicitObjectParameterType(this->Context, Method1,
RawObj1Ty,
- IsRValRef2);
- Args1.push_back(Obj1Ty);
- }
- if (ShouldConvert2) {
- bool IsRValRef1 =
- ShouldConvert1
- ? Method1->getRefQualifier() == RQ_RValue
- : Proto1->param_type_begin()[0]->isRValueReferenceType();
- // Compare 'this' from Method2 against first parameter from Method1.
- Obj2Ty = GetImplicitObjectParameterType(this->Context, Method2,
RawObj2Ty,
- IsRValRef1);
- Args2.push_back(Obj2Ty);
- }
+
+ bool NonStaticMethod1 = Method1 && !Method1->isStatic(),
+ NonStaticMethod2 = Method2 && !Method2->isStatic();
+
+ auto Params1Begin = Proto1->param_type_begin(),
+ Params2Begin = Proto2->param_type_begin();
+
size_t NumComparedArguments = NumCallArguments1;
- // Either added an argument above or the prototype includes an explicit
- // object argument we need to count
- if (Method1)
- ++NumComparedArguments;
- Args1.insert(Args1.end(), Proto1->param_type_begin(),
- Proto1->param_type_end());
- Args2.insert(Args2.end(), Proto2->param_type_begin(),
- Proto2->param_type_end());
+ if ((NonStaticMethod1 && NonStaticMethod2) || FD1->isOverloadedOperator())
{
+ ShouldConvert1 =
+ NonStaticMethod1 &&
!Method1->hasCXXExplicitFunctionObjectParameter();
+ ShouldConvert2 =
+ NonStaticMethod2 &&
!Method2->hasCXXExplicitFunctionObjectParameter();
+ NumComparedArguments += 1;
+
+ if (ShouldConvert1) {
+ bool IsRValRef2 =
+ ShouldConvert2
+ ? Method2->getRefQualifier() == RQ_RValue
+ : Proto2->param_type_begin()[0]->isRValueReferenceType();
+ // Compare 'this' from Method1 against first parameter from Method2.
+ Obj1Ty = GetImplicitObjectParameterType(this->Context, Method1,
+ RawObj1Ty, IsRValRef2);
+ Args1.push_back(Obj1Ty);
+ }
+ if (ShouldConvert2) {
+ bool IsRValRef1 =
+ ShouldConvert1
+ ? Method1->getRefQualifier() == RQ_RValue
+ : Proto1->param_type_begin()[0]->isRValueReferenceType();
+ // Compare 'this' from Method2 against first parameter from Method1.
+ Obj2Ty = GetImplicitObjectParameterType(this->Context, Method2,
+ RawObj2Ty, IsRValRef1);
+ Args2.push_back(Obj2Ty);
+ }
+ } else {
+ if (NonStaticMethod1 && Method1->hasCXXExplicitFunctionObjectParameter())
+ Params1Begin += 1;
+ if (NonStaticMethod2 && Method2->hasCXXExplicitFunctionObjectParameter())
+ Params2Begin += 1;
+ }
+ Args1.insert(Args1.end(), Params1Begin, Proto1->param_type_end());
+ Args2.insert(Args2.end(), Params2Begin, Proto2->param_type_end());
// C++ [temp.func.order]p5:
// The presence of unused ellipsis and default arguments has no effect on
@@ -5884,7 +6198,8 @@ static bool isAtLeastAsSpecializedAs(Sema &S, QualType
T1, QualType T2,
Deduced.resize(P2->getTemplateParameters()->size());
if (DeduceTemplateArgumentsByTypeMatch(
S, P2->getTemplateParameters(), T2, T1, Info, Deduced, TDF_None,
- /*PartialOrdering=*/true) != TemplateDeductionResult::Success)
+ /*PartialOrdering=*/true, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr) != TemplateDeductionResult::Success)
return false;
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
@@ -6218,7 +6533,8 @@ bool
Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
if (::DeduceTemplateArguments(*this, A, AArgs, PArgs, Info, Deduced,
/*NumberOfArgumentsMustMatch=*/false,
IsDeduced ? PackFold::ArgumentToParameter
- : PackFold::ParameterToArgument) !=
+ : PackFold::ParameterToArgument,
+ /*HasDeducedAnyParam=*/nullptr) !=
TemplateDeductionResult::Success)
return false;
diff --git a/clang/test/CodeCompletion/variadic-template.cpp
b/clang/test/CodeCompletion/variadic-template.cpp
index 31fc55ee154f6..370cf5e8461d6 100644
--- a/clang/test/CodeCompletion/variadic-template.cpp
+++ b/clang/test/CodeCompletion/variadic-template.cpp
@@ -8,7 +8,7 @@ void f() {
// The important thing is that we provide OVERLOAD signature in all those
cases.
//
// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:%(line-5):7 %s -o -
| FileCheck --check-prefix=CHECK-1 %s
- // CHECK-1: OVERLOAD: [#void#]fun(<#T x#>, Args args...)
+ // CHECK-1: OVERLOAD: [#void#]fun(<#T x#>)
// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:%(line-7):10 %s -o -
| FileCheck --check-prefix=CHECK-2 %s
// CHECK-2: OVERLOAD: [#void#]fun(int x)
// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:%(line-9):13 %s -o -
| FileCheck --check-prefix=CHECK-3 %s
diff --git a/clang/test/SemaTemplate/GH18291.cpp
b/clang/test/SemaTemplate/GH18291.cpp
new file mode 100644
index 0000000000000..2dc7328edad52
--- /dev/null
+++ b/clang/test/SemaTemplate/GH18291.cpp
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -std=c++23 -verify %s
+
+template<bool> struct enable_if { typedef void type; };
+template <class T> class Foo {};
+template <class X> constexpr bool check() { return true; }
+template <class X, class Enable = void> struct Bar {};
+
+template<class X> void func(Bar<X, typename enable_if<check<X>()>::type>) {}
+// expected-note@-1 {{candidate function}}
+
+template<class T> void func(Bar<Foo<T>>) {}
+// expected-note@-1 {{candidate function}}
+
+void g() {
+ func(Bar<Foo<int>>()); // expected-error {{call to 'func' is ambiguous}}
+}
diff --git a/clang/test/SemaTemplate/cwg2398.cpp
b/clang/test/SemaTemplate/cwg2398.cpp
index 7675d4287cb88..6fe1bd3d4f165 100644
--- a/clang/test/SemaTemplate/cwg2398.cpp
+++ b/clang/test/SemaTemplate/cwg2398.cpp
@@ -74,6 +74,20 @@ namespace class_template {
// new-error@-1 {{ambiguous partial specialization}}
} // namespace class_template
+namespace class_template_func {
+ template <class T1, class T2 = float> struct A {};
+
+ template <template <class T4> class TT1, class T5> void f(TT1<T5>);
+ // new-note@-1 {{candidate function}}
+
+ template <class T6, class T7> void f(A<T6, T7>) {};
+ // new-note@-1 {{candidate function}}
+
+ void g() {
+ f(A<int>()); // new-error {{call to 'f' is ambiguous}}
+ }
+} // namespace class_template_func
+
namespace type_pack1 {
template<class T2> struct A;
template<template<class ...T3s> class TT1, class T4> struct A<TT1<T4>> ;
diff --git a/clang/test/SemaTemplate/temp_arg_nontype.cpp
b/clang/test/SemaTemplate/temp_arg_nontype.cpp
index e091de669fab4..cbcfb2a5b8674 100644
--- a/clang/test/SemaTemplate/temp_arg_nontype.cpp
+++ b/clang/test/SemaTemplate/temp_arg_nontype.cpp
@@ -458,17 +458,13 @@ namespace dependent_nested_partial_specialization {
namespace nondependent_default_arg_ordering {
int n, m;
template<typename A, A B = &n> struct X {};
- template<typename A> void f(X<A>); // expected-note {{candidate}}
- template<typename A> void f(X<A, &m>); // expected-note {{candidate}}
- template<typename A, A B> void f(X<A, B>); // expected-note 2{{candidate}}
+ template<typename A> void f(X<A>);
+ template<typename A> void f(X<A, &m>);
+ template<typename A, A B> void f(X<A, B>);
template<template<typename U, U> class T, typename A, int *B> void f(T<A,
B>);
void g() {
- // FIXME: The first and second function templates above should be
- // considered more specialized than the third, but during partial
- // ordering we fail to check that we actually deduced template arguments
- // that make the deduced A identical to A.
- X<int *, &n> x; f(x); // expected-error {{ambiguous}}
- X<int *, &m> y; f(y); // expected-error {{ambiguous}}
+ X<int *, &n> x; f(x);
+ X<int *, &m> y; f(y);
}
}
diff --git a/clang/test/SemaTemplate/temp_arg_type.cpp
b/clang/test/SemaTemplate/temp_arg_type.cpp
index cdbcf281125ef..392d2573d3d0e 100644
--- a/clang/test/SemaTemplate/temp_arg_type.cpp
+++ b/clang/test/SemaTemplate/temp_arg_type.cpp
@@ -69,11 +69,10 @@ namespace deduce_noexcept {
void noexcept_function() noexcept;
void throwing_function();
- template<typename T, bool B> float &deduce_function(T(*)() noexcept(B)); //
expected-note {{candidate}}
- template<typename T> int &deduce_function(T(*)() noexcept); // expected-note
{{candidate}}
+ template<typename T, bool B> float &deduce_function(T(*)() noexcept(B));
+ template<typename T> int &deduce_function(T(*)() noexcept);
void test_function_deduction() {
- // FIXME: This should probably unambiguously select the second overload.
- int &r = deduce_function(noexcept_function); // expected-error
{{ambiguous}}
+ int &r = deduce_function(noexcept_function);
float &s = deduce_function(throwing_function);
}
diff --git a/clang/test/Templight/templight-empty-entries-fix.cpp
b/clang/test/Templight/templight-empty-entries-fix.cpp
index ad029d3070756..64b745adf1d7a 100644
--- a/clang/test/Templight/templight-empty-entries-fix.cpp
+++ b/clang/test/Templight/templight-empty-entries-fix.cpp
@@ -170,6 +170,78 @@ template <bool d = true, class = typename b<d>::c> void
a() { a(); }
template <bool = true> void d(int = 0) { d(); }
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+a$}}
+// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
+// CHECK: {{^event:[ ]+Begin$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:60:57'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:63'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+d$}}
+// CHECK: {{^kind:[ ]+DefaultTemplateArgumentInstantiation$}}
+// CHECK: {{^event:[ ]+Begin$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:60:16'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:57'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+d$}}
+// CHECK: {{^kind:[ ]+DefaultTemplateArgumentInstantiation$}}
+// CHECK: {{^event:[ ]+End$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:60:16'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:57'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+unnamed template type parameter 1 of a$}}
+// CHECK: {{^kind:[ ]+DefaultTemplateArgumentInstantiation$}}
+// CHECK: {{^event:[ ]+Begin$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:60:32'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:57'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+'b<1>'$}}
+// CHECK: {{^kind:[ ]+Memoization$}}
+// CHECK: {{^event:[ ]+Begin$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:59:23'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:43'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+'b<1>'$}}
+// CHECK: {{^kind:[ ]+Memoization$}}
+// CHECK: {{^event:[ ]+End$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:59:23'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:43'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+unnamed template type parameter 1 of a$}}
+// CHECK: {{^kind:[ ]+DefaultTemplateArgumentInstantiation$}}
+// CHECK: {{^event:[ ]+End$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:60:32'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:57'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+a$}}
+// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
+// CHECK: {{^event:[ ]+End$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:60:57'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:63'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+a$}}
+// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
+// CHECK: {{^event:[ ]+Begin$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:20:25'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:63'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+unnamed template non-type parameter 0 of a$}}
+// CHECK: {{^kind:[ ]+DefaultTemplateArgumentInstantiation$}}
+// CHECK: {{^event:[ ]+Begin$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:20:15'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:20:25'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+unnamed template non-type parameter 0 of a$}}
+// CHECK: {{^kind:[ ]+DefaultTemplateArgumentInstantiation$}}
+// CHECK: {{^event:[ ]+End$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:20:15'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:20:25'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+a$}}
+// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
+// CHECK: {{^event:[ ]+End$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:20:25'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:63'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
@@ -225,41 +297,41 @@ void e() {
}
// CHECK-LABEL: {{^---$}}
-// CHECK: {{^name:[ ]+'\(unnamed struct at
.*templight-empty-entries-fix.cpp:223:3\)'$}}
+// CHECK: {{^name:[ ]+'\(unnamed struct at
.*templight-empty-entries-fix.cpp:295:3\)'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:224:5'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:296:5'$}}
// CHECK-LABEL: {{^---$}}
-// CHECK: {{^name:[ ]+'\(unnamed struct at
.*templight-empty-entries-fix.cpp:223:3\)'$}}
+// CHECK: {{^name:[ ]+'\(unnamed struct at
.*templight-empty-entries-fix.cpp:295:3\)'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:224:5'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:296:5'$}}
// CHECK-LABEL: {{^---$}}
-// CHECK: {{^name:[ ]+'\(unnamed struct at
.*templight-empty-entries-fix.cpp:223:3\)'$}}
+// CHECK: {{^name:[ ]+'\(unnamed struct at
.*templight-empty-entries-fix.cpp:295:3\)'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:224:5'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:296:5'$}}
// CHECK-LABEL: {{^---$}}
-// CHECK: {{^name:[ ]+'\(unnamed struct at
.*templight-empty-entries-fix.cpp:223:3\)'$}}
+// CHECK: {{^name:[ ]+'\(unnamed struct at
.*templight-empty-entries-fix.cpp:295:3\)'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:224:5'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:296:5'$}}
// CHECK-LABEL: {{^---$}}
-// CHECK: {{^name:[ ]+'\(unnamed struct at
.*templight-empty-entries-fix.cpp:223:3\)'$}}
+// CHECK: {{^name:[ ]+'\(unnamed struct at
.*templight-empty-entries-fix.cpp:295:3\)'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
// CHECK-LABEL: {{^---$}}
-// CHECK: {{^name:[ ]+'\(unnamed struct at
.*templight-empty-entries-fix.cpp:223:3\)'$}}
+// CHECK: {{^name:[ ]+'\(unnamed struct at
.*templight-empty-entries-fix.cpp:295:3\)'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
template <template<typename> class>
@@ -275,59 +347,59 @@ void foo() {
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+ExplicitTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:266:6'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:338:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:343:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+unnamed template template parameter 0 of d$}}
// CHECK: {{^kind:[ ]+PriorTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:265:35'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:337:35'$}}
// CHECK: {{^poi:[ ]+''$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+unnamed template template parameter 0 of d$}}
// CHECK: {{^kind:[ ]+PriorTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:265:35'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:337:35'$}}
// CHECK: {{^poi:[ ]+''$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+ExplicitTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:266:6'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:338:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:343:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:266:6'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:338:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:343:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:266:6'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:338:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:343:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'d<C>'$}}
// CHECK: {{^kind:[ ]+TemplateInstantiation$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:266:6'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:338:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:343:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'d<C>'$}}
// CHECK: {{^kind:[ ]+TemplateInstantiation$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:266:6'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:338:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:343:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+ExplicitTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+Begin$}}
// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:171:29'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:343:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+ExplicitTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+End$}}
// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:171:29'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:343:3'$}}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
