From: Patrick Palka <ppalka@redhat.com>
Date: Wed, 13 Dec 2023 20:55:14 +0000 (-0500)
Subject: c++: unifying constants vs their type [PR99186, PR104867]
X-Git-Tag: basepoints/gcc-15~3619
X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=35ba3add7d0a9fc6ce955ba8ad82b0413e86ad7d;p=thirdparty%2Fgcc.git

c++: unifying constants vs their type [PR99186, PR104867]

When unifying constants we need to treat constants of different types
but same value as different in light of auto template parameters since
otherwise e.g. A<1> will unify with A<1u> (where A's template-head is
template<auto>).  This patch fixes this in a minimal way; it seems we
could get away with just using template_args_equal here, as we do in the
default case, or even just cp_tree_equal since the CONVERT_EXPR_P loop
seems to be dead code, but that's a simplification we could consider
during next stage 1.

	PR c++/99186
	PR c++/104867

gcc/cp/ChangeLog:

	* pt.cc (unify) <case INTEGER_CST>: Compare types as well.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp1z/nontype-auto23.C: New test.
	* g++.dg/cpp1z/nontype-auto24.C: New test.
---

diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index 9a21467bf219..b6a450c4ad40 100644
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -24706,6 +24706,8 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
       /* Type INTEGER_CST can come from ordinary constant template args.  */
     case INTEGER_CST:
     case REAL_CST:
+      if (!same_type_p (TREE_TYPE (parm), TREE_TYPE (arg)))
+	return unify_template_argument_mismatch (explain_p, parm, arg);
       while (CONVERT_EXPR_P (arg))
 	arg = TREE_OPERAND (arg, 0);
 
diff --git a/gcc/testsuite/g++.dg/cpp1z/nontype-auto23.C b/gcc/testsuite/g++.dg/cpp1z/nontype-auto23.C
new file mode 100644
index 000000000000..62a571ef84ab
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/nontype-auto23.C
@@ -0,0 +1,22 @@
+// PR c++/99186
+// { dg-do compile { target c++17 } }
+
+template<int N, class T, class... U>
+struct tuple_impl : tuple_impl<N + 1, U...> { };
+
+template<int N, class T>
+struct tuple_impl<N, T> { };
+
+template<class T, class U>
+struct tuple : tuple_impl<0, T, U> { };
+
+template<class T, int N, class... U>
+void get(const tuple_impl<N, T, U...>&);
+
+template<auto> struct S;
+
+int main() {
+   tuple<S<1>,S<1U>> x;
+   get<S<1U>>(x);
+   get<S<1>>(x);
+}
diff --git a/gcc/testsuite/g++.dg/cpp1z/nontype-auto24.C b/gcc/testsuite/g++.dg/cpp1z/nontype-auto24.C
new file mode 100644
index 000000000000..52e4c134ccdb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/nontype-auto24.C
@@ -0,0 +1,18 @@
+// PR c++/104867
+// { dg-do compile { target c++17 } }
+
+enum class Foo { A1 };
+
+enum class Bar { B1 };
+
+template<auto EnumVal> struct enum_;
+
+template<class...> struct list { };
+
+template<class V> void f(list<enum_<Bar::B1>, V>);
+
+struct enum_type_map : list<enum_<Foo::A1>, int>, list<enum_<Bar::B1>, double> { };
+
+int main() {
+  f(enum_type_map());
+}