c++: deduction guides and ttp rewriting [PR102479]

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> (where both 'Tmpl's are rewritten ttps).

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.

	PR c++/102479

gcc/cp/ChangeLog:

	* pt.c (rewrite_template_parm): Handle single-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.

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 6bd6ceb..41fa7ed 100644 (file)
--- 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 (PR102479).
+         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 a31cc15..f0d7ea0 100644 (file)
--- 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 (file)
index 0000000..6daa4b7
--- /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