The problem here is ultimately that rewrite_tparm_list when rewriting a
TEMPLATE_TEMPLATE_PARM introduces a tree cycle in the rewritten
ttp that structural_comptypes can't cope with. In particular the
DECL_TEMPLATE_PARMS of a ttp's TEMPLATE_DECL normally captures an empty
parameter list at its own level (and so the TEMPLATE_DECL doesn't appear
in its own DECL_TEMPLATE_PARMS), but rewrite_tparm_list ends up giving
it a complete parameter list. In the new testcase below, this causes
infinite recursion from structural_comptypes when comparing Tmpl<char>
with Tmpl<long> (here both 'Tmpl's are rewritten).
This patch fixes this by making rewrite_template_parm give a rewritten
template template parm an empty parameter list at its own level, thereby
avoiding the tree cycle. Testing the alias CTAD case revealed that
we're not setting current_template_parms in alias_ctad_tweaks, which
this patch also fixes. Also, the change to use TMPL_ARGS_LEVEL instead
of TREE_VEC_ELT is needed because alias_ctad_tweaks passes only a single
level of targs to rewrite_tparm_list.
Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look OK for
trunk?
PR c++/102479
gcc/cp/ChangeLog:
* pt.c (rewrite_template_parm): Use TMPL_ARGS_LEVEL instead of
TREE_VEC_ELT directly to properly handle one-level tsubst_args.
Avoid a tree cycle when assigning the DECL_TEMPLATE_PARMS for a
rewritten ttp.
(alias_ctad_tweaks): Set current_template_parms accordingly.
gcc/testsuite/ChangeLog:
* g++.dg/cpp1z/class-deduction12.C: Also test alias CTAD in the
same way.
* g++.dg/cpp1z/class-deduction99.C: New test.
---
gcc/cp/pt.c | 20 +++++++++--
.../g++.dg/cpp1z/class-deduction12.C | 6 ++++
.../g++.dg/cpp1z/class-deduction99.C | 35 +++++++++++++++++++
3 files changed, 58 insertions(+), 3 deletions(-)
create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction99.C
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 6bd6ceb29be..cba0f5c8279 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -28754,7 +28754,7 @@ rewrite_template_parm (tree olddecl, unsigned index,
unsigned level,
const int depth = TMPL_ARGS_DEPTH (tsubst_args);
tree ttargs = make_tree_vec (depth + 1);
for (int i = 0; i < depth; ++i)
- TREE_VEC_ELT (ttargs, i) = TREE_VEC_ELT (tsubst_args, i);
+ TREE_VEC_ELT (ttargs, i) = TMPL_ARGS_LEVEL (tsubst_args, i + 1);
TREE_VEC_ELT (ttargs, depth)
= template_parms_level_to_args (ttparms);
// Substitute ttargs into ttparms to fix references to
@@ -28767,8 +28767,17 @@ rewrite_template_parm (tree olddecl, unsigned index,
unsigned level,
ttparms = tsubst_template_parms_level (ttparms, ttargs,
complain);
// Finally, tack the adjusted parms onto tparms.
- ttparms = tree_cons (size_int (depth), ttparms,
- current_template_parms);
+ ttparms = tree_cons (size_int (level + 1), ttparms,
+ copy_node (current_template_parms));
+ // As with all template template parms, the parameter list captured
+ // by this template template parm that corresponds to its own level
+ // should be empty. This avoids infinite recursion when structurally
+ // comparing two such rewritten template template parms (102479).
+ gcc_assert (!TREE_VEC_LENGTH
+ (TREE_VALUE (TREE_CHAIN (DECL_TEMPLATE_PARMS
(olddecl)))));
+ gcc_assert (TMPL_PARMS_DEPTH (TREE_CHAIN (ttparms)) == level);
+ TREE_VALUE (TREE_CHAIN (ttparms)) = make_tree_vec (0);
+ // All done.
DECL_TEMPLATE_PARMS (newdecl) = ttparms;
}
}
@@ -29266,6 +29275,11 @@ alias_ctad_tweaks (tree tmpl, tree uguides)
++ndlen;
tree gtparms = make_tree_vec (natparms + ndlen);
+ /* Set current_template_parms as in build_deduction_guide. */
+ auto ctp = make_temp_override (current_template_parms);
+ current_template_parms = copy_node (DECL_TEMPLATE_PARMS (tmpl));
+ TREE_VALUE (current_template_parms) = gtparms;
+
/* First copy over the parms of A. */
for (j = 0; j < natparms; ++j)
TREE_VEC_ELT (gtparms, j) = TREE_VEC_ELT (atparms, j);
diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction12.C
b/gcc/testsuite/g++.dg/cpp1z/class-deduction12.C
index a31cc1526db..f0d7ea0e16b 100644
--- a/gcc/testsuite/g++.dg/cpp1z/class-deduction12.C
+++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction12.C
@@ -15,3 +15,9 @@ A a(&i,2,B<42>());
template <class,class> class same;
template <class T> class same<T,T> {};
same<decltype(a), A<int*>> s;
+
+#if __cpp_deduction_guides >= 201907
+template <class T> using C = A<const T*>;
+
+same<decltype(C(&i, 2, B<42>())), A<const int*>> t;
+#endif
diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction99.C
b/gcc/testsuite/g++.dg/cpp1z/class-deduction99.C
new file mode 100644
index 00000000000..6daa4b7c55c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction99.C
@@ -0,0 +1,35 @@
+// PR c++/102479
+// { dg-do compile { target c++17 } }
+
+template<class T> struct A;
+
+template<class T>
+struct tuple {
+ tuple(T);
+
+ template<template<class> class Tmpl>
+ tuple(Tmpl<T>);
+
+ template<template<class> class Tmpl, typename A<Tmpl<char>>::type = 0>
+ tuple(Tmpl<T>);
+
+ template<template<class> class Tmpl, typename A<Tmpl<long>>::type = 0>
+ tuple(Tmpl<T>);
+};
+
+template<class T> struct B { };
+
+using ty1 = tuple<int>;
+using ty1 = decltype(tuple(0));
+using ty1 = decltype(tuple(B<int>{}));
+
+#if __cpp_deduction_guides >= 201907
+template<class T> using const_tuple = tuple<const T>;
+
+using ty2 = const_tuple<int>;
+using ty2 = decltype(const_tuple(0));
+using ty2 = decltype(const_tuple(B<const int>{}));
+
+using ty3 = const_tuple<B<int>>;
+using ty3 = decltype(const_tuple(B<int>{}));
+#endif
--
2.33.0.591.gddb1055343
