[libcxx-commits] [libcxx] [libc++] Implement comparison operators for `tuple` added in C++23 (PR #148799)
A. Jiang via libcxx-commits
libcxx-commits at lists.llvm.org
Sat Jul 19 03:42:41 PDT 2025
https://github.com/frederick-vs-ja updated https://github.com/llvm/llvm-project/pull/148799
>From 807cd14dfe8a604ae386f5047e6eaf3e3188a9e5 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34 at live.cn>
Date: Tue, 15 Jul 2025 16:30:21 +0800
Subject: [PATCH 1/8] [libc++] Implement comparison operators for `tuple` added
in C++23
And constrain the new `operator==` since C++26.
This patch implements parts of P2165R4, P2944R3, and a possibly improved
resolution of LWG3882. Currently, libstdc++ and MSVC STL constrain the
new overloads in the same way.
---
libcxx/docs/Status/Cxx23Papers.csv | 2 +-
libcxx/docs/Status/Cxx2cIssues.csv | 1 +
libcxx/docs/Status/Cxx2cPapers.csv | 2 +-
libcxx/include/tuple | 130 ++++-
.../tuple/tuple.tuple/tuple.rel/eq.pass.cpp | 380 +++++++++-----
.../tuple/tuple.tuple/tuple.rel/lt.pass.cpp | 469 +++++++++++-------
...ze_incompatible_three_way.compile.pass.cpp | 19 +-
.../tuple.tuple/tuple.rel/three_way.pass.cpp | 172 ++++++-
8 files changed, 821 insertions(+), 354 deletions(-)
diff --git a/libcxx/docs/Status/Cxx23Papers.csv b/libcxx/docs/Status/Cxx23Papers.csv
index e4fa07d82289d..f1d8e9a2bd09c 100644
--- a/libcxx/docs/Status/Cxx23Papers.csv
+++ b/libcxx/docs/Status/Cxx23Papers.csv
@@ -60,7 +60,7 @@
"`P1642R11 <https://wg21.link/P1642R11>`__","Freestanding ``[utilities]``, ``[ranges]``, and ``[iterators]``","2022-07 (Virtual)","","",""
"`P1899R3 <https://wg21.link/P1899R3>`__","``stride_view``","2022-07 (Virtual)","","",""
"`P2093R14 <https://wg21.link/P2093R14>`__","Formatted output","2022-07 (Virtual)","|Complete|","18",""
-"`P2165R4 <https://wg21.link/P2165R4>`__","Compatibility between ``tuple``, ``pair`` and ``tuple-like`` objects","2022-07 (Virtual)","|Partial|","","Only the part for ``zip_view`` is implemented."
+"`P2165R4 <https://wg21.link/P2165R4>`__","Compatibility between ``tuple``, ``pair`` and ``tuple-like`` objects","2022-07 (Virtual)","|Partial|","","Changes of ``tuple``, ``adjacent_view``, and ``cartesian_product_view`` are not yet implemented."
"`P2278R4 <https://wg21.link/P2278R4>`__","``cbegin`` should always return a constant iterator","2022-07 (Virtual)","","",""
"`P2286R8 <https://wg21.link/P2286R8>`__","Formatting Ranges","2022-07 (Virtual)","|Complete|","16",""
"`P2291R3 <https://wg21.link/P2291R3>`__","Add Constexpr Modifiers to Functions ``to_chars`` and ``from_chars`` for Integral Types in ``<charconv>`` Header","2022-07 (Virtual)","|Complete|","16",""
diff --git a/libcxx/docs/Status/Cxx2cIssues.csv b/libcxx/docs/Status/Cxx2cIssues.csv
index c8a3aa95b7480..70ef723cd2b02 100644
--- a/libcxx/docs/Status/Cxx2cIssues.csv
+++ b/libcxx/docs/Status/Cxx2cIssues.csv
@@ -149,4 +149,5 @@
"`LWG3343 <https://wg21.link/LWG3343>`__","Ordering of calls to ``unlock()`` and ``notify_all()`` in Effects element of ``notify_all_at_thread_exit()`` should be reversed","Not Adopted Yet","|Complete|","16",""
"`LWG4139 <https://wg21.link/LWG4139>`__","ยง[time.zone.leap] recursive constraint in <=>","Not Adopted Yet","|Complete|","20",""
"`LWG3456 <https://wg21.link/LWG3456>`__","Pattern used by std::from_chars is underspecified (option B)","Not Adopted Yet","|Complete|","20",""
+"`LWG3882 <https://wg21.link/LWG3882>`__","``tuple`` relational operators have confused friendships","Not Adopted Yet","|Complete|","21","The comparsion operators are constrained harder than the proposed resolution. libstdc++ and MSVC STL do the same."
"","","","","",""
diff --git a/libcxx/docs/Status/Cxx2cPapers.csv b/libcxx/docs/Status/Cxx2cPapers.csv
index 98efd3e46ebee..e41b6a10e10f4 100644
--- a/libcxx/docs/Status/Cxx2cPapers.csv
+++ b/libcxx/docs/Status/Cxx2cPapers.csv
@@ -59,7 +59,7 @@
"`P2248R8 <https://wg21.link/P2248R8>`__","Enabling list-initialization for algorithms","2024-03 (Tokyo)","","",""
"`P2810R4 <https://wg21.link/P2810R4>`__","``is_debugger_present`` ``is_replaceable``","2024-03 (Tokyo)","","",""
"`P1068R11 <https://wg21.link/P1068R11>`__","Vector API for random number generation","2024-03 (Tokyo)","","",""
-"`P2944R3 <https://wg21.link/P2944R3>`__","Comparisons for ``reference_wrapper``","2024-03 (Tokyo)","|Partial|","","The changes to ``tuple``'s equality overload from P2165R4 are not yet implemented."
+"`P2944R3 <https://wg21.link/P2944R3>`__","Comparisons for ``reference_wrapper``","2024-03 (Tokyo)","|Complete|","21",""
"`P2642R6 <https://wg21.link/P2642R6>`__","Padded ``mdspan`` layouts","2024-03 (Tokyo)","","",""
"`P3029R1 <https://wg21.link/P3029R1>`__","Better ``mdspan``'s CTAD","2024-03 (Tokyo)","|Complete|","19",""
"","","","","",""
diff --git a/libcxx/include/tuple b/libcxx/include/tuple
index 75021f0ea51f6..1ab451539f533 100644
--- a/libcxx/include/tuple
+++ b/libcxx/include/tuple
@@ -230,6 +230,7 @@ template <class... Types>
# include <__tuple/sfinae_helpers.h>
# include <__tuple/tuple_element.h>
# include <__tuple/tuple_indices.h>
+# include <__tuple/tuple_like.h>
# include <__tuple/tuple_like_ext.h>
# include <__tuple/tuple_size.h>
# include <__tuple/tuple_types.h>
@@ -288,6 +289,72 @@ _LIBCPP_BEGIN_NAMESPACE_STD
# ifndef _LIBCPP_CXX03_LANG
+template <size_t _Ip>
+struct __tuple_equal {
+ template <class _Tp, class _Up>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp& __x, const _Up& __y) {
+ return __tuple_equal<_Ip - 1>()(__x, __y) && std::get<_Ip - 1>(__x) == std::get<_Ip - 1>(__y);
+ }
+
+# if _LIBCPP_STD_VER >= 26
+ template <class _Tp, class _Up>
+ static constexpr bool __can_compare =
+ __tuple_equal<_Ip - 1>::template __can_compare<_Tp, _Up> && requires(const _Tp& __x, const _Up& __y) {
+ { std::get<_Ip - 1>(__x) == std::get<_Ip - 1>(__y) } -> __boolean_testable;
+ };
+# endif // _LIBCPP_STD_VER >= 26
+};
+
+template <>
+struct __tuple_equal<0> {
+ template <class _Tp, class _Up>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp&, const _Up&) {
+ return true;
+ }
+
+# if _LIBCPP_STD_VER >= 26
+ template <class _Tp, class _Up>
+ static constexpr bool __can_compare = true;
+# endif // _LIBCPP_STD_VER >= 26
+};
+
+# if _LIBCPP_STD_VER >= 20
+template <class _Ret, class _Tp, class _Up, size_t... _Is>
+_LIBCPP_HIDE_FROM_ABI constexpr _Ret __tuple_compare_three_way(const _Tp& __x, const _Up& __y, index_sequence<_Is...>) {
+ _Ret __result = strong_ordering::equal;
+ static_cast<void>(
+ ((__result = std::__synth_three_way(std::get<_Is>(__x), std::get<_Is>(__y)), __result != 0) || ...));
+ return __result;
+}
+# endif // _LIBCPP_STD_VER >= 20
+
+# if _LIBCPP_STD_VER >= 23
+template <class>
+inline constexpr bool __is_tuple_v = false;
+
+template <class... _Tp>
+inline constexpr bool __is_tuple_v<tuple<_Tp...>> = true;
+
+template <class _Tp>
+concept __tuple_like_no_tuple = __tuple_like<_Tp> && !__is_tuple_v<_Tp>;
+
+template <class _Tp, class _Up, class _IndexSeq>
+struct __tuple_common_comparison_category_impl {};
+template <class _Tp, class _Up, size_t... _Indices>
+ requires requires {
+ typename common_comparison_category_t<
+ __synth_three_way_result<tuple_element_t<_Indices, _Tp>, tuple_element_t<_Indices, _Up>>...>;
+ }
+struct __tuple_common_comparison_category_impl<_Tp, _Up, index_sequence<_Indices...>> {
+ using type _LIBCPP_NODEBUG = common_comparison_category_t<
+ __synth_three_way_result<tuple_element_t<_Indices, _Tp>, tuple_element_t<_Indices, _Up>>...>;
+};
+
+template <__tuple_like _Tp, __tuple_like _Up>
+using __tuple_common_comparison_category _LIBCPP_NODEBUG =
+ __tuple_common_comparison_category_impl<_Tp, _Up, make_index_sequence<tuple_size_v<_Tp>>>::type;
+# endif // _LIBCPP_STD_VER >= 23
+
// __tuple_leaf
template <size_t _Ip, class _Hp, bool = is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value >
@@ -997,7 +1064,25 @@ public:
noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) {
__base_.swap(__t.__base_);
}
-# endif // _LIBCPP_STD_VER >= 23
+
+ template <__tuple_like_no_tuple _UTuple>
+# if _LIBCPP_STD_VER >= 26
+ requires(__tuple_equal<sizeof...(_Tp)>::template __can_compare<tuple, _UTuple>) &&
+ (sizeof...(_Tp) == tuple_size_v<_UTuple>)
+# endif // _LIBCPP_STD_VER >= 26
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const tuple& __x, const _UTuple& __y) {
+ static_assert(sizeof...(_Tp) == tuple_size_v<_UTuple>, "Can't compare tuple-like values of different sizes");
+ return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
+ }
+
+ template <__tuple_like_no_tuple _UTuple>
+ requires(sizeof...(_Tp) == tuple_size_v<_UTuple>)
+ _LIBCPP_HIDE_FROM_ABI friend constexpr __tuple_common_comparison_category<tuple, _UTuple>
+ operator<=>(const tuple& __x, const _UTuple& __y) {
+ return std::__tuple_compare_three_way<__tuple_common_comparison_category<tuple, _UTuple>>(
+ __x, __y, index_sequence_for<_Tp...>{});
+ }
+# endif // _LIBCPP_STD_VER >= 23
};
_LIBCPP_DIAGNOSTIC_PUSH
@@ -1019,6 +1104,21 @@ public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(tuple&) _NOEXCEPT {}
# if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple&) const noexcept {}
+
+ template <__tuple_like_no_tuple _UTuple>
+# if _LIBCPP_STD_VER >= 26
+ requires(tuple_size_v<_UTuple> == 0)
+# endif // _LIBCPP_STD_VER >= 26
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const tuple&, const _UTuple&) {
+ static_assert(tuple_size_v<_UTuple> == 0, "Can't compare tuple-like values of different sizes");
+ return true;
+ }
+
+ template <__tuple_like_no_tuple _UTuple>
+ requires(tuple_size_v<_UTuple> == 0)
+ _LIBCPP_HIDE_FROM_ABI friend constexpr strong_ordering operator<=>(const tuple&, const _UTuple&) {
+ return strong_ordering::equal;
+ }
# endif
};
_LIBCPP_DIAGNOSTIC_POP
@@ -1137,22 +1237,6 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<_Tp&&...> forwa
return tuple<_Tp&&...>(std::forward<_Tp>(__t)...);
}
-template <size_t _Ip>
-struct __tuple_equal {
- template <class _Tp, class _Up>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp& __x, const _Up& __y) {
- return __tuple_equal<_Ip - 1>()(__x, __y) && std::get<_Ip - 1>(__x) == std::get<_Ip - 1>(__y);
- }
-};
-
-template <>
-struct __tuple_equal<0> {
- template <class _Tp, class _Up>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp&, const _Up&) {
- return true;
- }
-};
-
template <class... _Tp, class... _Up>
# if _LIBCPP_STD_VER >= 26
requires(__all<requires(const _Tp& __t, const _Up& __u) {
@@ -1169,20 +1253,12 @@ operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
// operator<=>
-template <class... _Tp, class... _Up, size_t... _Is>
-_LIBCPP_HIDE_FROM_ABI constexpr auto
-__tuple_compare_three_way(const tuple<_Tp...>& __x, const tuple<_Up...>& __y, index_sequence<_Is...>) {
- common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...> __result = strong_ordering::equal;
- static_cast<void>(
- ((__result = std::__synth_three_way(std::get<_Is>(__x), std::get<_Is>(__y)), __result != 0) || ...));
- return __result;
-}
-
template <class... _Tp, class... _Up>
requires(sizeof...(_Tp) == sizeof...(_Up))
_LIBCPP_HIDE_FROM_ABI constexpr common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...>
operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
- return std::__tuple_compare_three_way(__x, __y, index_sequence_for<_Tp...>{});
+ return std::__tuple_compare_three_way<common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...>>(
+ __x, __y, index_sequence_for<_Tp...>{});
}
# else // _LIBCPP_STD_VER >= 20
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
index 779a89b163f04..b0301f3ad93e7 100644
--- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
@@ -13,6 +13,8 @@
// template<class... TTypes, class... UTypes>
// bool
// operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+// template<tuple-like UTuple>
+// friend constexpr bool operator==(const tuple& t, const UTuple& u); // since C++23
// UNSUPPORTED: c++03
@@ -23,6 +25,13 @@
#include "test_comparisons.h"
#include "test_macros.h"
+#if TEST_STD_VER >= 23
+# include <ranges>
+#endif
+#if TEST_STD_VER >= 26
+# include <complex>
+#endif
+
#if TEST_STD_VER >= 26
// Test SFINAE.
@@ -41,140 +50,249 @@ static_assert(
static_assert(
!std::equality_comparable_with<std::tuple<EqualityComparable, EqualityComparable>, std::tuple<EqualityComparable>>);
+// Heterogeneous comparisons.
+// TODO: Use equality_comparable_with once other changes of tuple introduced in P2165R4 are implemented.
+template <class T, class U>
+concept can_eq_compare = requires(const T& t, const U& u) { t == u; };
+
+static_assert(can_eq_compare<std::tuple<EqualityComparable>, std::array<EqualityComparable, 1>>);
+static_assert(!can_eq_compare<std::tuple<EqualityComparable>, std::array<NonComparable, 1>>);
+
+static_assert(can_eq_compare<std::tuple<EqualityComparable, EqualityComparable>,
+ std::pair<EqualityComparable, EqualityComparable>>);
+static_assert(
+ !can_eq_compare<std::tuple<EqualityComparable, EqualityComparable>, std::pair<EqualityComparable, NonComparable>>);
+
+static_assert(can_eq_compare<std::tuple<int*, int*>, std::ranges::subrange<const int*>>);
+static_assert(!can_eq_compare<std::tuple<int (*)[1], int (*)[1]>, std::ranges::subrange<const int*>>);
+static_assert(can_eq_compare<std::tuple<double, double>, std::complex<float>>);
+static_assert(!can_eq_compare<std::tuple<int*, int*>, std::complex<float>>);
+
+// Size mismatch in heterogeneous comparisons.
+static_assert(!can_eq_compare<std::tuple<>, std::array<EqualityComparable, 2>>);
+static_assert(!can_eq_compare<std::tuple<EqualityComparable>, std::array<EqualityComparable, 2>>);
+static_assert(!can_eq_compare<std::tuple<>, std::pair<EqualityComparable, EqualityComparable>>);
+static_assert(!can_eq_compare<std::tuple<EqualityComparable>, std::pair<EqualityComparable, EqualityComparable>>);
+static_assert(!can_eq_compare<std::tuple<int*>, std::ranges::subrange<int*>>);
+static_assert(!can_eq_compare<std::tuple<double>, std::complex<double>>);
+
#endif
-int main(int, char**)
-{
- {
- typedef std::tuple<> T1;
- typedef std::tuple<> T2;
- const T1 t1;
- const T2 t2;
- assert(t1 == t2);
- assert(!(t1 != t2));
- }
- {
- typedef std::tuple<int> T1;
- typedef std::tuple<double> T2;
- const T1 t1(1);
- const T2 t2(1.1);
- assert(!(t1 == t2));
- assert(t1 != t2);
- }
- {
- typedef std::tuple<int> T1;
- typedef std::tuple<double> T2;
- const T1 t1(1);
- const T2 t2(1);
- assert(t1 == t2);
- assert(!(t1 != t2));
- }
- {
- typedef std::tuple<int, double> T1;
- typedef std::tuple<double, long> T2;
- const T1 t1(1, 2);
- const T2 t2(1, 2);
- assert(t1 == t2);
- assert(!(t1 != t2));
- }
- {
- typedef std::tuple<int, double> T1;
- typedef std::tuple<double, long> T2;
- const T1 t1(1, 2);
- const T2 t2(1, 3);
- assert(!(t1 == t2));
- assert(t1 != t2);
- }
- {
- typedef std::tuple<int, double> T1;
- typedef std::tuple<double, long> T2;
- const T1 t1(1, 2);
- const T2 t2(1.1, 2);
- assert(!(t1 == t2));
- assert(t1 != t2);
- }
- {
- typedef std::tuple<int, double> T1;
- typedef std::tuple<double, long> T2;
- const T1 t1(1, 2);
- const T2 t2(1.1, 3);
- assert(!(t1 == t2));
- assert(t1 != t2);
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1, 2, 3);
- assert(t1 == t2);
- assert(!(t1 != t2));
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1.1, 2, 3);
- assert(!(t1 == t2));
- assert(t1 != t2);
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1, 3, 3);
- assert(!(t1 == t2));
- assert(t1 != t2);
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1, 2, 4);
- assert(!(t1 == t2));
- assert(t1 != t2);
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1, 3, 2);
- assert(!(t1 == t2));
- assert(t1 != t2);
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1.1, 2, 2);
- assert(!(t1 == t2));
- assert(t1 != t2);
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1.1, 3, 3);
- assert(!(t1 == t2));
- assert(t1 != t2);
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1.1, 3, 2);
- assert(!(t1 == t2));
- assert(t1 != t2);
- }
-#if TEST_STD_VER > 11
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- constexpr T1 t1(1, 2, 3);
- constexpr T2 t2(1.1, 3, 2);
- static_assert(!(t1 == t2), "");
- static_assert(t1 != t2, "");
- }
+TEST_CONSTEXPR_CXX14 bool test() {
+ {
+ typedef std::tuple<> T1;
+ typedef std::tuple<> T2;
+ const T1 t1;
+ const T2 t2;
+ assert(t1 == t2);
+ assert(!(t1 != t2));
+ }
+ {
+ typedef std::tuple<int> T1;
+ typedef std::tuple<double> T2;
+ const T1 t1(1);
+ const T2 t2(1.1);
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ typedef std::tuple<int> T1;
+ typedef std::tuple<double> T2;
+ const T1 t1(1);
+ const T2 t2(1);
+ assert(t1 == t2);
+ assert(!(t1 != t2));
+ }
+ {
+ typedef std::tuple<int, double> T1;
+ typedef std::tuple<double, long> T2;
+ const T1 t1(1, 2);
+ const T2 t2(1, 2);
+ assert(t1 == t2);
+ assert(!(t1 != t2));
+ }
+ {
+ typedef std::tuple<int, double> T1;
+ typedef std::tuple<double, long> T2;
+ const T1 t1(1, 2);
+ const T2 t2(1, 3);
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ typedef std::tuple<int, double> T1;
+ typedef std::tuple<double, long> T2;
+ const T1 t1(1, 2);
+ const T2 t2(1.1, 2);
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ typedef std::tuple<int, double> T1;
+ typedef std::tuple<double, long> T2;
+ const T1 t1(1, 2);
+ const T2 t2(1.1, 3);
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1, 2, 3);
+ assert(t1 == t2);
+ assert(!(t1 != t2));
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1.1, 2, 3);
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1, 3, 3);
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1, 2, 4);
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1, 3, 2);
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1.1, 2, 2);
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1.1, 3, 3);
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1.1, 3, 2);
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+#if TEST_STD_VER >= 14
+ {
+ using T1 = std::tuple<long, int, double>;
+ using T2 = std::tuple<double, long, int>;
+ constexpr T1 t1(1, 2, 3);
+ constexpr T2 t2(1.1, 3, 2);
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
#endif
+#if TEST_STD_VER >= 23
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::pair<double, long>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.0, 2};
+ assert(t1 == t2);
+ assert(!(t1 != t2));
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::pair<double, long>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.1, 3};
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::array<double, 2>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.0, 2.0};
+ assert(t1 == t2);
+ assert(!(t1 != t2));
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::array<double, 2>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.1, 3.0};
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ using T1 = std::tuple<const int*, const int*>;
+ using T2 = std::ranges::subrange<const int*>;
+
+ int arr[1]{};
+ T1 t1{arr, arr + 1};
+ T2 t2{arr};
+ assert(t1 == t2);
+ assert(!(t1 != t2));
+ }
+ {
+ using T1 = std::tuple<const int*, const int*>;
+ using T2 = std::ranges::subrange<const int*>;
+ int arr[1]{};
+ T1 t1{arr, arr};
+ T2 t2{arr};
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+ {
+ assert((std::tuple<>{} == std::array<int*, 0>{}));
+ assert((std::tuple<>{} == std::array<double, 0>{}));
+ }
+#endif
+#if TEST_STD_VER >= 26
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::complex<double>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.0, 2.0};
+ assert(t1 == t2);
+ assert(!(t1 != t2));
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::complex<double>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.1, 3.0};
+ assert(!(t1 == t2));
+ assert(t1 != t2);
+ }
+#endif
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+#if TEST_STD_VER >= 14
+ static_assert(test(), "");
+#endif
return 0;
}
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
index 0ece614a23e80..ef50454885a2b 100644
--- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
@@ -28,186 +28,305 @@
// UNSUPPORTED: c++03
-#include <tuple>
-#include <string>
#include <cassert>
+#include <tuple>
#include "test_macros.h"
-int main(int, char**)
-{
- {
- typedef std::tuple<> T1;
- typedef std::tuple<> T2;
- const T1 t1;
- const T2 t2;
- assert(!(t1 < t2));
- assert( (t1 <= t2));
- assert(!(t1 > t2));
- assert( (t1 >= t2));
- }
- {
- typedef std::tuple<long> T1;
- typedef std::tuple<double> T2;
- const T1 t1(1);
- const T2 t2(1);
- assert(!(t1 < t2));
- assert( (t1 <= t2));
- assert(!(t1 > t2));
- assert( (t1 >= t2));
- }
- {
- typedef std::tuple<long> T1;
- typedef std::tuple<double> T2;
- const T1 t1(1);
- const T2 t2(0.9);
- assert(!(t1 < t2));
- assert(!(t1 <= t2));
- assert( (t1 > t2));
- assert( (t1 >= t2));
- }
- {
- typedef std::tuple<long> T1;
- typedef std::tuple<double> T2;
- const T1 t1(1);
- const T2 t2(1.1);
- assert( (t1 < t2));
- assert( (t1 <= t2));
- assert(!(t1 > t2));
- assert(!(t1 >= t2));
- }
- {
- typedef std::tuple<long, int> T1;
- typedef std::tuple<double, long> T2;
- const T1 t1(1, 2);
- const T2 t2(1, 2);
- assert(!(t1 < t2));
- assert( (t1 <= t2));
- assert(!(t1 > t2));
- assert( (t1 >= t2));
- }
- {
- typedef std::tuple<long, int> T1;
- typedef std::tuple<double, long> T2;
- const T1 t1(1, 2);
- const T2 t2(0.9, 2);
- assert(!(t1 < t2));
- assert(!(t1 <= t2));
- assert( (t1 > t2));
- assert( (t1 >= t2));
- }
- {
- typedef std::tuple<long, int> T1;
- typedef std::tuple<double, long> T2;
- const T1 t1(1, 2);
- const T2 t2(1.1, 2);
- assert( (t1 < t2));
- assert( (t1 <= t2));
- assert(!(t1 > t2));
- assert(!(t1 >= t2));
- }
- {
- typedef std::tuple<long, int> T1;
- typedef std::tuple<double, long> T2;
- const T1 t1(1, 2);
- const T2 t2(1, 1);
- assert(!(t1 < t2));
- assert(!(t1 <= t2));
- assert( (t1 > t2));
- assert( (t1 >= t2));
- }
- {
- typedef std::tuple<long, int> T1;
- typedef std::tuple<double, long> T2;
- const T1 t1(1, 2);
- const T2 t2(1, 3);
- assert( (t1 < t2));
- assert( (t1 <= t2));
- assert(!(t1 > t2));
- assert(!(t1 >= t2));
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1, 2, 3);
- assert(!(t1 < t2));
- assert( (t1 <= t2));
- assert(!(t1 > t2));
- assert( (t1 >= t2));
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(0.9, 2, 3);
- assert(!(t1 < t2));
- assert(!(t1 <= t2));
- assert( (t1 > t2));
- assert( (t1 >= t2));
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1.1, 2, 3);
- assert( (t1 < t2));
- assert( (t1 <= t2));
- assert(!(t1 > t2));
- assert(!(t1 >= t2));
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1, 1, 3);
- assert(!(t1 < t2));
- assert(!(t1 <= t2));
- assert( (t1 > t2));
- assert( (t1 >= t2));
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1, 3, 3);
- assert( (t1 < t2));
- assert( (t1 <= t2));
- assert(!(t1 > t2));
- assert(!(t1 >= t2));
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1, 2, 2);
- assert(!(t1 < t2));
- assert(!(t1 <= t2));
- assert( (t1 > t2));
- assert( (t1 >= t2));
- }
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- const T1 t1(1, 2, 3);
- const T2 t2(1, 2, 4);
- assert( (t1 < t2));
- assert( (t1 <= t2));
- assert(!(t1 > t2));
- assert(!(t1 >= t2));
- }
-#if TEST_STD_VER > 11
- {
- typedef std::tuple<long, int, double> T1;
- typedef std::tuple<double, long, int> T2;
- constexpr T1 t1(1, 2, 3);
- constexpr T2 t2(1, 2, 4);
- static_assert( (t1 < t2), "");
- static_assert( (t1 <= t2), "");
- static_assert(!(t1 > t2), "");
- static_assert(!(t1 >= t2), "");
- }
+#if TEST_STD_VER >= 23
+# include <array>
+# include <ranges>
+# include <utility>
+#endif
+#if TEST_STD_VER >= 26
+# include <complex>
+#endif
+
+TEST_CONSTEXPR_CXX14 bool test() {
+ {
+ typedef std::tuple<> T1;
+ typedef std::tuple<> T2;
+ const T1 t1;
+ const T2 t2;
+ assert(!(t1 < t2));
+ assert((t1 <= t2));
+ assert(!(t1 > t2));
+ assert((t1 >= t2));
+ }
+ {
+ typedef std::tuple<long> T1;
+ typedef std::tuple<double> T2;
+ const T1 t1(1);
+ const T2 t2(1);
+ assert(!(t1 < t2));
+ assert((t1 <= t2));
+ assert(!(t1 > t2));
+ assert((t1 >= t2));
+ }
+ {
+ typedef std::tuple<long> T1;
+ typedef std::tuple<double> T2;
+ const T1 t1(1);
+ const T2 t2(0.9);
+ assert(!(t1 < t2));
+ assert(!(t1 <= t2));
+ assert((t1 > t2));
+ assert((t1 >= t2));
+ }
+ {
+ typedef std::tuple<long> T1;
+ typedef std::tuple<double> T2;
+ const T1 t1(1);
+ const T2 t2(1.1);
+ assert((t1 < t2));
+ assert((t1 <= t2));
+ assert(!(t1 > t2));
+ assert(!(t1 >= t2));
+ }
+ {
+ typedef std::tuple<long, int> T1;
+ typedef std::tuple<double, long> T2;
+ const T1 t1(1, 2);
+ const T2 t2(1, 2);
+ assert(!(t1 < t2));
+ assert((t1 <= t2));
+ assert(!(t1 > t2));
+ assert((t1 >= t2));
+ }
+ {
+ typedef std::tuple<long, int> T1;
+ typedef std::tuple<double, long> T2;
+ const T1 t1(1, 2);
+ const T2 t2(0.9, 2);
+ assert(!(t1 < t2));
+ assert(!(t1 <= t2));
+ assert((t1 > t2));
+ assert((t1 >= t2));
+ }
+ {
+ typedef std::tuple<long, int> T1;
+ typedef std::tuple<double, long> T2;
+ const T1 t1(1, 2);
+ const T2 t2(1.1, 2);
+ assert((t1 < t2));
+ assert((t1 <= t2));
+ assert(!(t1 > t2));
+ assert(!(t1 >= t2));
+ }
+ {
+ typedef std::tuple<long, int> T1;
+ typedef std::tuple<double, long> T2;
+ const T1 t1(1, 2);
+ const T2 t2(1, 1);
+ assert(!(t1 < t2));
+ assert(!(t1 <= t2));
+ assert((t1 > t2));
+ assert((t1 >= t2));
+ }
+ {
+ typedef std::tuple<long, int> T1;
+ typedef std::tuple<double, long> T2;
+ const T1 t1(1, 2);
+ const T2 t2(1, 3);
+ assert((t1 < t2));
+ assert((t1 <= t2));
+ assert(!(t1 > t2));
+ assert(!(t1 >= t2));
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1, 2, 3);
+ assert(!(t1 < t2));
+ assert((t1 <= t2));
+ assert(!(t1 > t2));
+ assert((t1 >= t2));
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(0.9, 2, 3);
+ assert(!(t1 < t2));
+ assert(!(t1 <= t2));
+ assert((t1 > t2));
+ assert((t1 >= t2));
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1.1, 2, 3);
+ assert((t1 < t2));
+ assert((t1 <= t2));
+ assert(!(t1 > t2));
+ assert(!(t1 >= t2));
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1, 1, 3);
+ assert(!(t1 < t2));
+ assert(!(t1 <= t2));
+ assert((t1 > t2));
+ assert((t1 >= t2));
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1, 3, 3);
+ assert((t1 < t2));
+ assert((t1 <= t2));
+ assert(!(t1 > t2));
+ assert(!(t1 >= t2));
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1, 2, 2);
+ assert(!(t1 < t2));
+ assert(!(t1 <= t2));
+ assert((t1 > t2));
+ assert((t1 >= t2));
+ }
+ {
+ typedef std::tuple<long, int, double> T1;
+ typedef std::tuple<double, long, int> T2;
+ const T1 t1(1, 2, 3);
+ const T2 t2(1, 2, 4);
+ assert((t1 < t2));
+ assert((t1 <= t2));
+ assert(!(t1 > t2));
+ assert(!(t1 >= t2));
+ }
+#if TEST_STD_VER >= 14
+ {
+ using T1 = std::tuple<long, int, double>;
+ using T2 = std::tuple<double, long, int>;
+ constexpr T1 t1(1, 2, 3);
+ constexpr T2 t2(1, 2, 4);
+ assert((t1 < t2));
+ assert((t1 <= t2));
+ assert(!(t1 > t2));
+ assert(!(t1 >= t2));
+ }
+#endif
+#if TEST_STD_VER >= 23
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::pair<double, long>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.0, 2};
+ assert(!(t1 < t2));
+ assert(t1 <= t2);
+ assert(!(t1 > t2));
+ assert(t1 >= t2);
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::pair<double, long>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.0, 3};
+ assert(t1 < t2);
+ assert(t1 <= t2);
+ assert(!(t1 > t2));
+ assert(!(t1 >= t2));
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::array<double, 2>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.0, 2.0};
+ assert(!(t1 < t2));
+ assert(t1 <= t2);
+ assert(!(t1 > t2));
+ assert(t1 >= t2);
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::array<double, 2>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.1, 3.0};
+ assert(t1 < t2);
+ assert(t1 <= t2);
+ assert(!(t1 > t2));
+ assert(!(t1 >= t2));
+ }
+ {
+ using T1 = std::tuple<const int*, const int*>;
+ using T2 = std::ranges::subrange<const int*>;
+
+ int arr[1]{};
+ T1 t1{arr, arr + 1};
+ T2 t2{arr};
+ assert(!(t1 < t2));
+ assert(t1 <= t2);
+ assert(!(t1 > t2));
+ assert(t1 >= t2);
+ }
+ {
+ using T1 = std::tuple<const int*, const int*>;
+ using T2 = std::ranges::subrange<const int*>;
+
+ int arr[1]{};
+ T1 t1{arr + 1, arr + 1};
+ T2 t2{arr};
+ assert(!(t1 < t2));
+ assert(!(t1 <= t2));
+ assert(t1 > t2);
+ assert(t1 >= t2);
+ }
+ {
+ constexpr std::tuple<> t1{};
+ constexpr std::array<int*, 0> t2{};
+ assert(!(t1 < t2));
+ assert(t1 <= t2);
+ assert(!(t1 > t2));
+ assert(t1 >= t2);
+ }
+ {
+ constexpr std::tuple<> t1{};
+ constexpr std::array<double, 0> t2{};
+ assert(!(t1 < t2));
+ assert(t1 <= t2);
+ assert(!(t1 > t2));
+ assert(t1 >= t2);
+ }
+#endif
+#if TEST_STD_VER >= 26
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::complex<double>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.0, 2.0};
+ assert(!(t1 < t2));
+ assert(t1 <= t2);
+ assert(!(t1 > t2));
+ assert(t1 >= t2);
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::complex<double>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.1, 3.0};
+ assert(t1 < t2);
+ assert(t1 <= t2);
+ assert(!(t1 > t2));
+ assert(!(t1 >= t2));
+ }
#endif
+ return true;
+}
+
+int main(int, char**) {
+ test();
+#if TEST_STD_VER >= 14
+ static_assert(test(), "");
+#endif
return 0;
}
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/size_incompatible_three_way.compile.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/size_incompatible_three_way.compile.pass.cpp
index f9c72a1742e72..8eae8d675c0a5 100644
--- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/size_incompatible_three_way.compile.pass.cpp
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/size_incompatible_three_way.compile.pass.cpp
@@ -13,16 +13,31 @@
// template<class... TTypes, class... UTypes>
// auto
// operator<=>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+// template<tuple-like UTuple>
+// friend constexpr auto operator<=>(const tuple& t, const UTuple& u); // since C++23
// UNSUPPORTED: c++03, c++11, c++14, c++17
+#include <array>
+#include <complex>
+#include <ranges>
#include <tuple>
+#include <utility>
template <class T, class U>
concept can_compare = requires(T t, U u) { t <=> u; };
-typedef std::tuple<int> T1;
-typedef std::tuple<int, long> T2;
+using T1 = std::tuple<int>;
+using T2 = std::tuple<int, long>;
+using T1P = std::tuple<int*>;
static_assert(!can_compare<T1, T2>);
static_assert(!can_compare<T2, T1>);
+static_assert(!can_compare<T1, std::array<int, 2>>);
+static_assert(!can_compare<std::array<int, 2>, T1>);
+static_assert(!can_compare<T1, std::pair<int, long>>);
+static_assert(!can_compare<std::pair<int, long>, T1>);
+static_assert(!can_compare<T1, std::complex<double>>);
+static_assert(!can_compare<std::complex<double>, T1>);
+static_assert(!can_compare<T1P, std::ranges::subrange<int*>>);
+static_assert(!can_compare<std::ranges::subrange<int*>, T1P>);
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp
index d954314874c4f..cdee6f2b28f00 100644
--- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp
@@ -13,6 +13,8 @@
// template<class... TTypes, class... UTypes>
// auto
// operator<=>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+// template<tuple-like UTuple>
+// friend constexpr auto operator<=>(const tuple& t, const UTuple& u); // since C++23
// UNSUPPORTED: c++03, c++11, c++14, c++17
@@ -28,6 +30,15 @@ TEST_MSVC_DIAGNOSTIC_IGNORED(4242 4244)
#include <tuple>
#include <type_traits> // std::is_constant_evaluated
+#if TEST_STD_VER >= 23
+# include <array>
+# include <ranges>
+# include <utility>
+#endif
+#if TEST_STD_VER >= 26
+# include <complex>
+#endif
+
// A custom three-way result type
struct CustomEquality {
friend constexpr bool operator==(const CustomEquality&, int) noexcept { return true; }
@@ -36,6 +47,11 @@ struct CustomEquality {
};
constexpr bool test() {
+ struct WeakSpaceship {
+ constexpr bool operator==(const WeakSpaceship&) const { return true; }
+ constexpr std::weak_ordering operator<=>(const WeakSpaceship&) const { return std::weak_ordering::equivalent; }
+ };
+
// Empty tuple
{
typedef std::tuple<> T0;
@@ -135,23 +151,17 @@ constexpr bool test() {
ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::strong_ordering);
}
{
- struct WeakSpaceship {
- constexpr bool operator==(const WeakSpaceship&) const { return true; }
- constexpr std::weak_ordering operator<=>(const WeakSpaceship&) const { return std::weak_ordering::equivalent; }
- };
- {
- typedef std::tuple<int, unsigned int, WeakSpaceship> T1;
- typedef std::tuple<int, unsigned long, WeakSpaceship> T2;
- // Strongly ordered members and a weakly ordered member yields weak ordering.
- ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::weak_ordering);
- }
- {
- typedef std::tuple<unsigned int, int, WeakSpaceship> T1;
- typedef std::tuple<double, long, WeakSpaceship> T2;
- // Doubles are partially ordered, so one partial, one strong, and one weak ordering
- // yields partial ordering.
- ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
- }
+ typedef std::tuple<int, unsigned int, WeakSpaceship> T1;
+ typedef std::tuple<int, unsigned long, WeakSpaceship> T2;
+ // Strongly ordered members and a weakly ordered member yields weak ordering.
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::weak_ordering);
+ }
+ {
+ typedef std::tuple<unsigned int, int, WeakSpaceship> T1;
+ typedef std::tuple<double, long, WeakSpaceship> T2;
+ // Doubles are partially ordered, so one partial, one strong, and one weak ordering
+ // yields partial ordering.
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
}
{
struct NoSpaceship {
@@ -224,6 +234,134 @@ constexpr bool test() {
}
}
+// Heterogeneous comparisons enabled by P2165R4.
+#if TEST_STD_VER >= 23
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::pair<int, long>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1, 2};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::strong_ordering);
+ assert((t1 <=> t2) == std::strong_ordering::equal);
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::pair<int, long>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1, 0};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::strong_ordering);
+ assert((t1 <=> t2) == std::strong_ordering::greater);
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::pair<double, long>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.1, 3};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::partial_ordering);
+ assert((t1 <=> t2) == std::partial_ordering::less);
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::pair<double, long>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.0, 2};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::partial_ordering);
+ assert((t1 <=> t2) == std::partial_ordering::equivalent);
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::pair<double, long>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.1, 3};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::partial_ordering);
+ assert((t1 <=> t2) == std::partial_ordering::less);
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::array<double, 2>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.0, 2.0};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::partial_ordering);
+ assert((t1 <=> t2) == std::partial_ordering::equivalent);
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::array<double, 2>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.1, 3.0};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::partial_ordering);
+ assert((t1 <=> t2) == std::partial_ordering::less);
+ }
+ {
+ using T1 = std::tuple<const int*, const int*>;
+ using T2 = std::ranges::subrange<const int*>;
+
+ int arr[1]{};
+ T1 t1{arr, arr + 1};
+ T2 t2{arr};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::strong_ordering);
+ assert((t1 <=> t2) == std::strong_ordering::equal);
+ }
+ {
+ using T1 = std::tuple<const int*, const int*>;
+ using T2 = std::ranges::subrange<const int*>;
+
+ int arr[1]{};
+ T1 t1{arr + 1, arr + 1};
+ T2 t2{arr};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::strong_ordering);
+ assert((t1 <=> t2) == std::strong_ordering::greater);
+ }
+ {
+ constexpr std::tuple<WeakSpaceship, WeakSpaceship> t1{};
+ constexpr std::pair<WeakSpaceship, WeakSpaceship> t2{};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::weak_ordering);
+ assert((t1 <=> t2) == std::weak_ordering::equivalent);
+ }
+ {
+ constexpr std::tuple<WeakSpaceship, WeakSpaceship> t1{};
+ constexpr std::array<WeakSpaceship, 2> t2{};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::weak_ordering);
+ assert((t1 <=> t2) == std::weak_ordering::equivalent);
+ }
+ {
+ constexpr std::tuple<> t1{};
+ constexpr std::array<int*, 0> t2{};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::strong_ordering);
+ assert((t1 <=> t2) == std::strong_ordering::equal);
+ }
+ {
+ constexpr std::tuple<> t1{};
+ constexpr std::array<double, 0> t2{};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::strong_ordering);
+ assert((t1 <=> t2) == std::strong_ordering::equal);
+ }
+ {
+ constexpr std::tuple<> t1{};
+ constexpr std::array<WeakSpaceship, 0> t2{};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::strong_ordering);
+ assert((t1 <=> t2) == std::strong_ordering::equal);
+ }
+#endif
+#if TEST_STD_VER >= 26
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::complex<double>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.0, 2.0};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::partial_ordering);
+ assert((t1 <=> t2) == std::partial_ordering::equivalent);
+ }
+ {
+ using T1 = std::tuple<long, int>;
+ using T2 = std::complex<double>;
+ constexpr T1 t1{1, 2};
+ constexpr T2 t2{1.1, 3.0};
+ ASSERT_SAME_TYPE(decltype(t1 <=> t2), std::partial_ordering);
+ assert((t1 <=> t2) == std::partial_ordering::less);
+ }
+#endif
+
return true;
}
>From 244361023c97f68307cc9367b8c3d51895d7a80f Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34 at live.cn>
Date: Tue, 15 Jul 2025 16:48:26 +0800
Subject: [PATCH 2/8] [libc++] Set feature-test macro
`__cpp_lib_constrained_equality`
And add a release note for P2944R3 and P3379R0.
---
libcxx/docs/FeatureTestMacroTable.rst | 2 +-
libcxx/docs/ReleaseNotes/21.rst | 2 ++
libcxx/include/version | 2 +-
.../expected.version.compile.pass.cpp | 16 +++++-----------
.../optional.version.compile.pass.cpp | 16 +++++-----------
.../tuple.version.compile.pass.cpp | 16 +++++-----------
.../utility.version.compile.pass.cpp | 16 +++++-----------
.../variant.version.compile.pass.cpp | 16 +++++-----------
.../version.version.compile.pass.cpp | 16 +++++-----------
.../generate_feature_test_macro_components.py | 2 --
10 files changed, 34 insertions(+), 70 deletions(-)
diff --git a/libcxx/docs/FeatureTestMacroTable.rst b/libcxx/docs/FeatureTestMacroTable.rst
index 61805726a4ff0..a36848ebd24b4 100644
--- a/libcxx/docs/FeatureTestMacroTable.rst
+++ b/libcxx/docs/FeatureTestMacroTable.rst
@@ -432,7 +432,7 @@ Status
---------------------------------------------------------- -----------------
``__cpp_lib_constexpr_queue`` ``202502L``
---------------------------------------------------------- -----------------
- ``__cpp_lib_constrained_equality`` *unimplemented*
+ ``__cpp_lib_constrained_equality`` ``202411L``
---------------------------------------------------------- -----------------
``__cpp_lib_copyable_function`` *unimplemented*
---------------------------------------------------------- -----------------
diff --git a/libcxx/docs/ReleaseNotes/21.rst b/libcxx/docs/ReleaseNotes/21.rst
index 0bb73a1c0196d..b1fb9be2a6848 100644
--- a/libcxx/docs/ReleaseNotes/21.rst
+++ b/libcxx/docs/ReleaseNotes/21.rst
@@ -53,6 +53,8 @@ Implemented Papers
- P2711R1: Making multi-param constructors of ``views`` ``explicit`` (`Github <https://github.com/llvm/llvm-project/issues/105252>`__)
- P2770R0: Stashing stashing ``iterators`` for proper flattening (`Github <https://github.com/llvm/llvm-project/issues/105250>`__)
- P2655R3: ``common_reference_t`` of ``reference_wrapper`` Should Be a Reference Type (`Github <https://github.com/llvm/llvm-project/issues/105260>`__)
+- P2944R3: Comparisons for ``reference_wrapper`` (`Github <https://github.com/llvm/llvm-project/issues/105424>`__)
+- P3379R0: Constrain ``std::expected equality`` operators (`Github <https://github.com/llvm/llvm-project/issues/118135>`__)
Improvements and New Features
-----------------------------
diff --git a/libcxx/include/version b/libcxx/include/version
index d98049bd57046..aae9277a7dfc6 100644
--- a/libcxx/include/version
+++ b/libcxx/include/version
@@ -555,7 +555,7 @@ __cpp_lib_void_t 201411L <type_traits>
# define __cpp_lib_constexpr_new 202406L
# endif
# define __cpp_lib_constexpr_queue 202502L
-// # define __cpp_lib_constrained_equality 202411L
+# define __cpp_lib_constrained_equality 202411L
// # define __cpp_lib_copyable_function 202306L
// # define __cpp_lib_debugging 202311L
// # define __cpp_lib_default_template_type_for_algorithm_values 202403L
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/expected.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/expected.version.compile.pass.cpp
index 9c7a84f145dde..2115da20af369 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/expected.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/expected.version.compile.pass.cpp
@@ -93,17 +93,11 @@
#elif TEST_STD_VER > 23
-# if !defined(_LIBCPP_VERSION)
-# ifndef __cpp_lib_constrained_equality
-# error "__cpp_lib_constrained_equality should be defined in c++26"
-# endif
-# if __cpp_lib_constrained_equality != 202411L
-# error "__cpp_lib_constrained_equality should have the value 202411L in c++26"
-# endif
-# else
-# ifdef __cpp_lib_constrained_equality
-# error "__cpp_lib_constrained_equality should not be defined because it is unimplemented in libc++!"
-# endif
+# ifndef __cpp_lib_constrained_equality
+# error "__cpp_lib_constrained_equality should be defined in c++26"
+# endif
+# if __cpp_lib_constrained_equality != 202411L
+# error "__cpp_lib_constrained_equality should have the value 202411L in c++26"
# endif
# ifndef __cpp_lib_expected
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/optional.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/optional.version.compile.pass.cpp
index 32685972d6019..6e1ab17821074 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/optional.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/optional.version.compile.pass.cpp
@@ -119,17 +119,11 @@
#elif TEST_STD_VER > 23
-# if !defined(_LIBCPP_VERSION)
-# ifndef __cpp_lib_constrained_equality
-# error "__cpp_lib_constrained_equality should be defined in c++26"
-# endif
-# if __cpp_lib_constrained_equality != 202411L
-# error "__cpp_lib_constrained_equality should have the value 202411L in c++26"
-# endif
-# else
-# ifdef __cpp_lib_constrained_equality
-# error "__cpp_lib_constrained_equality should not be defined because it is unimplemented in libc++!"
-# endif
+# ifndef __cpp_lib_constrained_equality
+# error "__cpp_lib_constrained_equality should be defined in c++26"
+# endif
+# if __cpp_lib_constrained_equality != 202411L
+# error "__cpp_lib_constrained_equality should have the value 202411L in c++26"
# endif
# if !defined(_LIBCPP_VERSION)
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/tuple.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/tuple.version.compile.pass.cpp
index b583edfc43ad0..df30228802e8e 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/tuple.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/tuple.version.compile.pass.cpp
@@ -270,17 +270,11 @@
# error "__cpp_lib_constexpr_tuple should have the value 201811L in c++26"
# endif
-# if !defined(_LIBCPP_VERSION)
-# ifndef __cpp_lib_constrained_equality
-# error "__cpp_lib_constrained_equality should be defined in c++26"
-# endif
-# if __cpp_lib_constrained_equality != 202411L
-# error "__cpp_lib_constrained_equality should have the value 202411L in c++26"
-# endif
-# else
-# ifdef __cpp_lib_constrained_equality
-# error "__cpp_lib_constrained_equality should not be defined because it is unimplemented in libc++!"
-# endif
+# ifndef __cpp_lib_constrained_equality
+# error "__cpp_lib_constrained_equality should be defined in c++26"
+# endif
+# if __cpp_lib_constrained_equality != 202411L
+# error "__cpp_lib_constrained_equality should have the value 202411L in c++26"
# endif
# ifndef __cpp_lib_make_from_tuple
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/utility.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/utility.version.compile.pass.cpp
index 7dd3478576331..c11c3682ae9a3 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/utility.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/utility.version.compile.pass.cpp
@@ -401,17 +401,11 @@
# error "__cpp_lib_constexpr_utility should have the value 201811L in c++26"
# endif
-# if !defined(_LIBCPP_VERSION)
-# ifndef __cpp_lib_constrained_equality
-# error "__cpp_lib_constrained_equality should be defined in c++26"
-# endif
-# if __cpp_lib_constrained_equality != 202411L
-# error "__cpp_lib_constrained_equality should have the value 202411L in c++26"
-# endif
-# else
-# ifdef __cpp_lib_constrained_equality
-# error "__cpp_lib_constrained_equality should not be defined because it is unimplemented in libc++!"
-# endif
+# ifndef __cpp_lib_constrained_equality
+# error "__cpp_lib_constrained_equality should be defined in c++26"
+# endif
+# if __cpp_lib_constrained_equality != 202411L
+# error "__cpp_lib_constrained_equality should have the value 202411L in c++26"
# endif
# ifndef __cpp_lib_exchange_function
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/variant.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/variant.version.compile.pass.cpp
index 4a7b9f7431a81..30537dc97090b 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/variant.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/variant.version.compile.pass.cpp
@@ -99,17 +99,11 @@
#elif TEST_STD_VER > 23
-# if !defined(_LIBCPP_VERSION)
-# ifndef __cpp_lib_constrained_equality
-# error "__cpp_lib_constrained_equality should be defined in c++26"
-# endif
-# if __cpp_lib_constrained_equality != 202411L
-# error "__cpp_lib_constrained_equality should have the value 202411L in c++26"
-# endif
-# else
-# ifdef __cpp_lib_constrained_equality
-# error "__cpp_lib_constrained_equality should not be defined because it is unimplemented in libc++!"
-# endif
+# ifndef __cpp_lib_constrained_equality
+# error "__cpp_lib_constrained_equality should be defined in c++26"
+# endif
+# if __cpp_lib_constrained_equality != 202411L
+# error "__cpp_lib_constrained_equality should have the value 202411L in c++26"
# endif
# if !defined(_LIBCPP_VERSION)
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
index 222d562a19d63..53dfaaad626c7 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
@@ -6631,17 +6631,11 @@
# error "__cpp_lib_constexpr_vector should have the value 201907L in c++26"
# endif
-# if !defined(_LIBCPP_VERSION)
-# ifndef __cpp_lib_constrained_equality
-# error "__cpp_lib_constrained_equality should be defined in c++26"
-# endif
-# if __cpp_lib_constrained_equality != 202411L
-# error "__cpp_lib_constrained_equality should have the value 202411L in c++26"
-# endif
-# else
-# ifdef __cpp_lib_constrained_equality
-# error "__cpp_lib_constrained_equality should not be defined because it is unimplemented in libc++!"
-# endif
+# ifndef __cpp_lib_constrained_equality
+# error "__cpp_lib_constrained_equality should be defined in c++26"
+# endif
+# if __cpp_lib_constrained_equality != 202411L
+# error "__cpp_lib_constrained_equality should have the value 202411L in c++26"
# endif
# ifndef __cpp_lib_containers_ranges
diff --git a/libcxx/utils/generate_feature_test_macro_components.py b/libcxx/utils/generate_feature_test_macro_components.py
index 18eb8a8623748..714b5041ae505 100644
--- a/libcxx/utils/generate_feature_test_macro_components.py
+++ b/libcxx/utils/generate_feature_test_macro_components.py
@@ -442,11 +442,9 @@ def add_version_header(tc):
{
"name": "__cpp_lib_constrained_equality",
"values": {
- # "c++26": 202403, # P2944R3: Comparisons for reference_wrapper
"c++26": 202411, # P3379R0: Constrain std::expected equality operators
},
"headers": ["expected", "optional", "tuple", "utility", "variant"],
- "unimplemented": True,
},
{
"name": "__cpp_lib_containers_ranges",
>From d0b980829112598a093d8d72922e838a677c414d Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34 at live.cn>
Date: Tue, 15 Jul 2025 17:25:13 +0800
Subject: [PATCH 3/8] Potential workarounds for pre-CWG2369 Clang and module
builds
---
libcxx/include/tuple | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/libcxx/include/tuple b/libcxx/include/tuple
index 1ab451539f533..56720bfb2c32e 100644
--- a/libcxx/include/tuple
+++ b/libcxx/include/tuple
@@ -220,7 +220,9 @@ template <class... Types>
# include <__config>
# include <__cstddef/size_t.h>
# include <__fwd/array.h>
+# include <__fwd/complex.h>
# include <__fwd/pair.h>
+# include <__fwd/subrange.h>
# include <__fwd/tuple.h>
# include <__memory/allocator_arg_t.h>
# include <__memory/uses_allocator.h>
@@ -341,7 +343,7 @@ concept __tuple_like_no_tuple = __tuple_like<_Tp> && !__is_tuple_v<_Tp>;
template <class _Tp, class _Up, class _IndexSeq>
struct __tuple_common_comparison_category_impl {};
template <class _Tp, class _Up, size_t... _Indices>
- requires requires {
+ requires(tuple_size_v<_Tp> == tuple_size_v<_Up>) && requires {
typename common_comparison_category_t<
__synth_three_way_result<tuple_element_t<_Indices, _Tp>, tuple_element_t<_Indices, _Up>>...>;
}
>From 6ec602909310425ec47d93dee25635803806327c Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34 at live.cn>
Date: Wed, 16 Jul 2025 10:32:55 +0800
Subject: [PATCH 4/8] Tweak implementation of `operator==`
Use `if constexpr` and `__all`.
---
libcxx/include/tuple | 49 +++++++++++++++++++-------------------------
1 file changed, 21 insertions(+), 28 deletions(-)
diff --git a/libcxx/include/tuple b/libcxx/include/tuple
index 56720bfb2c32e..7cbb199da2870 100644
--- a/libcxx/include/tuple
+++ b/libcxx/include/tuple
@@ -291,34 +291,28 @@ _LIBCPP_BEGIN_NAMESPACE_STD
# ifndef _LIBCPP_CXX03_LANG
-template <size_t _Ip>
-struct __tuple_equal {
- template <class _Tp, class _Up>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp& __x, const _Up& __y) {
- return __tuple_equal<_Ip - 1>()(__x, __y) && std::get<_Ip - 1>(__x) == std::get<_Ip - 1>(__y);
- }
-
-# if _LIBCPP_STD_VER >= 26
- template <class _Tp, class _Up>
- static constexpr bool __can_compare =
- __tuple_equal<_Ip - 1>::template __can_compare<_Tp, _Up> && requires(const _Tp& __x, const _Up& __y) {
- { std::get<_Ip - 1>(__x) == std::get<_Ip - 1>(__y) } -> __boolean_testable;
- };
-# endif // _LIBCPP_STD_VER >= 26
-};
-
-template <>
-struct __tuple_equal<0> {
- template <class _Tp, class _Up>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp&, const _Up&) {
+template <size_t _Ip, class _Tp, class _Up>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool __tuple_compare_equal(const _Tp& __x, const _Up& __y) {
+ if constexpr (_Ip == 0)
return true;
- }
+ else
+ return std::__tuple_compare_equal<_Ip - 1>(__x, __y) && std::get<_Ip - 1>(__x) == std::get<_Ip - 1>(__y);
+}
# if _LIBCPP_STD_VER >= 26
- template <class _Tp, class _Up>
- static constexpr bool __can_compare = true;
+template <class _Tp, class _Up, class _IndexSeq>
+inline constexpr bool __can_tuple_compare_equal_impl = false;
+template <class _Tp, class _Up, size_t... _Is>
+ requires(tuple_size_v<_Tp> == tuple_size_v<_Up>)
+inline constexpr bool __can_tuple_compare_equal_impl<_Tp, _Up, index_sequence<_Is...>> =
+ __all<requires(const tuple_element_t<_Is, _Tp>& __t, const tuple_element_t<_Is, _Up>& __u) {
+ { __t == __u } -> __boolean_testable;
+ }...>::value;
+
+template <class _Tp, class _Up>
+inline constexpr bool __can_tuple_compare_equal =
+ __can_tuple_compare_equal_impl<_Tp, _Up, make_index_sequence<tuple_size_v<_Tp>>>;
# endif // _LIBCPP_STD_VER >= 26
-};
# if _LIBCPP_STD_VER >= 20
template <class _Ret, class _Tp, class _Up, size_t... _Is>
@@ -1069,12 +1063,11 @@ public:
template <__tuple_like_no_tuple _UTuple>
# if _LIBCPP_STD_VER >= 26
- requires(__tuple_equal<sizeof...(_Tp)>::template __can_compare<tuple, _UTuple>) &&
- (sizeof...(_Tp) == tuple_size_v<_UTuple>)
+ requires __can_tuple_compare_equal<tuple, _UTuple> && (sizeof...(_Tp) == tuple_size_v<_UTuple>)
# endif // _LIBCPP_STD_VER >= 26
_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const tuple& __x, const _UTuple& __y) {
static_assert(sizeof...(_Tp) == tuple_size_v<_UTuple>, "Can't compare tuple-like values of different sizes");
- return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
+ return std::__tuple_compare_equal<sizeof...(_Tp)>(__x, __y);
}
template <__tuple_like_no_tuple _UTuple>
@@ -1248,7 +1241,7 @@ template <class... _Tp, class... _Up>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
static_assert(sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
- return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
+ return std::__tuple_compare_equal<sizeof...(_Tp)>(__x, __y);
}
# if _LIBCPP_STD_VER >= 20
>From 1dec129ed2c9bfd4257137f9a68fcc7ec5bf1cf9 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34 at live.cn>
Date: Wed, 16 Jul 2025 10:34:57 +0800
Subject: [PATCH 5/8] Rename `_Indices` to simpler `_Is`
---
libcxx/include/tuple | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git a/libcxx/include/tuple b/libcxx/include/tuple
index 7cbb199da2870..12796647fca9b 100644
--- a/libcxx/include/tuple
+++ b/libcxx/include/tuple
@@ -336,14 +336,14 @@ concept __tuple_like_no_tuple = __tuple_like<_Tp> && !__is_tuple_v<_Tp>;
template <class _Tp, class _Up, class _IndexSeq>
struct __tuple_common_comparison_category_impl {};
-template <class _Tp, class _Up, size_t... _Indices>
+template <class _Tp, class _Up, size_t... _Is>
requires(tuple_size_v<_Tp> == tuple_size_v<_Up>) && requires {
typename common_comparison_category_t<
- __synth_three_way_result<tuple_element_t<_Indices, _Tp>, tuple_element_t<_Indices, _Up>>...>;
+ __synth_three_way_result<tuple_element_t<_Is, _Tp>, tuple_element_t<_Is, _Up>>...>;
}
-struct __tuple_common_comparison_category_impl<_Tp, _Up, index_sequence<_Indices...>> {
- using type _LIBCPP_NODEBUG = common_comparison_category_t<
- __synth_three_way_result<tuple_element_t<_Indices, _Tp>, tuple_element_t<_Indices, _Up>>...>;
+struct __tuple_common_comparison_category_impl<_Tp, _Up, index_sequence<_Is...>> {
+ using type _LIBCPP_NODEBUG =
+ common_comparison_category_t<__synth_three_way_result<tuple_element_t<_Is, _Tp>, tuple_element_t<_Is, _Up>>...>;
};
template <__tuple_like _Tp, __tuple_like _Up>
>From 8b7c412942872ffc764064e5889715cc5c8f9c19 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34 at live.cn>
Date: Wed, 16 Jul 2025 10:35:12 +0800
Subject: [PATCH 6/8] Add missed synopsis comments
---
libcxx/include/tuple | 5 +++++
1 file changed, 5 insertions(+)
diff --git a/libcxx/include/tuple b/libcxx/include/tuple
index 12796647fca9b..56e7baa3913b0 100644
--- a/libcxx/include/tuple
+++ b/libcxx/include/tuple
@@ -106,6 +106,11 @@ public:
void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...)); // constexpr in C++20
constexpr void swap(const tuple&) const noexcept(see-below); // C++23
+
+ template<tuple-like UTuple>
+ friend constexpr bool operator==(const tuple& t, const UTuple& u); // C++23
+ template<tuple-like UTuple>
+ friend constexpr auto operator<=>(const tuple& t, const UTuple& u); // C++23
};
>From 754c0c23e5e8e6ab707a4e62fac044c0181d2796 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34 at live.cn>
Date: Wed, 16 Jul 2025 10:35:47 +0800
Subject: [PATCH 7/8] Unconditionally include headers in
`tuple.rel/three_way.pass.cpp`
---
.../tuple/tuple.tuple/tuple.rel/three_way.pass.cpp | 13 ++++---------
1 file changed, 4 insertions(+), 9 deletions(-)
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp
index cdee6f2b28f00..697d0c03eefe2 100644
--- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp
@@ -24,20 +24,15 @@ TEST_CLANG_DIAGNOSTIC_IGNORED("-Wsign-compare")
TEST_GCC_DIAGNOSTIC_IGNORED("-Wsign-compare")
TEST_MSVC_DIAGNOSTIC_IGNORED(4242 4244)
+#include <array>
#include <cassert>
#include <compare>
+#include <complex>
#include <limits>
+#include <ranges>
#include <tuple>
#include <type_traits> // std::is_constant_evaluated
-
-#if TEST_STD_VER >= 23
-# include <array>
-# include <ranges>
-# include <utility>
-#endif
-#if TEST_STD_VER >= 26
-# include <complex>
-#endif
+#include <utility>
// A custom three-way result type
struct CustomEquality {
>From 23a8091e75ab8c21128101ced4caf399cf24ff58 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34 at live.cn>
Date: Sat, 19 Jul 2025 14:54:40 +0800
Subject: [PATCH 8/8] Apply @ldionne's suggestions
- include `<__fwd/get.h>` to get all `std::get` overloads
- eliminate `__can_tuple_compare_equal_impl` layer
---
libcxx/include/tuple | 13 ++++---------
1 file changed, 4 insertions(+), 9 deletions(-)
diff --git a/libcxx/include/tuple b/libcxx/include/tuple
index 56e7baa3913b0..1b35e6360dc2a 100644
--- a/libcxx/include/tuple
+++ b/libcxx/include/tuple
@@ -225,9 +225,8 @@ template <class... Types>
# include <__config>
# include <__cstddef/size_t.h>
# include <__fwd/array.h>
-# include <__fwd/complex.h>
+# include <__fwd/get.h>
# include <__fwd/pair.h>
-# include <__fwd/subrange.h>
# include <__fwd/tuple.h>
# include <__memory/allocator_arg_t.h>
# include <__memory/uses_allocator.h>
@@ -305,18 +304,14 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool __tuple_compare_equal(c
}
# if _LIBCPP_STD_VER >= 26
-template <class _Tp, class _Up, class _IndexSeq>
-inline constexpr bool __can_tuple_compare_equal_impl = false;
+template <class _Tp, class _Up, class _IndexSeq = make_index_sequence<tuple_size_v<_Tp>>>
+inline constexpr bool __can_tuple_compare_equal = false;
template <class _Tp, class _Up, size_t... _Is>
requires(tuple_size_v<_Tp> == tuple_size_v<_Up>)
-inline constexpr bool __can_tuple_compare_equal_impl<_Tp, _Up, index_sequence<_Is...>> =
+inline constexpr bool __can_tuple_compare_equal<_Tp, _Up, index_sequence<_Is...>> =
__all<requires(const tuple_element_t<_Is, _Tp>& __t, const tuple_element_t<_Is, _Up>& __u) {
{ __t == __u } -> __boolean_testable;
}...>::value;
-
-template <class _Tp, class _Up>
-inline constexpr bool __can_tuple_compare_equal =
- __can_tuple_compare_equal_impl<_Tp, _Up, make_index_sequence<tuple_size_v<_Tp>>>;
# endif // _LIBCPP_STD_VER >= 26
# if _LIBCPP_STD_VER >= 20
More information about the libcxx-commits
mailing list