c++: structural equality and partially inst typedef [PR119379]

Complex alias templates (and their dependent specializations) always use
structural equality because we need to treat them as transparent in some
contexts but not others.  Structural-ness however wasn't being preserved
during partial instantiation, which for the below testcase leads to the
checking ICE

  same canonical type node for different types 'S<int>::P<U>' and 'pair<int, U>'

when comparing those two types with comparing_dependent_aliases set
(from alias_ctad_tweaks).

This patch fixes this by making us preserve structural-ness for
partially instantiated typedefs in general.

	PR c++/119379

gcc/cp/ChangeLog:

	* pt.cc (tsubst_decl) <case TYPE_DECL>: Preserve structural-ness
	of a partially instantiated typedef.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp2a/class-deduction-alias24.C: New test.

Reviewed-by: Jason Merrill <jason@redhat.com>

diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index 538ff220d745207555bfa035a33b5a0bf51c98d1..39c0ee610bbd990ad7880c32e07dafdcacbdea91 100644 (file)
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -15920,6 +15920,11 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain,
            if (TYPE_USER_ALIGN (TREE_TYPE (t)))
              TREE_TYPE (r) = build_aligned_type (TREE_TYPE (r),
                                                  TYPE_ALIGN (TREE_TYPE (t)));
+
+           /* Preserve structural-ness of a partially instantiated typedef.  */
+           if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (t))
+               && dependent_type_p (TREE_TYPE (r)))
+             SET_TYPE_STRUCTURAL_EQUALITY (TREE_TYPE (r));
          }
 
        layout_decl (r, 0);

diff --git a/gcc/testsuite/g++.dg/cpp2a/class-deduction-alias24.C b/gcc/testsuite/g++.dg/cpp2a/class-deduction-alias24.C
new file mode 100644 (file)
index 0000000..cceddac
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/class-deduction-alias24.C
@@ -0,0 +1,16 @@
+// PR c++/119379
+// { dg-do compile { target c++20 } }
+
+template<class T, class U>
+struct pair {
+  pair(T, U);
+};
+
+template<class T>
+struct S {
+  template<class U> requires true
+  using P = pair<T, U>;
+};
+
+using type = decltype(S<int>::P(1, 2));
+using type = S<int>::P<int>;