[llvm-branch-commits] [clang] [clang] Finish implementation of P0522 (PR #96023)
Matheus Izvekov via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Jun 18 22:11:15 PDT 2024
https://github.com/mizvekov created https://github.com/llvm/llvm-project/pull/96023
This finishes the clang implementation of P0522, getting rid of the fallback to the old, pre-P0522 rules.
Before this patch, when partial ordering template template parameters, we would perform, in order:
* If the old rules would match, we would accept it. Otherwise, don't generate diagnostics yet.
* If the new rules would match, just accept it. Otherwise, don't generate any diagnostics yet again.
* Apply the old rules again, this time with diagnostics.
This situation was far from ideal, as we would sometimes:
* Accept some things we shouldn't.
* Reject some things we shouldn't.
* Only diagnose rejection in terms of the old rules.
With this patch, we apply the P0522 rules throughout.
This needed to extend template argument deduction in order to accept the historial rule for TTP matching pack parameter to non-pack arguments.
This change also makes us accept some combinations of historical and P0522 allowances we wouldn't before.
It also fixes a bunch of bugs that were documented in the test suite, which I am not sure there are issues already created for them.
This causes a lot of changes to the way these failures are diagnosed, with related test suite churn.
The problem here is that the old rules were very simple and non-recursive, making it easy to provide customized diagnostics, and to keep them consistent with each other.
The new rules are a lot more complex and rely on template argument deduction, substitutions, and they are recursive.
The approach taken here is to mostly rely on existing diagnostics, and create a new instantiation context that keeps track of things.
So for example when a substitution failure occurs, we use the error produced there unmodified, and just attach notes to it explaining that it occurred in the context of partial ordering this template argument against that template parameter.
This diverges from the old diagnostics, which would lead with an error pointing to the template argument, explain the problem in subsequent notes, and produce a final note pointing to the parameter.
>From 453df309b880468ded94fc8f2d670908e7bcb5c7 Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Mon, 17 Jun 2024 21:39:08 -0300
Subject: [PATCH] [clang] Finish implementation of P0522
This finishes the clang implementation of P0522, getting rid
of the fallback to the old, pre-P0522 rules.
Before this patch, when partial ordering template template parameters,
we would perform, in order:
* If the old rules would match, we would accept it. Otherwise, don't
generate diagnostics yet.
* If the new rules would match, just accept it. Otherwise, don't
generate any diagnostics yet again.
* Apply the old rules again, this time with diagnostics.
This situation was far from ideal, as we would sometimes:
* Accept some things we shouldn't.
* Reject some things we shouldn't.
* Only diagnose rejection in terms of the old rules.
With this patch, we apply the P0522 rules throughout.
This needed to extend template argument deduction in order
to accept the historial rule for TTP matching pack parameter to non-pack
arguments.
This change also makes us accept some combinations of historical and P0522
allowances we wouldn't before.
It also fixes a bunch of bugs that were documented in the test suite,
which I am not sure there are issues already created for them.
This causes a lot of changes to the way these failures are diagnosed,
with related test suite churn.
The problem here is that the old rules were very simple and
non-recursive, making it easy to provide customized diagnostics,
and to keep them consistent with each other.
The new rules are a lot more complex and rely on template argument
deduction, substitutions, and they are recursive.
The approach taken here is to mostly rely on existing diagnostics,
and create a new instantiation context that keeps track of this context.
So for example when a substitution failure occurs, we use the error
produced there unmodified, and just attach notes to it explaining
that it occurred in the context of partial ordering this template
argument against that template parameter.
This diverges from the old diagnostics, which would lead with an
error pointing to the template argument, explain the problem
in subsequent notes, and produce a final note pointing to the parameter.
---
clang/docs/ReleaseNotes.rst | 9 +-
.../clang/Basic/DiagnosticSemaKinds.td | 7 +
clang/include/clang/Sema/Sema.h | 14 +-
clang/lib/Frontend/FrontendActions.cpp | 2 +
clang/lib/Sema/SemaTemplate.cpp | 95 ++---
clang/lib/Sema/SemaTemplateDeduction.cpp | 341 +++++++++++++-----
clang/lib/Sema/SemaTemplateInstantiate.cpp | 15 +
.../temp/temp.arg/temp.arg.template/p3-0x.cpp | 31 +-
clang/test/CXX/temp/temp.param/p12.cpp | 21 +-
clang/test/Modules/cxx-templates.cpp | 15 +-
clang/test/SemaCXX/make_integer_seq.cpp | 5 +-
clang/test/SemaTemplate/cwg2398.cpp | 30 +-
clang/test/SemaTemplate/temp_arg_nontype.cpp | 45 +--
clang/test/SemaTemplate/temp_arg_template.cpp | 38 +-
.../SemaTemplate/temp_arg_template_p0522.cpp | 70 ++--
.../Templight/templight-empty-entries-fix.cpp | 12 +
.../templight-prior-template-arg.cpp | 33 +-
17 files changed, 505 insertions(+), 278 deletions(-)
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 7112d1f889fef..abe535f55fb2a 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -176,6 +176,8 @@ C++17 Feature Support
the values produced by GCC, so these macros should not be used from header
files because they may not be stable across multiple TUs (the values may vary
based on compiler version as well as CPU tuning). #GH60174
+- The implementation of the relaxed template template argument matching rules is
+ more complete and reliable, and should provide more accurate diagnostics.
C++14 Feature Support
^^^^^^^^^^^^^^^^^^^^^
@@ -589,6 +591,10 @@ Improvements to Clang's diagnostics
- Clang no longer emits a "declared here" note for a builtin function that has no declaration in source.
Fixes #GH93369.
+- Clang now properly explains the reason a template template argument failed to
+ match a template template parameter, in terms of the C++17 relaxed matching rules
+ instead of the old ones.
+
Improvements to Clang's time-trace
----------------------------------
@@ -887,7 +893,8 @@ Bug Fixes to C++ Support
between the addresses of two labels (a GNU extension) to a pointer within a constant expression. (#GH95366).
- Fix immediate escalation bugs in the presence of dependent call arguments. (#GH94935)
- Clang now diagnoses explicit specializations with storage class specifiers in all contexts.
-
+- Fixes to several issues in partial ordering of template template parameters, which
+ were documented in the test suite.
Bug Fixes to AST Handling
^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 14736784cff5f..397d10d4036f0 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -5207,6 +5207,13 @@ def note_template_arg_refers_here_func : Note<
def err_template_arg_template_params_mismatch : Error<
"template template argument has different template parameters than its "
"corresponding template template parameter">;
+def note_template_arg_template_params_mismatch : Note<
+ "template template argument has different template parameters than its "
+ "corresponding template template parameter">;
+def err_non_deduced_mismatch : Error<
+ "could not match %diff{$ against $|types}0,1">;
+def err_inconsistent_deduction : Error<
+ "conflicting deduction %diff{$ against $|types}0,1 for parameter">;
def err_template_arg_not_integral_or_enumeral : Error<
"non-type template argument of type %0 must have an integral or enumeration"
" type">;
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index a847fb8fe5500..7022da6dcee1d 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -9728,8 +9728,9 @@ class Sema final : public SemaBase {
sema::TemplateDeductionInfo &Info);
bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
- TemplateParameterList *PParam, TemplateDecl *AArg,
- const DefaultArguments &DefaultArgs, SourceLocation Loc, bool IsDeduced);
+ TemplateParameterList *PParam, TemplateDecl *PArg, TemplateDecl *AArg,
+ const DefaultArguments &DefaultArgs, SourceLocation ArgLoc,
+ bool IsDeduced);
void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced,
unsigned Depth, llvm::SmallBitVector &Used);
@@ -9934,6 +9935,9 @@ class Sema final : public SemaBase {
/// We are instantiating a type alias template declaration.
TypeAliasTemplateInstantiation,
+
+ /// We are performing partial ordering for template template parameters.
+ PartialOrderTTP,
} Kind;
/// Was the enclosing context a non-instantiation SFINAE context?
@@ -10155,6 +10159,12 @@ class Sema final : public SemaBase {
TemplateDecl *Entity, BuildingDeductionGuidesTag,
SourceRange InstantiationRange = SourceRange());
+ struct PartialOrderTTP {};
+ /// \brief Note that we are partial ordering template template parameters.
+ InstantiatingTemplate(Sema &SemaRef, SourceLocation ArgLoc, PartialOrderTTP,
+ TemplateDecl *PArg,
+ SourceRange InstantiationRange = SourceRange());
+
/// Note that we have finished instantiating this template.
void Clear();
diff --git a/clang/lib/Frontend/FrontendActions.cpp b/clang/lib/Frontend/FrontendActions.cpp
index 4f064321997a2..d31b704f186a6 100644
--- a/clang/lib/Frontend/FrontendActions.cpp
+++ b/clang/lib/Frontend/FrontendActions.cpp
@@ -456,6 +456,8 @@ class DefaultTemplateInstCallback : public TemplateInstantiationCallback {
return "BuildingDeductionGuides";
case CodeSynthesisContext::TypeAliasTemplateInstantiation:
return "TypeAliasTemplateInstantiation";
+ case CodeSynthesisContext::PartialOrderTTP:
+ return "PartialOrderTTP";
}
return "";
}
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 2296750cebc72..c9806afc1a32d 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -6652,8 +6652,7 @@ bool Sema::CheckTemplateArgumentList(
DefaultArgs && ParamIdx >= DefaultArgs.StartPos) {
// All written arguments should have been consumed by this point.
assert(ArgIdx == NumArgs && "bad default argument deduction");
- // FIXME: Don't ignore parameter packs.
- if (ParamIdx == DefaultArgs.StartPos && !(*Param)->isParameterPack()) {
+ if (ParamIdx == DefaultArgs.StartPos) {
assert(Param + DefaultArgs.Args.size() <= ParamEnd);
// Default arguments from a DeducedTemplateName are already converted.
for (const TemplateArgument &DefArg : DefaultArgs.Args) {
@@ -6897,8 +6896,9 @@ bool Sema::CheckTemplateArgumentList(
// pack expansions; they might be empty. This can happen even if
// PartialTemplateArgs is false (the list of arguments is complete but
// still dependent).
- if (ArgIdx < NumArgs && CurrentInstantiationScope &&
- CurrentInstantiationScope->getPartiallySubstitutedPack()) {
+ if (PartialOrderingTTP ||
+ (CurrentInstantiationScope &&
+ CurrentInstantiationScope->getPartiallySubstitutedPack())) {
while (ArgIdx < NumArgs &&
NewArgs[ArgIdx].getArgument().isPackExpansion()) {
const TemplateArgument &Arg = NewArgs[ArgIdx++].getArgument();
@@ -8513,64 +8513,49 @@ bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
<< Template;
}
+ if (!getLangOpts().RelaxedTemplateTemplateArgs)
+ return !TemplateParameterListsAreEqual(
+ Template->getTemplateParameters(), Params, /*Complain=*/true,
+ TPL_TemplateTemplateArgumentMatch, Arg.getLocation());
+
// C++1z [temp.arg.template]p3: (DR 150)
// A template-argument matches a template template-parameter P when P
// is at least as specialized as the template-argument A.
- if (getLangOpts().RelaxedTemplateTemplateArgs) {
- // Quick check for the common case:
- // If P contains a parameter pack, then A [...] matches P if each of A's
- // template parameters matches the corresponding template parameter in
- // the template-parameter-list of P.
- if (TemplateParameterListsAreEqual(
- Template->getTemplateParameters(), Params, false,
- TPL_TemplateTemplateArgumentMatch, Arg.getLocation()) &&
- // If the argument has no associated constraints, then the parameter is
- // definitely at least as specialized as the argument.
- // Otherwise - we need a more thorough check.
- !Template->hasAssociatedConstraints())
- return false;
- if (isTemplateTemplateParameterAtLeastAsSpecializedAs(
- Params, Template, DefaultArgs, Arg.getLocation(), IsDeduced)) {
- // P2113
- // C++20[temp.func.order]p2
- // [...] If both deductions succeed, the partial ordering selects the
- // more constrained template (if one exists) as determined below.
- SmallVector<const Expr *, 3> ParamsAC, TemplateAC;
- Params->getAssociatedConstraints(ParamsAC);
- // C++2a[temp.arg.template]p3
- // [...] In this comparison, if P is unconstrained, the constraints on A
- // are not considered.
- if (ParamsAC.empty())
- return false;
+ // FIXME: Create context for recursive diagnostics, in the PartialOrderingTTP
+ // case.
+ if (!isTemplateTemplateParameterAtLeastAsSpecializedAs(
+ Params, Param, Template, DefaultArgs, Arg.getLocation(), IsDeduced))
+ return true;
+ // P2113
+ // C++20[temp.func.order]p2
+ // [...] If both deductions succeed, the partial ordering selects the
+ // more constrained template (if one exists) as determined below.
+ SmallVector<const Expr *, 3> ParamsAC, TemplateAC;
+ Params->getAssociatedConstraints(ParamsAC);
+ // C++2a[temp.arg.template]p3
+ // [...] In this comparison, if P is unconstrained, the constraints on A
+ // are not considered.
+ if (ParamsAC.empty())
+ return false;
- Template->getAssociatedConstraints(TemplateAC);
+ Template->getAssociatedConstraints(TemplateAC);
- bool IsParamAtLeastAsConstrained;
- if (IsAtLeastAsConstrained(Param, ParamsAC, Template, TemplateAC,
- IsParamAtLeastAsConstrained))
- return true;
- if (!IsParamAtLeastAsConstrained) {
- Diag(Arg.getLocation(),
- diag::err_template_template_parameter_not_at_least_as_constrained)
- << Template << Param << Arg.getSourceRange();
- Diag(Param->getLocation(), diag::note_entity_declared_at) << Param;
- Diag(Template->getLocation(), diag::note_entity_declared_at)
- << Template;
- MaybeEmitAmbiguousAtomicConstraintsDiagnostic(Param, ParamsAC, Template,
- TemplateAC);
- return true;
- }
- return false;
- }
- // FIXME: Produce better diagnostics for deduction failures.
+ bool IsParamAtLeastAsConstrained;
+ if (IsAtLeastAsConstrained(Param, ParamsAC, Template, TemplateAC,
+ IsParamAtLeastAsConstrained))
+ return true;
+ if (!IsParamAtLeastAsConstrained) {
+ Diag(Arg.getLocation(),
+ diag::err_template_template_parameter_not_at_least_as_constrained)
+ << Template << Param << Arg.getSourceRange();
+ Diag(Param->getLocation(), diag::note_entity_declared_at) << Param;
+ Diag(Template->getLocation(), diag::note_entity_declared_at) << Template;
+ MaybeEmitAmbiguousAtomicConstraintsDiagnostic(Param, ParamsAC, Template,
+ TemplateAC);
+ return true;
}
-
- return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),
- Params,
- true,
- TPL_TemplateTemplateArgumentMatch,
- Arg.getLocation());
+ return false;
}
static Sema::SemaDiagnosticBuilder noteLocation(Sema &S, const NamedDecl &Decl,
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index 3efc3030fc261..cc9d54d35fda8 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -139,7 +139,7 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
bool PartialOrdering = false, bool DeducedFromArrayBound = false);
-enum class PackFold { ParameterToArgument, ArgumentToParameter };
+enum class PackFold { ParameterToArgument, ArgumentToParameter, Both };
static TemplateDeductionResult
DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
ArrayRef<TemplateArgument> Ps,
@@ -1640,7 +1640,18 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
DeducedTemplateArgument Result =
checkDeducedTemplateArguments(S.Context, Deduced[Index], NewDeduced);
if (Result.isNull()) {
- Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
+ // We can also get inconsistencies when matching NTTP type.
+ switch (NamedDecl *Param = TemplateParams->getParam(Index);
+ Param->getKind()) {
+ case Decl::TemplateTypeParm:
+ Info.Param = cast<TemplateTypeParmDecl>(Param);
+ break;
+ case Decl::NonTypeTemplateParm:
+ Info.Param = cast<NonTypeTemplateParmDecl>(Param);
+ break;
+ default:
+ llvm_unreachable("unexpected kind");
+ }
Info.FirstArg = Deduced[Index];
Info.SecondArg = NewDeduced;
return TemplateDeductionResult::Inconsistent;
@@ -2426,8 +2437,29 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
if (const NonTypeTemplateParmDecl *NTTP =
getDeducedParameterFromExpr(Info, P.getAsExpr())) {
switch (A.getKind()) {
+ case TemplateArgument::Expression: {
+ const Expr *E = A.getAsExpr();
+ // When checking NTTP, if either the parameter or the argument is
+ // dependent, as there would be otherwise nothing to deduce, we force
+ // the argument to the parameter type using this dependent implicit
+ // cast, in order to maintain invariants. Now we can deduce the
+ // resulting type from the original type, and deduce the original type
+ // against the parameter we are checking.
+ if (const auto *ICE = dyn_cast<ImplicitCastExpr>(E);
+ ICE && ICE->getCastKind() == clang::CK_Dependent) {
+ E = ICE->getSubExpr();
+ if (auto Result = DeduceTemplateArgumentsByTypeMatch(
+ S, TemplateParams, ICE->getType(), E->getType(), Info,
+ Deduced, TDF_SkipNonDependent, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false);
+ Result != TemplateDeductionResult::Success)
+ return Result;
+ }
+ return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+ DeducedTemplateArgument(A),
+ E->getType(), Info, Deduced);
+ }
case TemplateArgument::Integral:
- case TemplateArgument::Expression:
case TemplateArgument::StructuralValue:
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, DeducedTemplateArgument(A),
@@ -2513,49 +2545,76 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool NumberOfArgumentsMustMatch, PackFold PackFold) {
- if (PackFold == PackFold::ArgumentToParameter)
- std::swap(Ps, As);
+ bool FoldPackParameter = PackFold == PackFold::ParameterToArgument ||
+ PackFold == PackFold::Both,
+ FoldPackArgument = PackFold == PackFold::ArgumentToParameter ||
+ PackFold == PackFold::Both;
+
// C++0x [temp.deduct.type]p9:
// If the template argument list of P contains a pack expansion that is not
// the last template argument, the entire template argument list is a
// non-deduced context.
- if (hasPackExpansionBeforeEnd(Ps))
+ if (FoldPackParameter && hasPackExpansionBeforeEnd(Ps))
+ return TemplateDeductionResult::Success;
+
+ if (FoldPackArgument && hasPackExpansionBeforeEnd(As))
return TemplateDeductionResult::Success;
// C++0x [temp.deduct.type]p9:
// If P has a form that contains <T> or <i>, then each argument Pi of the
// respective template argument list P is compared with the corresponding
// argument Ai of the corresponding template argument list of A.
- unsigned ArgIdx = 0, ParamIdx = 0;
- for (; hasTemplateArgumentForDeduction(Ps, ParamIdx); ++ParamIdx) {
- const TemplateArgument &P = Ps[ParamIdx];
- if (!P.isPackExpansion()) {
+ for (unsigned ArgIdx = 0, ParamIdx = 0; /**/; /**/) {
+ if (!hasTemplateArgumentForDeduction(Ps, ParamIdx))
+ return !FoldPackParameter && NumberOfArgumentsMustMatch &&
+ hasTemplateArgumentForDeduction(As, ArgIdx) &&
+ !As[ArgIdx].isPackExpansion()
+ ? TemplateDeductionResult::MiscellaneousDeductionFailure
+ : TemplateDeductionResult::Success;
+
+ if (!Ps[ParamIdx].isPackExpansion()) {
// The simple case: deduce template arguments by matching Pi and Ai.
// Check whether we have enough arguments.
if (!hasTemplateArgumentForDeduction(As, ArgIdx))
- return NumberOfArgumentsMustMatch
+ return !FoldPackArgument && NumberOfArgumentsMustMatch
? TemplateDeductionResult::MiscellaneousDeductionFailure
: TemplateDeductionResult::Success;
- // C++1z [temp.deduct.type]p9:
- // During partial ordering, if Ai was originally a pack expansion [and]
- // Pi is not a pack expansion, template argument deduction fails.
- if (As[ArgIdx].isPackExpansion())
- return TemplateDeductionResult::MiscellaneousDeductionFailure;
+ if (As[ArgIdx].isPackExpansion()) {
+ // C++1z [temp.deduct.type]p9:
+ // During partial ordering, if Ai was originally a pack expansion
+ // [and] Pi is not a pack expansion, template argument deduction
+ // fails.
+ if (!FoldPackArgument)
+ return TemplateDeductionResult::MiscellaneousDeductionFailure;
+
+ for (TemplateArgument Pattern = As[ArgIdx].getPackExpansionPattern();
+ /**/;
+ /**/) {
+ // Deduce template parameters from the pattern.
+ if (auto Result = DeduceTemplateArguments(
+ S, TemplateParams, Ps[ParamIdx], Pattern, Info, Deduced);
+ Result != TemplateDeductionResult::Success)
+ return Result;
- // Perform deduction for this Pi/Ai pair.
- TemplateArgument Pi = P, Ai = As[ArgIdx];
- if (PackFold == PackFold::ArgumentToParameter)
- std::swap(Pi, Ai);
- if (auto Result =
- DeduceTemplateArguments(S, TemplateParams, Pi, Ai, Info, Deduced);
- Result != TemplateDeductionResult::Success)
- return Result;
+ ++ParamIdx;
+ if (!hasTemplateArgumentForDeduction(Ps, ParamIdx))
+ return TemplateDeductionResult::Success;
+ if (Ps[ParamIdx].isPackExpansion())
+ break;
+ }
+ } else {
+ // Perform deduction for this Pi/Ai pair.
+ if (auto Result = DeduceTemplateArguments(
+ S, TemplateParams, Ps[ParamIdx], As[ArgIdx], Info, Deduced);
+ Result != TemplateDeductionResult::Success)
+ return Result;
- // Move to the next argument.
- ++ArgIdx;
- continue;
+ ++ArgIdx;
+ ++ParamIdx;
+ continue;
+ }
}
// The parameter is a pack expansion.
@@ -2565,7 +2624,7 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
// each remaining argument in the template argument list of A. Each
// comparison deduces template arguments for subsequent positions in the
// template parameter packs expanded by Pi.
- TemplateArgument Pattern = P.getPackExpansionPattern();
+ TemplateArgument Pattern = Ps[ParamIdx].getPackExpansionPattern();
// Prepare to deduce the packs within the pattern.
PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
@@ -2576,12 +2635,11 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
for (; hasTemplateArgumentForDeduction(As, ArgIdx) &&
PackScope.hasNextElement();
++ArgIdx) {
- TemplateArgument Pi = Pattern, Ai = As[ArgIdx];
- if (PackFold == PackFold::ArgumentToParameter)
- std::swap(Pi, Ai);
+ if (!FoldPackParameter && !As[ArgIdx].isPackExpansion())
+ return TemplateDeductionResult::MiscellaneousDeductionFailure;
// Deduce template arguments from the pattern.
- if (auto Result =
- DeduceTemplateArguments(S, TemplateParams, Pi, Ai, Info, Deduced);
+ if (auto Result = DeduceTemplateArguments(S, TemplateParams, Pattern,
+ As[ArgIdx], Info, Deduced);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2590,12 +2648,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
// Build argument packs for each of the parameter packs expanded by this
// pack expansion.
- if (auto Result = PackScope.finish();
- Result != TemplateDeductionResult::Success)
- return Result;
+ return PackScope.finish();
}
-
- return TemplateDeductionResult::Success;
}
TemplateDeductionResult Sema::DeduceTemplateArguments(
@@ -3168,7 +3222,6 @@ static TemplateDeductionResult FinishTemplateArgumentDeduction(
// Unevaluated SFINAE context.
EnterExpressionEvaluationContext Unevaluated(
S, Sema::ExpressionEvaluationContext::Unevaluated);
- Sema::SFINAETrap Trap(S);
Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(Template));
@@ -3186,20 +3239,36 @@ static TemplateDeductionResult FinishTemplateArgumentDeduction(
// Check that we produced the correct argument list.
TemplateParameterList *TemplateParams = Template->getTemplateParameters();
+ auto notSame = [&](unsigned I, const TemplateArgument &P,
+ const TemplateArgument &A) {
+ if (isSameTemplateArg(S.Context, P, A, PartialOrdering,
+ /*PackExpansionMatchesPack=*/true))
+ return false;
+ Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
+ Info.FirstArg = P;
+ Info.SecondArg = A;
+ return true;
+ };
for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
- TemplateArgument InstArg = CanonicalBuilder[I];
- if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg, PartialOrdering,
- /*PackExpansionMatchesPack=*/true)) {
- Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
- Info.FirstArg = TemplateArgs[I];
- Info.SecondArg = InstArg;
- return TemplateDeductionResult::NonDeducedMismatch;
+ const TemplateArgument &P = TemplateArgs[I];
+ if (P.isPackExpansion()) {
+ assert(I == TemplateArgs.size() - 1);
+ for (/**/; I != E; ++I) {
+ const TemplateArgument &A = CanonicalBuilder[I];
+ if (A.getKind() == TemplateArgument::Pack) {
+ for (const TemplateArgument &Ai : A.getPackAsArray())
+ if (notSame(I, P, Ai))
+ return TemplateDeductionResult::NonDeducedMismatch;
+ } else if (notSame(I, P, A)) {
+ return TemplateDeductionResult::NonDeducedMismatch;
+ }
+ }
+ break;
}
+ if (notSame(I, P, CanonicalBuilder[I]))
+ return TemplateDeductionResult::NonDeducedMismatch;
}
- if (Trap.hasErrorOccurred())
- return TemplateDeductionResult::SubstitutionFailure;
-
if (auto Result = CheckDeducedArgumentConstraints(S, Template, SugaredBuilder,
CanonicalBuilder, Info);
Result != TemplateDeductionResult::Success)
@@ -3217,7 +3286,6 @@ static TemplateDeductionResult FinishTemplateArgumentDeduction(
// Unevaluated SFINAE context.
EnterExpressionEvaluationContext Unevaluated(
S, Sema::ExpressionEvaluationContext::Unevaluated);
- Sema::SFINAETrap Trap(S);
Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(TD));
@@ -3226,20 +3294,13 @@ static TemplateDeductionResult FinishTemplateArgumentDeduction(
// explicitly specified, template argument deduction fails.
SmallVector<TemplateArgument, 4> SugaredBuilder, CanonicalBuilder;
if (auto Result = ConvertDeducedTemplateArguments(
- S, TD, /*IsPartialOrdering=*/false, Deduced, Info, SugaredBuilder,
+ S, TD, /*IsDeduced=*/false, Deduced, Info, SugaredBuilder,
CanonicalBuilder);
Result != TemplateDeductionResult::Success)
return Result;
- if (Trap.hasErrorOccurred())
- return TemplateDeductionResult::SubstitutionFailure;
-
- if (auto Result = CheckDeducedArgumentConstraints(S, TD, SugaredBuilder,
- CanonicalBuilder, Info);
- Result != TemplateDeductionResult::Success)
- return Result;
-
- return TemplateDeductionResult::Success;
+ return ::CheckDeducedArgumentConstraints(S, TD, SugaredBuilder,
+ CanonicalBuilder, Info);
}
/// Perform template argument deduction to determine whether the given template
@@ -3284,16 +3345,20 @@ DeduceTemplateArguments(Sema &S, T *Partial,
if (Inst.isInvalid())
return TemplateDeductionResult::InstantiationDepth;
- if (Trap.hasErrorOccurred())
- return TemplateDeductionResult::SubstitutionFailure;
-
TemplateDeductionResult Result;
S.runWithSufficientStackSpace(Info.getLocation(), [&] {
Result = ::FinishTemplateArgumentDeduction(S, Partial,
/*IsPartialOrdering=*/false,
TemplateArgs, Deduced, Info);
});
- return Result;
+
+ if (Result != TemplateDeductionResult::Success)
+ return Result;
+
+ if (Trap.hasErrorOccurred())
+ return TemplateDeductionResult::SubstitutionFailure;
+
+ return TemplateDeductionResult::Success;
}
TemplateDeductionResult
@@ -3351,14 +3416,18 @@ Sema::DeduceTemplateArgumentsFromType(TemplateDecl *TD, QualType FromType,
if (Inst.isInvalid())
return TemplateDeductionResult::InstantiationDepth;
- if (Trap.hasErrorOccurred())
- return TemplateDeductionResult::SubstitutionFailure;
-
TemplateDeductionResult Result;
runWithSufficientStackSpace(Info.getLocation(), [&] {
Result = ::FinishTemplateArgumentDeduction(*this, TD, Deduced, Info);
});
- return Result;
+
+ if (Result != TemplateDeductionResult::Success)
+ return Result;
+
+ if (Trap.hasErrorOccurred())
+ return TemplateDeductionResult::SubstitutionFailure;
+
+ return TemplateDeductionResult::Success;
}
/// Determine whether the given type T is a simple-template-id type.
@@ -6038,14 +6107,23 @@ static bool isAtLeastAsSpecializedAs(Sema &S, QualType T1, QualType T2,
return false;
const auto *TST1 = cast<TemplateSpecializationType>(T1);
- bool AtLeastAsSpecialized;
+
+ Sema::SFINAETrap Trap(S);
+
+ TemplateDeductionResult Result;
S.runWithSufficientStackSpace(Info.getLocation(), [&] {
- AtLeastAsSpecialized =
- FinishTemplateArgumentDeduction(
- S, P2, /*IsPartialOrdering=*/true, TST1->template_arguments(),
- Deduced, Info) == TemplateDeductionResult::Success;
+ Result = ::FinishTemplateArgumentDeduction(
+ S, P2, /*IsPartialOrdering=*/true, TST1->template_arguments(), Deduced,
+ Info);
});
- return AtLeastAsSpecialized;
+
+ if (Result != TemplateDeductionResult::Success)
+ return false;
+
+ if (Trap.hasErrorOccurred())
+ return false;
+
+ return true;
}
namespace {
@@ -6295,8 +6373,9 @@ bool Sema::isMoreSpecializedThanPrimary(
}
bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
- TemplateParameterList *P, TemplateDecl *AArg,
- const DefaultArguments &DefaultArgs, SourceLocation Loc, bool IsDeduced) {
+ TemplateParameterList *P, TemplateDecl *PArg, TemplateDecl *AArg,
+ const DefaultArguments &DefaultArgs, SourceLocation ArgLoc,
+ bool IsDeduced) {
// 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
@@ -6308,6 +6387,12 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
//
TemplateParameterList *A = AArg->getTemplateParameters();
+ Sema::InstantiatingTemplate Inst(
+ *this, ArgLoc, Sema::InstantiatingTemplate::PartialOrderTTP(), PArg,
+ SourceRange(P->getTemplateLoc(), P->getRAngleLoc()));
+ if (Inst.isInvalid())
+ return false;
+
// Given an invented class template X with the template parameter list of
// A (including default arguments):
// - Each function template has a single function parameter whose type is
@@ -6322,8 +6407,6 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
// templates.
SmallVector<TemplateArgument, 4> PArgs;
{
- SFINAETrap Trap(*this);
-
Context.getInjectedTemplateArgs(P, PArgs);
TemplateArgumentListInfo PArgList(P->getLAngleLoc(),
P->getRAngleLoc());
@@ -6343,18 +6426,17 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
// C++1z [temp.arg.template]p3:
// If the rewrite produces an invalid type, then P is not at least as
// specialized as A.
- SmallVector<TemplateArgument, 4> SugaredPArgs;
- if (CheckTemplateArgumentList(AArg, Loc, PArgList, DefaultArgs, false,
- SugaredPArgs, PArgs,
+ SmallVector<TemplateArgument, 4> CanonicalPArgs;
+ if (CheckTemplateArgumentList(AArg, ArgLoc, PArgList, DefaultArgs, false,
+ PArgs, CanonicalPArgs,
/*UpdateArgsWithConversions=*/true,
/*ConstraintsNotSatisfied=*/nullptr,
- /*PartialOrderTTP=*/true) ||
- Trap.hasErrorOccurred())
+ /*PartialOrderTTP=*/true))
return false;
}
// Determine whether P1 is at least as specialized as P2.
- TemplateDeductionInfo Info(Loc, A->getDepth());
+ TemplateDeductionInfo Info(ArgLoc, A->getDepth());
SmallVector<DeducedTemplateArgument, 4> Deduced;
Deduced.resize(A->size());
@@ -6369,27 +6451,88 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
// be inverted between Ps and As. On non-deduced context, matching needs to
// happen both ways, according to [temp.arg.template]p3, but this is
// currently implemented as a special case elsewhere.
- if (::DeduceTemplateArguments(*this, A, AArgs, PArgs, Info, Deduced,
- /*NumberOfArgumentsMustMatch=*/false,
- IsDeduced ? PackFold::ArgumentToParameter
- : PackFold::ParameterToArgument) !=
- TemplateDeductionResult::Success)
+ switch (TemplateDeductionResult Result = ::DeduceTemplateArguments(
+ *this, A, AArgs, PArgs, Info, Deduced,
+ /*NumberOfArgumentsMustMatch=*/false,
+ IsDeduced ? PackFold::ArgumentToParameter : PackFold::Both)) {
+ case clang::TemplateDeductionResult::Success:
+ break;
+
+ case TemplateDeductionResult::MiscellaneousDeductionFailure:
+ Diag(AArg->getLocation(), diag::err_template_param_list_different_arity)
+ << (A->size() > P->size()) << /*isTemplateTemplateParameter=*/true
+ << SourceRange(A->getTemplateLoc(), P->getRAngleLoc());
+ return false;
+ case TemplateDeductionResult::NonDeducedMismatch:
+ Diag(AArg->getLocation(), diag::err_non_deduced_mismatch)
+ << Info.FirstArg << Info.SecondArg;
+ return false;
+ case TemplateDeductionResult::Inconsistent:
+ Diag(getAsNamedDecl(Info.Param)->getLocation(),
+ diag::err_inconsistent_deduction)
+ << Info.FirstArg << Info.SecondArg;
+ return false;
+ case TemplateDeductionResult::AlreadyDiagnosed:
return false;
+ // None of these should happen for a plain deduction.
+ case TemplateDeductionResult::Invalid:
+ case TemplateDeductionResult::InstantiationDepth:
+ case TemplateDeductionResult::Incomplete:
+ case TemplateDeductionResult::IncompletePack:
+ case TemplateDeductionResult::Underqualified:
+ case TemplateDeductionResult::SubstitutionFailure:
+ case TemplateDeductionResult::DeducedMismatch:
+ case TemplateDeductionResult::DeducedMismatchNested:
+ case TemplateDeductionResult::TooManyArguments:
+ case TemplateDeductionResult::TooFewArguments:
+ case TemplateDeductionResult::InvalidExplicitArguments:
+ case TemplateDeductionResult::NonDependentConversionFailure:
+ case TemplateDeductionResult::ConstraintsNotSatisfied:
+ case TemplateDeductionResult::CUDATargetMismatch:
+ llvm_unreachable("Unexpected Result");
+ }
+
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
- Sema::InstantiatingTemplate Inst(*this, Info.getLocation(), AArg, DeducedArgs,
- Info);
- if (Inst.isInvalid())
- return false;
- bool AtLeastAsSpecialized;
+ TemplateDeductionResult TDK;
runWithSufficientStackSpace(Info.getLocation(), [&] {
- AtLeastAsSpecialized =
- ::FinishTemplateArgumentDeduction(
- *this, AArg, /*IsPartialOrdering=*/true, PArgs, Deduced, Info) ==
- TemplateDeductionResult::Success;
+ TDK = ::FinishTemplateArgumentDeduction(
+ *this, AArg, /*IsPartialOrdering=*/true, PArgs, Deduced, Info);
});
- return AtLeastAsSpecialized;
+ switch (TDK) {
+ case TemplateDeductionResult::Success:
+ return true;
+
+ // It doesn't seem possible to get a non-deduced mismatch when partial
+ // ordering TTPs.
+ case TemplateDeductionResult::NonDeducedMismatch:
+ llvm_unreachable("Unexpected NonDeducedMismatch");
+
+ // Substitution failures should have already been diagnosed.
+ case TemplateDeductionResult::AlreadyDiagnosed:
+ case TemplateDeductionResult::SubstitutionFailure:
+ case TemplateDeductionResult::InstantiationDepth:
+ return false;
+
+ // None of these should happen when just converting deduced arguments.
+ case TemplateDeductionResult::Invalid:
+ case TemplateDeductionResult::Incomplete:
+ case TemplateDeductionResult::IncompletePack:
+ case TemplateDeductionResult::Inconsistent:
+ case TemplateDeductionResult::Underqualified:
+ case TemplateDeductionResult::DeducedMismatch:
+ case TemplateDeductionResult::DeducedMismatchNested:
+ case TemplateDeductionResult::TooManyArguments:
+ case TemplateDeductionResult::TooFewArguments:
+ case TemplateDeductionResult::InvalidExplicitArguments:
+ case TemplateDeductionResult::NonDependentConversionFailure:
+ case TemplateDeductionResult::ConstraintsNotSatisfied:
+ case TemplateDeductionResult::MiscellaneousDeductionFailure:
+ case TemplateDeductionResult::CUDATargetMismatch:
+ llvm_unreachable("Unexpected Result");
+ }
+ llvm_unreachable("Unexpected TDK");
}
namespace {
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 863cc53c55afa..ddea395719f91 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -598,6 +598,7 @@ bool Sema::CodeSynthesisContext::isInstantiationRecord() const {
case LambdaExpressionSubstitution:
case BuildingDeductionGuides:
case TypeAliasTemplateInstantiation:
+ case PartialOrderTTP:
return false;
// This function should never be called when Kind's value is Memoization.
@@ -830,6 +831,11 @@ Sema::InstantiatingTemplate::InstantiatingTemplate(
SemaRef, CodeSynthesisContext::BuildingDeductionGuides,
PointOfInstantiation, InstantiationRange, Entity) {}
+Sema::InstantiatingTemplate::InstantiatingTemplate(
+ Sema &SemaRef, SourceLocation ArgLoc, PartialOrderTTP, TemplateDecl *PArg,
+ SourceRange InstantiationRange)
+ : InstantiatingTemplate(SemaRef, CodeSynthesisContext::PartialOrderTTP,
+ ArgLoc, InstantiationRange, PArg) {}
void Sema::pushCodeSynthesisContext(CodeSynthesisContext Ctx) {
Ctx.SavedInNonInstantiationSFINAEContext = InNonInstantiationSFINAEContext;
@@ -1272,6 +1278,14 @@ void Sema::PrintInstantiationStack() {
<< cast<TypeAliasTemplateDecl>(Active->Entity)
<< Active->InstantiationRange;
break;
+ case CodeSynthesisContext::PartialOrderTTP:
+ Diags.Report(Active->PointOfInstantiation,
+ diag::note_template_arg_template_params_mismatch);
+ if (SourceLocation ParamLoc = Active->Entity->getLocation();
+ ParamLoc.isValid())
+ Diags.Report(ParamLoc, diag::note_template_prev_declaration)
+ << /*isTemplateTemplateParam=*/true << Active->InstantiationRange;
+ break;
}
}
}
@@ -1314,6 +1328,7 @@ std::optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const {
case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
case CodeSynthesisContext::DefaultTemplateArgumentChecking:
case CodeSynthesisContext::RewritingOperatorAsSpaceship:
+ case CodeSynthesisContext::PartialOrderTTP:
// A default template argument instantiation and substitution into
// template parameters with arguments for prior parameters may or may
// not be a SFINAE context; look further up the stack.
diff --git a/clang/test/CXX/temp/temp.arg/temp.arg.template/p3-0x.cpp b/clang/test/CXX/temp/temp.arg/temp.arg.template/p3-0x.cpp
index 51489c5eac5ad..408674edf0fc5 100644
--- a/clang/test/CXX/temp/temp.arg/temp.arg.template/p3-0x.cpp
+++ b/clang/test/CXX/temp/temp.arg/temp.arg.template/p3-0x.cpp
@@ -2,13 +2,13 @@
template <class T> struct eval; // expected-note 3{{template is declared here}}
-template <template <class, class...> class TT, class T1, class... Rest>
+template <template <class, class...> class TT, class T1, class... Rest>
struct eval<TT<T1, Rest...>> { };
-template <class T1> struct A;
-template <class T1, class T2> struct B;
-template <int N> struct C;
-template <class T1, int N> struct D;
+template <class T1> struct A;
+template <class T1, class T2> struct B;
+template <int N> struct C;
+template <class T1, int N> struct D;
template <class T1, class T2, int N = 17> struct E;
eval<A<int>> eA;
@@ -17,24 +17,29 @@ eval<C<17>> eC; // expected-error{{implicit instantiation of undefined template
eval<D<int, 17>> eD; // expected-error{{implicit instantiation of undefined template 'eval<D<int, 17>>'}}
eval<E<int, float>> eE; // expected-error{{implicit instantiation of undefined template 'eval<E<int, float>>}}
-template<template <int ...N> class TT> struct X0 { }; // expected-note{{previous non-type template parameter with type 'int' is here}}
+template<
+ template <int ...N> // expected-error{{deduced non-type template argument does not have the same type as the corresponding template parameter ('int' vs 'long')}}
+ class TT // expected-note {{previous template template parameter is here}}
+> struct X0 { };
+
template<int I, int J, int ...Rest> struct X0a;
template<int ...Rest> struct X0b;
-template<int I, long J> struct X0c; // expected-note{{template non-type parameter has a different type 'long' in template argument}}
+template<int I, long J> struct X0c; // expected-note{{template parameter is declared here}}
X0<X0a> inst_x0a;
X0<X0b> inst_x0b;
-X0<X0c> inst_x0c; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
+X0<X0c> inst_x0c; // expected-note{{template template argument has different template parameters than its corresponding template template parameter}}
-template<typename T,
- template <T ...N> class TT> // expected-note{{previous non-type template parameter with type 'short' is here}}
-struct X1 { };
+template<typename T,
+ template <T ...N> // expected-error{{deduced non-type template argument does not have the same type as the corresponding template parameter ('short' vs 'long')}}
+ class TT // expected-note {{previous template template parameter is here}}
+> struct X1 { };
template<int I, int J, int ...Rest> struct X1a;
template<long I, long ...Rest> struct X1b;
template<short I, short J> struct X1c;
-template<short I, long J> struct X1d; // expected-note{{template non-type parameter has a different type 'long' in template argument}}
+template<short I, long J> struct X1d; // expected-note{{template parameter is declared here}}
X1<int, X1a> inst_x1a;
X1<long, X1b> inst_x1b;
X1<short, X1c> inst_x1c;
-X1<short, X1d> inst_x1d; // expected-error{{template template argument has different template parameters than its corresponding template template paramete}}
+X1<short, X1d> inst_x1d; // expected-note{{template template argument has different template parameters than its corresponding template template paramete}}
diff --git a/clang/test/CXX/temp/temp.param/p12.cpp b/clang/test/CXX/temp/temp.param/p12.cpp
index 7be38790905fa..8317e7f24152c 100644
--- a/clang/test/CXX/temp/temp.param/p12.cpp
+++ b/clang/test/CXX/temp/temp.param/p12.cpp
@@ -1,39 +1,40 @@
-// RUN: %clang_cc1 -fsyntax-only -verify %s
-template<typename> struct Y1; // expected-note{{too few template parameters in template template argument}}
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename> struct Y1; // expected-note{{template is declared here}}
template<typename, int> struct Y2;
// C++ [temp.param]p12:
-template<class T1,
+template<class T1,
class T2 = int> // expected-note{{previous default template argument defined here}}
class B3;
template<class T1, typename T2> class B3;
-template<class T1,
+template<class T1,
typename T2 = float> // expected-error{{template parameter redefines default argument}}
class B3;
-template<template<class, int> class,
+template<template<class, int> class,
template<class> class = Y1> // expected-note{{previous default template argument defined here}}
class B3t;
template<template<class, int> class, template<class> class> class B3t;
-template<template<class, int> class,
+template<template<class, int> class,
template<class> class = Y1> // expected-error{{template parameter redefines default argument}}
class B3t;
-template<int N,
+template<int N,
int M = 5> // expected-note{{previous default template argument defined here}}
class B3n;
template<int N, int M> class B3n;
-template<int N,
+template<int N,
int M = 7> // expected-error{{template parameter redefines default argument}}
class B3n;
// Check validity of default arguments
-template<template<class, int> class // expected-note{{previous template template parameter is here}}
- = Y1> // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
+template<template<class, int> class =// expected-note {{previous template template parameter is here}}
+ Y1> // expected-error{{too many template arguments for class template 'Y1'}}
+ // expected-note at -1 {{template template argument has different template parameters than its corresponding template template parameter}}
class C1 {};
C1<> c1; // expected-note{{while checking a default template argument}}
diff --git a/clang/test/Modules/cxx-templates.cpp b/clang/test/Modules/cxx-templates.cpp
index b7d5741e69af6..953fc0d9e867c 100644
--- a/clang/test/Modules/cxx-templates.cpp
+++ b/clang/test/Modules/cxx-templates.cpp
@@ -40,23 +40,14 @@ void g() {
template_param_kinds_1<0>(); // ok, from cxx-templates-a.h
template_param_kinds_1<int>(); // ok, from cxx-templates-b.h
-
- template_param_kinds_2<Tmpl_T_C>(); // expected-error {{no matching function}}
- // expected-note at Inputs/cxx-templates-a.h:11 {{invalid explicitly-specified argument}}
- // expected-note at Inputs/cxx-templates-b.h:11 {{invalid explicitly-specified argument}}
+ template_param_kinds_2<Tmpl_T_C>(); // ok, from cxx-templates-b.h
template_param_kinds_2<Tmpl_T_I_I>(); // expected-error {{ambiguous}}
// expected-note at Inputs/cxx-templates-a.h:11 {{candidate}}
// expected-note at Inputs/cxx-templates-b.h:11 {{candidate}}
- // FIXME: This should be valid, but we incorrectly match the template template
- // argument against both template template parameters.
- template_param_kinds_3<Tmpl_T_T_A>(); // expected-error {{ambiguous}}
- // expected-note at Inputs/cxx-templates-a.h:12 {{candidate}}
- // expected-note at Inputs/cxx-templates-b.h:12 {{candidate}}
- template_param_kinds_3<Tmpl_T_T_B>(); // expected-error {{ambiguous}}
- // expected-note at Inputs/cxx-templates-a.h:12 {{candidate}}
- // expected-note at Inputs/cxx-templates-b.h:12 {{candidate}}
+ template_param_kinds_3<Tmpl_T_T_A>();
+ template_param_kinds_3<Tmpl_T_T_B>();
// Trigger the instantiation of a template in 'a' that uses a type defined in
// 'common'. That type is not visible here.
diff --git a/clang/test/SemaCXX/make_integer_seq.cpp b/clang/test/SemaCXX/make_integer_seq.cpp
index 8f72ce15eef47..71b7b8260d4ab 100644
--- a/clang/test/SemaCXX/make_integer_seq.cpp
+++ b/clang/test/SemaCXX/make_integer_seq.cpp
@@ -48,6 +48,5 @@ using illformed2 = ErrorSeq<int, -5>; // expected-note{{in instantiation}}
template <typename T, T N> void f() {}
__make_integer_seq<f, int, 0> x; // expected-error{{template template parameter must be a class template or type alias template}}
-__make_integer_seq<__make_integer_seq, int, 10> PR28494; // expected-error{{different template parameters}}
-// expected-note at make_integer_seq.cpp:* {{template parameter has a different kind}}
-// expected-note at make_integer_seq.cpp:* {{previous template template parameter is here}}
+__make_integer_seq<__make_integer_seq, int, 10> PR28494; // expected-note{{different template parameters}}
+// expected-error at make_integer_seq.cpp:* {{template argument for template template parameter must be a class template or type alias template}}
diff --git a/clang/test/SemaTemplate/cwg2398.cpp b/clang/test/SemaTemplate/cwg2398.cpp
index 51a7c7b3612e4..06d89eaf116d9 100644
--- a/clang/test/SemaTemplate/cwg2398.cpp
+++ b/clang/test/SemaTemplate/cwg2398.cpp
@@ -94,12 +94,13 @@ namespace type_pack3 {
template<class T3> struct B;
template<template<class T4 > class TT1, class T5 > struct B<TT1<T5 >>;
- // new-note at -1 {{template is declared here}}
- template<template<class T6, class ...T7s> class TT2, class T8, class ...T9s> struct B<TT2<T8, T9s...>>;
- // old-note at -1 {{template is declared here}}
+ // new-note at -1 {{partial specialization matches}}
+
+ template<template<class T6, class ...T7s> class TT2, class T8, class ...T9s> struct B<TT2<T8, T9s...>> {};
+ // new-note at -1 {{partial specialization matches}}
template struct B<A<int>>;
- // expected-error at -1 {{explicit instantiation of undefined template}}
+ // new-error at -1 {{ambiguous partial specializations of 'B<type_pack3::A<int>>'}}
} // namespace type_pack3
namespace gcc_issue {
@@ -301,12 +302,14 @@ namespace classes {
};
template <template <class T3> class TT> void f(TT<int> v) {
- // old-note at -1 {{template template argument has different template parameters}}
- // new-note at -2 {{deduced type 'A<[...], (no argument), (no argument), (no argument)>' of 1st parameter does not match adjusted type 'A<[...], void, void, void>' of argument [with TT = A:1<void, void, void>]}}
+ // new-note at -1 {{substitution failure: too many template parameters in template template parameter}}
+ // old-note at -2 {{template template argument has different template parameters}}
static_assert(v.val == 3);
};
void test() {
- // FIXME: Needs deduction of defaulted template parameter packs.
+ // FIXME: We incorrectly reject the pack to non-pack matching.
+ // This should apply the same rules as directly specifying the arguments,
+ // but the partial ordering rules are applied instead.
f(A<int, void, void, void>());
// expected-error at -1 {{no matching function for call}}
}
@@ -352,6 +355,19 @@ namespace classes {
} // namespace defaulted
} // namespace classes
+namespace packs {
+ namespace t1 {
+ template<template<class, int, int...> class> struct A {};
+ // old-note at -1 {{previous non-type template parameter with type 'int' is here}}
+
+ template<class, char> struct B;
+ // old-note at -1 {{template non-type parameter has a different type 'char' in template argument}}
+
+ template struct A<B>;
+ // old-error at -1 {{has different template parameters}}
+ } // namespace t1
+} // namespace packs
+
namespace regression1 {
template <typename T, typename Y> struct map {};
template <typename T> class foo {};
diff --git a/clang/test/SemaTemplate/temp_arg_nontype.cpp b/clang/test/SemaTemplate/temp_arg_nontype.cpp
index e091de669fab4..c78eca2264b14 100644
--- a/clang/test/SemaTemplate/temp_arg_nontype.cpp
+++ b/clang/test/SemaTemplate/temp_arg_nontype.cpp
@@ -128,28 +128,28 @@ namespace ns {
struct Foo {
static const bool value = true;
};
-
+
template <bool b>
struct Bar {};
-
+
const bool value = false;
-
+
Bar<bool(ns::Foo<int>::value)> x;
}
// PR5349
namespace ns {
enum E { k };
-
+
template <E e>
struct Baz {};
-
+
Baz<k> f1; // This works.
Baz<E(0)> f2; // This too.
Baz<static_cast<E>(0)> f3; // And this.
-
+
Baz<ns::E(0)> b1; // This doesn't work.
- Baz<static_cast<ns::E>(0)> b2; // This neither.
+ Baz<static_cast<ns::E>(0)> b2; // This neither.
}
// PR5597
@@ -193,7 +193,7 @@ namespace EntityReferenced {
template<typename T>
struct Y {
- static void f(T x) {
+ static void f(T x) {
x = 1; // expected-error{{incompatible integer to pointer conversion assigning to 'int *' from 'int'}}
}
};
@@ -208,7 +208,7 @@ namespace PR6964 {
// expected-note {{template parameter is declared here}}
struct as_nview { };
- template <typename Sequence, int I0>
+ template <typename Sequence, int I0>
struct as_nview<Sequence, I0> // expected-note{{while checking a default template argument used here}}
{ };
}
@@ -235,7 +235,7 @@ namespace test8 {
char y;
double z;
};
-
+
template <C* cp> struct B {
C* p;
B() : p(cp) {}
@@ -387,12 +387,11 @@ namespace PR17696 {
namespace partial_order_different_types {
template<int, int, typename T, typename, T> struct A;
- template<int N, typename T, typename U, T V> struct A<0, N, T, U, V>; // expected-note {{matches}}
- // FIXME: It appears that this partial specialization should be ill-formed as
- // it is not more specialized than the primary template. V is not deducible
- // because it does not have the same type as the corresponding parameter.
- template<int N, typename T, typename U, U V> struct A<0, N, T, U, V> {}; // expected-note {{matches}}
- A<0, 0, int, int, 0> a; // expected-error {{ambiguous}}
+ // expected-note at -1 {{template is declared here}}
+ template<int N, typename T, typename U, T V> struct A<0, N, T, U, V> {};
+ template<int N, typename T, typename U, U V> struct A<0, N, T, U, V>;
+ // expected-error at -1 {{class template partial specialization is not more specialized than the primary template}}
+ A<0, 0, int, int, 0> a;
}
namespace partial_order_references {
@@ -458,17 +457,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_template.cpp b/clang/test/SemaTemplate/temp_arg_template.cpp
index a7236669276aa..9908af5e78669 100644
--- a/clang/test/SemaTemplate/temp_arg_template.cpp
+++ b/clang/test/SemaTemplate/temp_arg_template.cpp
@@ -1,33 +1,40 @@
// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx17 %std_cxx98-14 %s
// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx17 -std=c++17 %s
-template<template<typename T> class X> struct A; // expected-note 2{{previous template template parameter is here}}
+template<template<typename T> class X> struct A; // #A
+// expected-note at -1 2{{previous template template parameter is here}}
template<template<typename T, int I> class X> struct B; // expected-note{{previous template template parameter is here}}
-template<template<int I> class X> struct C; // expected-note {{previous non-type template parameter with type 'int' is here}}
+template<template<int I> class X> struct C;
+// precxx17-error at -1 {{deduced non-type template argument does not have the same type as the corresponding template parameter ('int' vs 'const int &')}}
+// cxx17-error at -2 {{conversion from 'int' to 'const int &' in converted constant expression would bind reference to a temporary}}
+// expected-note at -3 {{previous template template parameter is here}}
-template<class> struct X; // expected-note{{too few template parameters in template template argument}}
-template<int N> struct Y; // expected-note{{template parameter has a different kind in template argument}}
+template<class> struct X; // expected-note {{template is declared here}}
+template<int N> struct Y; // expected-note {{template parameter is declared here}}
template<long N> struct Ylong;
-template<const int &N> struct Yref; // expected-note{{template non-type parameter has a different type 'const int &' in template argument}}
+template<const int &N> struct Yref; // precxx17-note {{template parameter is declared here}}
namespace N {
template<class> struct Z;
}
-template<class, class> struct TooMany; // expected-note{{too many template parameters in template template argument}}
+template<class, class> struct TooMany; // expected-note{{template is declared here}}
A<X> *a1;
A<N::Z> *a2;
A< ::N::Z> *a3;
-A<Y> *a4; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
-A<TooMany> *a5; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
-B<X> *a6; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
+A<Y> *a4; // expected-error@#A {{template argument for non-type template parameter must be an expression}}
+ // expected-note at -1 {{different template parameters}}
+A<TooMany> *a5; // expected-error {{too few template arguments for class template 'TooMany'}}
+ // expected-note at -1 {{different template parameters}}
+B<X> *a6; // expected-error {{too many template arguments for class template 'X'}}
+ // expected-note at -1 {{different template parameters}}
C<Y> *a7;
C<Ylong> *a8;
-C<Yref> *a9; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
+C<Yref> *a9; // expected-note {{different template parameters}}
template<typename T> void f(int);
@@ -103,9 +110,9 @@ void foo() {
namespace CheckDependentNonTypeParamTypes {
template<template<typename T, typename U, T v> class X> struct A {
+ // expected-note at -1 {{previous template template parameter is here}}
void f() {
- X<int, void*, 3> x; // precxx17-error {{does not refer to any declaration}} \
- cxx17-error {{value of type 'int' is not implicitly convertible to 'void *'}}
+ X<int, void*, 3> x;
}
void g() {
X<int, long, 3> x;
@@ -124,15 +131,16 @@ namespace CheckDependentNonTypeParamTypes {
}
};
- template<typename T, typename U, U v> struct B { // precxx17-note {{parameter}}
+ template<typename T, typename U, U v> struct B {
+ // expected-error at -1 {{conflicting deduction 'U' against 'T' for parameter}}
static const U value = v;
};
// FIXME: This should probably be rejected, but the rules are at best unclear.
- A<B> ab;
+ A<B> ab; // expected-note {{different template parameters}}
void use() {
- ab.f(); // expected-note {{instantiation of}}
+ ab.f();
ab.g();
ab.h();
}
diff --git a/clang/test/SemaTemplate/temp_arg_template_p0522.cpp b/clang/test/SemaTemplate/temp_arg_template_p0522.cpp
index 251b6fc7d2be1..9529481893dde 100644
--- a/clang/test/SemaTemplate/temp_arg_template_p0522.cpp
+++ b/clang/test/SemaTemplate/temp_arg_template_p0522.cpp
@@ -1,14 +1,16 @@
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++20 %s
-// expected-note at temp_arg_template_p0522.cpp:* 1+{{}}
+// expected-note at temp_arg_template_p0522.cpp:* 1+{{template is declared here}}
+// expected-note at temp_arg_template_p0522.cpp:* 1+{{template parameter is declared here}}
+// expected-note at temp_arg_template_p0522.cpp:* 1+{{previous template template parameter is here}}
-template<template<int> typename> struct Ti;
-template<template<int...> typename> struct TPi;
+template<template<int> typename> struct Ti; // #Ti
+template<template<int...> typename> struct TPi; // #TPi
template<template<int, int...> typename> struct TiPi;
template<template<int..., int...> typename> struct TPiPi; // FIXME: Why is this not ill-formed?
-template<typename T, template<T> typename> struct tT0;
-template<template<typename T, T> typename> struct Tt0;
+template<typename T, template<T> typename> struct tT0; // #tT0
+template<template<typename T, T> typename> struct Tt0; // #Tt0
template<template<typename> typename> struct Tt;
template<template<typename, typename...> typename> struct TtPt;
@@ -19,8 +21,8 @@ template<int, int> struct ii;
template<int...> struct Pi;
template<int, int, int...> struct iiPi;
-template<int, typename = int> struct iDt;
-template<int, typename> struct it;
+template<int, typename = int> struct iDt; // #iDt
+template<int, typename> struct it; // #it
template<typename T, T v> struct t0;
@@ -31,10 +33,14 @@ namespace IntParam {
Ti<iDi>,
Ti<Pi>,
Ti<iDt>>;
- using err1 = Ti<ii>; // expected-error {{different template parameters}}
- using err2 = Ti<iiPi>; // expected-error {{different template parameters}}
- using err3 = Ti<t0>; // expected-error {{different template parameters}}
- using err4 = Ti<it>; // expected-error {{different template parameters}}
+ using err1 = Ti<ii>; // expected-error {{too few template arguments for class template 'ii'}}
+ // expected-note at -1 {{different template parameters}}
+ using err2 = Ti<iiPi>; // expected-error {{too few template arguments for class template 'iiPi'}}
+ // expected-note at -1 {{different template parameters}}
+ using err3 = Ti<t0>; // expected-error@#Ti {{template argument for template type parameter must be a type}}
+ // expected-note at -1 {{different template parameters}}
+ using err4 = Ti<it>; // expected-error {{too few template arguments for class template 'it'}}
+ // expected-note at -1 {{different template parameters}}
}
// These are accepted by the backwards-compatibility "parameter pack in
@@ -42,9 +48,12 @@ namespace IntParam {
namespace IntPackParam {
using ok = TPi<Pi>;
using ok_compat = Pt<TPi<i>, TPi<iDi>, TPi<ii>, TPi<iiPi>>;
- using err1 = TPi<t0>; // expected-error {{different template parameters}}
- using err2 = TPi<iDt>; // expected-error {{different template parameters}}
- using err3 = TPi<it>; // expected-error {{different template parameters}}
+ using err1 = TPi<t0>; // expected-error@#TPi {{template argument for template type parameter must be a type}}
+ // expected-note at -1 {{different template parameters}}
+ using err2 = TPi<iDt>; // expected-error@#iDt {{could not match 'type-parameter-0-1' against}}
+ // expected-note at -1 {{different template parameters}}
+ using err3 = TPi<it>; // expected-error@#it {{could not match 'type-parameter-0-1' against}}
+ // expected-note at -1 {{different template parameters}}
}
namespace IntAndPackParam {
@@ -55,42 +64,50 @@ namespace IntAndPackParam {
namespace DependentType {
using ok = Pt<tT0<int, i>, tT0<int, iDi>>;
- using err1 = tT0<int, ii>; // expected-error {{different template parameters}}
+ using err1 = tT0<int, ii>; // expected-error {{too few template arguments for class template 'ii'}}
+ // expected-note at -1 {{different template parameters}}
using err2 = tT0<short, i>; // FIXME: should this be OK?
using err2a = tT0<long long, i>; // FIXME: should this be OK (if long long is larger than int)?
- using err2b = tT0<void*, i>; // expected-error {{different template parameters}}
- using err3 = tT0<short, t0>; // expected-error {{different template parameters}}
+ using err2b = tT0<void*, i>; // expected-error@#tT0 {{value of type 'void *' is not implicitly convertible to 'int'}}
+ // expected-note at -1 {{different template parameters}}
+ using err3 = tT0<short, t0>; // expected-error@#tT0 {{template argument for template type parameter must be a type}}
+ // expected-note at -1 {{different template parameters}}
using ok2 = Tt0<t0>;
- using err4 = Tt0<it>; // expected-error {{different template parameters}}
+ using err4 = Tt0<it>; // expected-error@#Tt0 {{template argument for non-type template parameter must be an expression}}
+ // expected-note at -1 {{different template parameters}}
}
namespace Auto {
- template<template<int> typename T> struct TInt {};
- template<template<int*> typename T> struct TIntPtr {};
+ template<template<int> typename T> struct TInt {}; // #TInt
+ template<template<int*> typename T> struct TIntPtr {}; // #TIntPtr
template<template<auto> typename T> struct TAuto {};
template<template<auto*> typename T> struct TAutoPtr {};
template<template<decltype(auto)> typename T> struct TDecltypeAuto {};
template<auto> struct Auto;
- template<auto*> struct AutoPtr;
+ template<auto*> struct AutoPtr; // #AutoPtr
template<decltype(auto)> struct DecltypeAuto;
template<int> struct Int;
template<int*> struct IntPtr;
TInt<Auto> ia;
- TInt<AutoPtr> iap; // FIXME: ill-formed (?)
+ TInt<AutoPtr> iap; // expected-error@#TInt {{non-type template parameter '' with type 'auto *' has incompatible initializer of type 'int'}}
+ // expected-note at -1 {{different template parameters}}
TInt<DecltypeAuto> ida;
TInt<Int> ii;
- TInt<IntPtr> iip; // expected-error {{different template parameters}}
+ TInt<IntPtr> iip; // expected-error@#TInt {{conversion from 'int' to 'int *' is not allowed in a converted constant expression}}
+ // expected-note at -1 {{different template parameters}}
TIntPtr<Auto> ipa;
TIntPtr<AutoPtr> ipap;
TIntPtr<DecltypeAuto> ipda;
- TIntPtr<Int> ipi; // expected-error {{different template parameters}}
+ TIntPtr<Int> ipi; // expected-error@#TIntPtr {{value of type 'int *' is not implicitly convertible to 'int'}}
+ // expected-note at -1 {{different template parameters}}
TIntPtr<IntPtr> ipip;
TAuto<Auto> aa;
- TAuto<AutoPtr> aap; // FIXME: ill-formed (?)
+ TAuto<AutoPtr> aap; // expected-error@#AutoPtr {{could not match 'auto *' against 'auto'}}
+ // expected-note at -1 {{different template parameters}}
TAuto<Int> ai; // FIXME: ill-formed (?)
TAuto<IntPtr> aip; // FIXME: ill-formed (?)
@@ -111,7 +128,8 @@ namespace Auto {
// parameters (such as 'user-defined-type &') that are not valid 'auto'
// parameters.
TDecltypeAuto<Auto> daa;
- TDecltypeAuto<AutoPtr> daap; // FIXME: should probably be ill-formed
+ TDecltypeAuto<AutoPtr> daap; // expected-error@#AutoPtr {{could not match 'auto *' against 'decltype(auto)'}}
+ // expected-note at -1 {{different template parameters}}
int n;
template<auto A, decltype(A) B = &n> struct SubstFailure;
diff --git a/clang/test/Templight/templight-empty-entries-fix.cpp b/clang/test/Templight/templight-empty-entries-fix.cpp
index ad029d3070756..b2de3279f13e3 100644
--- a/clang/test/Templight/templight-empty-entries-fix.cpp
+++ b/clang/test/Templight/templight-empty-entries-fix.cpp
@@ -290,6 +290,18 @@ void foo() {
// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:265:35'$}}
// CHECK: {{^poi:[ ]+''$}}
// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+unnamed template template parameter 0 of d$}}
+// CHECK: {{^kind:[ ]+PartialOrderTTP$}}
+// CHECK: {{^event:[ ]+Begin$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:265:35'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:5'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+unnamed template template parameter 0 of d$}}
+// CHECK: {{^kind:[ ]+PartialOrderTTP$}}
+// CHECK: {{^event:[ ]+End$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:265:35'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:5'$}}
+// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+ExplicitTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+End$}}
diff --git a/clang/test/Templight/templight-prior-template-arg.cpp b/clang/test/Templight/templight-prior-template-arg.cpp
index e9b1dd47bb603..baf4f3f918868 100644
--- a/clang/test/Templight/templight-prior-template-arg.cpp
+++ b/clang/test/Templight/templight-prior-template-arg.cpp
@@ -10,63 +10,76 @@ class B {};
// CHECK: {{^kind:[ ]+PriorTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+Begin$}}
// CHECK: {{^orig:[ ]+'.*templight-prior-template-arg.cpp:5:40'}}
-// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:72:1'$}}
+// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:85:1'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'B::Outer'$}}
// CHECK: {{^kind:[ ]+PriorTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+End$}}
// CHECK: {{^orig:[ ]+'.*templight-prior-template-arg.cpp:5:40'}}
-// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:72:1'$}}
+// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:85:1'$}}
+//
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+'B::Outer'$}}
+// CHECK: {{^kind:[ ]+PartialOrderTTP$}}
+// CHECK: {{^event:[ ]+Begin$}}
+// CHECK: {{^orig:[ ]+'.*templight-prior-template-arg.cpp:5:40'}}
+// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:85:3'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+'B::Outer'$}}
+// CHECK: {{^kind:[ ]+PartialOrderTTP$}}
+// CHECK: {{^event:[ ]+End$}}
+// CHECK: {{^orig:[ ]+'.*templight-prior-template-arg.cpp:5:40'}}
+// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:85:3'$}}
//
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'B<A>'$}}
// CHECK: {{^kind:[ ]+TemplateInstantiation$}}
// CHECK: {{^event:[ ]+Begin$}}
// CHECK: {{^orig:[ ]+'.*templight-prior-template-arg.cpp:6:7'}}
-// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:72:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:85:6'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'B<A>'$}}
// CHECK: {{^kind:[ ]+TemplateInstantiation$}}
// CHECK: {{^event:[ ]+End$}}
// CHECK: {{^orig:[ ]+'.*templight-prior-template-arg.cpp:6:7'}}
-// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:72:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:85:6'$}}
//
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'B<A>'$}}
// CHECK: {{^kind:[ ]+TemplateInstantiation$}}
// CHECK: {{^event:[ ]+Begin$}}
// CHECK: {{^orig:[ ]+'.*templight-prior-template-arg.cpp:6:7'}}
-// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:72:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:85:6'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'B<A>'$}}
// CHECK: {{^kind:[ ]+TemplateInstantiation$}}
// CHECK: {{^event:[ ]+End$}}
// CHECK: {{^orig:[ ]+'.*templight-prior-template-arg.cpp:6:7'}}
-// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:72:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:85:6'$}}
//
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'B<A>'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+Begin$}}
// CHECK: {{^orig:[ ]+'.*templight-prior-template-arg.cpp:6:7'}}
-// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:72:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:85:6'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'B<A>'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+End$}}
// CHECK: {{^orig:[ ]+'.*templight-prior-template-arg.cpp:6:7'}}
-// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:72:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:85:6'$}}
//
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'B<A>'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+Begin$}}
// CHECK: {{^orig:[ ]+'.*templight-prior-template-arg.cpp:6:7'}}
-// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:72:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:85:6'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'B<A>'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+End$}}
// CHECK: {{^orig:[ ]+'.*templight-prior-template-arg.cpp:6:7'}}
-// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:72:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-prior-template-arg.cpp:85:6'$}}
B<A> b;
More information about the llvm-branch-commits
mailing list