From: Jonathan Wakely <jwakely@redhat.com>
Date: Wed, 28 Aug 2024 11:01:18 +0000 (+0100)
Subject: libstdc++: Constrain std::expected comparisons (P3379R0)
X-Git-Tag: basepoints/gcc-16~5216
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=0515b2436b7c7e5e391eae7edc42173c52bab61d;p=thirdparty%2Fgcc.git

libstdc++: Constrain std::expected comparisons (P3379R0)

This proposal of mine has been approved by LEWG and forwarded to LWG. I
expect it to be voted into the draft without significant changes.

libstdc++-v3/ChangeLog:

	* include/bits/version.def (constrained_equality): Bump value.
	* include/bits/version.h: Regenerate.
	* include/std/expected (operator==): Add constraints and
	noexcept specifiers.
	* testsuite/20_util/optional/relops/constrained.cc: Adjust
	check for feature test macro.
	* testsuite/20_util/pair/comparison_operators/constrained.cc:
	Likewise.
	* testsuite/20_util/tuple/comparison_operators/constrained.cc:
	Likewise.
	* testsuite/20_util/variant/relops/constrained.cc: Likewise.
	* testsuite/20_util/expected/equality_constrained.cc: New test.
---

diff --git a/libstdc++-v3/include/bits/version.def b/libstdc++-v3/include/bits/version.def
index 477651f358a2..4fa820a5a4ab 100644
--- a/libstdc++-v3/include/bits/version.def
+++ b/libstdc++-v3/include/bits/version.def
@@ -1256,7 +1256,7 @@ ftms = {
 ftms = {
   name = constrained_equality;
   values = {
-    v = 202403;
+    v = 202411; // FIXME: 202403 for P2944R3, ??? for P3379R0
     cxxmin = 20;
     extra_cond = "__glibcxx_three_way_comparison";
   };
diff --git a/libstdc++-v3/include/bits/version.h b/libstdc++-v3/include/bits/version.h
index 342ee6b4c7a0..fdbee8161d9e 100644
--- a/libstdc++-v3/include/bits/version.h
+++ b/libstdc++-v3/include/bits/version.h
@@ -1392,9 +1392,9 @@
 
 #if !defined(__cpp_lib_constrained_equality)
 # if (__cplusplus >= 202002L) && (__glibcxx_three_way_comparison)
-#  define __glibcxx_constrained_equality 202403L
+#  define __glibcxx_constrained_equality 202411L
 #  if defined(__glibcxx_want_all) || defined(__glibcxx_want_constrained_equality)
-#   define __cpp_lib_constrained_equality 202403L
+#   define __cpp_lib_constrained_equality 202411L
 #  endif
 # endif
 #endif /* !defined(__cpp_lib_constrained_equality) && defined(__glibcxx_want_constrained_equality) */
diff --git a/libstdc++-v3/include/std/expected b/libstdc++-v3/include/std/expected
index d4a4bc175415..7de2aeffc70c 100644
--- a/libstdc++-v3/include/std/expected
+++ b/libstdc++-v3/include/std/expected
@@ -35,6 +35,7 @@
 
 #define __glibcxx_want_expected
 #define __glibcxx_want_freestanding_expected
+#define __glibcxx_want_constrained_equality
 #include <bits/version.h>
 
 #ifdef __cpp_lib_expected // C++ >= 23 && __cpp_concepts >= 202002L
@@ -1152,10 +1153,15 @@ namespace __expected
 
       template<typename _Up, typename _Er2>
 	requires (!is_void_v<_Up>)
+	  && requires (const _Tp& __t, const _Up& __u,
+		       const _Er& __e, const _Er2& __e2) {
+	    { __t == __u } -> convertible_to<bool>;
+	    { __e == __e2 } -> convertible_to<bool>;
+	  }
 	friend constexpr bool
 	operator==(const expected& __x, const expected<_Up, _Er2>& __y)
-	// FIXME: noexcept(noexcept(bool(*__x == *__y))
-		  // && noexcept(bool(__x.error() == __y.error())))
+	noexcept(noexcept(bool(*__x == *__y))
+		  && noexcept(bool(__x.error() == __y.error())))
 	{
 	  if (__x.has_value())
 	    return __y.has_value() && bool(*__x == *__y);
@@ -1164,15 +1170,22 @@ namespace __expected
 	}
 
       template<typename _Up>
+	requires (!__expected::__is_expected<_Up>)
+	  && requires (const _Tp& __t, const _Up& __u) {
+	    { __t == __u } -> convertible_to<bool>;
+	  }
 	friend constexpr bool
 	operator==(const expected& __x, const _Up& __v)
-	// FIXME: noexcept(noexcept(bool(*__x == __v)))
+	noexcept(noexcept(bool(*__x == __v)))
 	{ return __x.has_value() && bool(*__x == __v); }
 
       template<typename _Er2>
+	requires requires (const _Er& __e, const _Er2& __e2) {
+	  { __e == __e2 } -> convertible_to<bool>;
+	}
 	friend constexpr bool
 	operator==(const expected& __x, const unexpected<_Er2>& __e)
-	// FIXME: noexcept(noexcept(bool(__x.error() == __e.error())))
+	noexcept(noexcept(bool(__x.error() == __e.error())))
 	{ return !__x.has_value() && bool(__x.error() == __e.error()); }
 
       friend constexpr void
@@ -1819,9 +1832,12 @@ namespace __expected
 
       template<typename _Up, typename _Er2>
 	requires is_void_v<_Up>
+	  && requires (const _Er& __e, const _Er2& __e2) {
+	    { __e == __e2 } -> convertible_to<bool>;
+	  }
 	friend constexpr bool
 	operator==(const expected& __x, const expected<_Up, _Er2>& __y)
-	// FIXME: noexcept(noexcept(bool(__x.error() == __y.error())))
+	noexcept(noexcept(bool(__x.error() == __y.error())))
 	{
 	  if (__x.has_value())
 	    return __y.has_value();
@@ -1830,9 +1846,12 @@ namespace __expected
 	}
 
       template<typename _Er2>
+	requires requires (const _Er& __e, const _Er2& __e2) {
+	  { __e == __e2 } -> convertible_to<bool>;
+	}
 	friend constexpr bool
 	operator==(const expected& __x, const unexpected<_Er2>& __e)
-	// FIXME: noexcept(noexcept(bool(__x.error() == __e.error())))
+	noexcept(noexcept(bool(__x.error() == __e.error())))
 	{ return !__x.has_value() && bool(__x.error() == __e.error()); }
 
       friend constexpr void
diff --git a/libstdc++-v3/testsuite/20_util/expected/equality_constrained.cc b/libstdc++-v3/testsuite/20_util/expected/equality_constrained.cc
new file mode 100644
index 000000000000..7f6cefae7487
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/expected/equality_constrained.cc
@@ -0,0 +1,181 @@
+// { dg-do compile { target c++23 } }
+
+#include <expected>
+
+#ifndef __cpp_lib_constrained_equality
+# error "Feature-test macro for constrained_equality missing in <expected>"
+#elif __cpp_lib_constrained_equality < 202411L // TODO: use final value
+# error "Feature-test macro for constrained_equality has wrong value"
+#endif
+
+template<typename T, typename U = T, typename E = int, typename E2 = E>
+concept eq_comparable
+= requires (const std::expected<T, E>& t, const std::expected<U, E2>& u) {
+  t == u;
+};
+
+static_assert( eq_comparable<int> );
+static_assert( eq_comparable<int, long> );
+static_assert( eq_comparable<short, int> );
+static_assert( eq_comparable<int, long, unsigned int, unsigned long> );
+static_assert( eq_comparable<void, const void> );
+
+struct A { };
+static_assert( ! eq_comparable<A> );
+static_assert( ! eq_comparable<A, A> );
+static_assert( ! eq_comparable<A, int> );
+static_assert( ! eq_comparable<int, int, A> );
+static_assert( ! eq_comparable<int, int, int, A> );
+static_assert( ! eq_comparable<void, const void, A> );
+
+struct B { };
+void operator==(B, B);
+static_assert( ! eq_comparable<B> );
+static_assert( ! eq_comparable<B, B> );
+static_assert( ! eq_comparable<B, int> );
+static_assert( ! eq_comparable<int, int, B> );
+static_assert( ! eq_comparable<int, int, int, B> );
+static_assert( ! eq_comparable<void, void, B> );
+
+struct C { };
+bool operator==(C, C);
+static_assert( eq_comparable<C> );
+static_assert( eq_comparable<C, C> );
+static_assert( eq_comparable<C, C> );
+static_assert( eq_comparable<C, C, C> );
+static_assert( eq_comparable<int, int, C> );
+static_assert( ! eq_comparable<C, C, A, A> );
+static_assert( ! eq_comparable<C, C, A, int> );
+static_assert( eq_comparable<void, void, C> );
+
+struct D { };
+int operator==(D, D);
+bool operator!=(D, D) = delete;
+static_assert( eq_comparable<D> );
+static_assert( eq_comparable<D, D> );
+static_assert( eq_comparable<int, int, D> );
+static_assert( eq_comparable<D, D, D> );
+static_assert( ! eq_comparable<D, D, D, int> );
+
+struct E { };
+bool operator==(/* not-const */ E&, const E&);
+static_assert( ! eq_comparable<E> );
+static_assert( ! eq_comparable<E, E> );
+static_assert( ! eq_comparable<E, E> );
+static_assert( ! eq_comparable<int, int, E> );
+
+bool operator==(A, B);
+static_assert( eq_comparable<A, B> );
+static_assert( eq_comparable<B, A> );
+static_assert( eq_comparable<int, long, B, A> );
+
+int operator==(C, D);
+static_assert( eq_comparable<C, D> );
+static_assert( eq_comparable<D, C> );
+static_assert( eq_comparable<int, int, C, D> );
+static_assert( eq_comparable<int, int, D, C> );
+static_assert( eq_comparable<const void, void, C, D> );
+static_assert( eq_comparable<const void, void, D, C> );
+
+template<typename T, typename U = T, typename E = int>
+concept eq_comparable_val
+= requires (const std::expected<T, E>& t, const U& u) {
+  t == u;
+};
+
+static_assert( eq_comparable_val<int> );
+static_assert( eq_comparable_val<int, long> );
+static_assert( eq_comparable_val<short, int> );
+static_assert( eq_comparable_val<int, long, unsigned> );
+static_assert( ! eq_comparable_val<void, const void> );
+
+static_assert( ! eq_comparable_val<A> );
+static_assert( ! eq_comparable_val<A, A> );
+static_assert( ! eq_comparable_val<A, int> );
+static_assert( eq_comparable_val<int, int, A> );
+static_assert( ! eq_comparable_val<void, A> );
+
+static_assert( ! eq_comparable_val<B> );
+static_assert( ! eq_comparable_val<B, B> );
+static_assert( ! eq_comparable_val<B, int> );
+static_assert( eq_comparable_val<int, int, B> );
+static_assert( ! eq_comparable_val<void, B> );
+
+static_assert( eq_comparable_val<C> );
+static_assert( eq_comparable_val<C, C> );
+static_assert( eq_comparable_val<C, C> );
+static_assert( eq_comparable_val<C, C, C> );
+static_assert( eq_comparable_val<int, int, C> );
+static_assert( eq_comparable_val<C, C, A> );
+static_assert( ! eq_comparable_val<void, C> );
+
+static_assert( eq_comparable_val<D> );
+static_assert( eq_comparable_val<D, D> );
+static_assert( ! eq_comparable_val<D, int> );
+static_assert( eq_comparable_val<int, int, D> );
+static_assert( eq_comparable_val<D, D, D> );
+
+static_assert( ! eq_comparable_val<E> );
+static_assert( ! eq_comparable_val<E, E> );
+static_assert( ! eq_comparable_val<E, int> );
+static_assert( eq_comparable_val<int, int, E> );
+
+static_assert( eq_comparable_val<A, B> );
+static_assert( eq_comparable_val<B, A> );
+
+static_assert( eq_comparable_val<C, D> );
+static_assert( ! eq_comparable_val<D, C> );
+
+template<typename E, typename U, typename T = int>
+concept eq_comparable_unex
+= requires (const std::expected<T, E>& t, const std::unexpected<U>& u) {
+  t == u;
+};
+
+static_assert( eq_comparable_unex<int, int> );
+static_assert( eq_comparable_unex<int, long> );
+static_assert( eq_comparable_unex<short, int> );
+static_assert( eq_comparable_unex<int, int, void> );
+static_assert( eq_comparable_unex<int, long, void> );
+static_assert( eq_comparable_unex<short, int, void> );
+
+static_assert( ! eq_comparable_unex<A, A> );
+static_assert( ! eq_comparable_unex<A, int> );
+static_assert( ! eq_comparable_unex<int, A> );
+static_assert( ! eq_comparable_unex<A, A, void> );
+static_assert( ! eq_comparable_unex<A, int, void> );
+static_assert( ! eq_comparable_unex<int, A, void> );
+
+static_assert( ! eq_comparable_unex<B, B> );
+static_assert( ! eq_comparable_unex<B, int> );
+static_assert( ! eq_comparable_unex<int, B> );
+static_assert( ! eq_comparable_unex<B, B, void> );
+static_assert( ! eq_comparable_unex<B, int, void> );
+static_assert( ! eq_comparable_unex<int, B, void> );
+
+static_assert( eq_comparable_unex<C, C> );
+static_assert( eq_comparable_unex<C, C, void> );
+
+static_assert( eq_comparable_unex<D, D> );
+static_assert( ! eq_comparable_unex<D, int> );
+static_assert( ! eq_comparable_unex<int, D> );
+static_assert( eq_comparable_unex<D, D, void> );
+static_assert( ! eq_comparable_unex<D, int, void> );
+static_assert( ! eq_comparable_unex<int, D, void> );
+
+static_assert( ! eq_comparable_unex<E, E> );
+static_assert( ! eq_comparable_unex<E, int> );
+static_assert( ! eq_comparable_unex<int, E> );
+static_assert( ! eq_comparable_unex<E, E, void> );
+static_assert( ! eq_comparable_unex<E, int, void> );
+static_assert( ! eq_comparable_unex<int, E, void> );
+
+static_assert( eq_comparable_unex<A, B> );
+static_assert( eq_comparable_unex<B, A> );
+static_assert( eq_comparable_unex<A, B, void> );
+static_assert( eq_comparable_unex<B, A, void> );
+
+static_assert( eq_comparable_unex<C, D> );
+static_assert( ! eq_comparable_unex<D, C> );
+static_assert( eq_comparable_unex<C, D, void> );
+static_assert( ! eq_comparable_unex<D, C, void> );
diff --git a/libstdc++-v3/testsuite/20_util/optional/relops/constrained.cc b/libstdc++-v3/testsuite/20_util/optional/relops/constrained.cc
index 0e3256180084..3e3932579286 100644
--- a/libstdc++-v3/testsuite/20_util/optional/relops/constrained.cc
+++ b/libstdc++-v3/testsuite/20_util/optional/relops/constrained.cc
@@ -4,7 +4,7 @@
 
 #ifndef __cpp_lib_constrained_equality
 # error "Feature-test macro for constrained_equality missing"
-#elif __cpp_lib_constrained_equality != 202403
+#elif __cpp_lib_constrained_equality < 202403L
 # error "Feature-test macro for constrained_equality has wrong value"
 #endif
 
diff --git a/libstdc++-v3/testsuite/20_util/pair/comparison_operators/constrained.cc b/libstdc++-v3/testsuite/20_util/pair/comparison_operators/constrained.cc
index a35dbd265a78..dabe35ff7469 100644
--- a/libstdc++-v3/testsuite/20_util/pair/comparison_operators/constrained.cc
+++ b/libstdc++-v3/testsuite/20_util/pair/comparison_operators/constrained.cc
@@ -4,7 +4,7 @@
 
 #ifndef __cpp_lib_constrained_equality
 # error "Feature-test macro for constrained_equality missing"
-#elif __cpp_lib_constrained_equality != 202403
+#elif __cpp_lib_constrained_equality < 202403L
 # error "Feature-test macro for constrained_equality has wrong value"
 #endif
 
diff --git a/libstdc++-v3/testsuite/20_util/tuple/comparison_operators/constrained.cc b/libstdc++-v3/testsuite/20_util/tuple/comparison_operators/constrained.cc
index 47035ab18bab..994d4a491a1a 100644
--- a/libstdc++-v3/testsuite/20_util/tuple/comparison_operators/constrained.cc
+++ b/libstdc++-v3/testsuite/20_util/tuple/comparison_operators/constrained.cc
@@ -4,7 +4,7 @@
 
 #ifndef __cpp_lib_constrained_equality
 # error "Feature-test macro for constrained_equality missing"
-#elif __cpp_lib_constrained_equality != 202403
+#elif __cpp_lib_constrained_equality < 202403L
 # error "Feature-test macro for constrained_equality has wrong value"
 #endif
 
diff --git a/libstdc++-v3/testsuite/20_util/variant/relops/constrained.cc b/libstdc++-v3/testsuite/20_util/variant/relops/constrained.cc
index 95e8f754d1ed..fbe10e0ba03d 100644
--- a/libstdc++-v3/testsuite/20_util/variant/relops/constrained.cc
+++ b/libstdc++-v3/testsuite/20_util/variant/relops/constrained.cc
@@ -4,7 +4,7 @@
 
 #ifndef __cpp_lib_constrained_equality
 # error "Feature-test macro for constrained_equality missing"
-#elif __cpp_lib_constrained_equality != 202403
+#elif __cpp_lib_constrained_equality < 202403L
 # error "Feature-test macro for constrained_equality has wrong value"
 #endif