[libcxx-commits] [libcxx] [libc++][concepts] P2404R3: Move-only types for equality_comparable_with, totally_ordered_with, and three_way_comparable_with (PR #99420)
Janet Cobb via libcxx-commits
libcxx-commits at lists.llvm.org
Thu Jul 18 12:00:48 PDT 2024
https://github.com/randomnetcat updated https://github.com/llvm/llvm-project/pull/99420
>From 363738b998edbb39e6836a320d9ebc9c0c3cb28d Mon Sep 17 00:00:00 2001
From: Janet Cobb <git at randomcat.org>
Date: Wed, 17 Jul 2024 21:53:02 -0400
Subject: [PATCH 1/9] P2404R3: Move-only types for relational concepts
---
libcxx/docs/ReleaseNotes/19.rst | 1 +
libcxx/docs/Status/Cxx23Papers.csv | 2 +-
libcxx/docs/Status/SpaceshipPapers.csv | 2 +-
libcxx/include/CMakeLists.txt | 1 +
.../include/__compare/three_way_comparable.h | 17 +++++++
.../__concepts/comparison_common_type.h | 39 ++++++++++++++++
.../include/__concepts/equality_comparable.h | 19 ++++++++
libcxx/include/module.modulemap | 45 ++++++++++---------
.../equality_comparable_with.compile.pass.cpp | 10 +++++
...three_way_comparable_with.compile.pass.cpp | 28 ++++++++++++
libcxx/test/support/compare_types.h | 23 ++++++++++
11 files changed, 163 insertions(+), 24 deletions(-)
create mode 100644 libcxx/include/__concepts/comparison_common_type.h
diff --git a/libcxx/docs/ReleaseNotes/19.rst b/libcxx/docs/ReleaseNotes/19.rst
index e6d8acb74aeb2..1699c97652488 100644
--- a/libcxx/docs/ReleaseNotes/19.rst
+++ b/libcxx/docs/ReleaseNotes/19.rst
@@ -55,6 +55,7 @@ Implemented Papers
- P2231R1 - Missing ``constexpr`` in ``std::optional`` and ``std::variant``
- P0019R8 - ``std::atomic_ref``
- P2389R2 - Alias template ``dims`` for the ``extents`` of ``mdspan``
+- P2404R3 - Move-only types for ``equality_comparable_with``, ``totally_ordered_with``, and ``three_way_comparable_with``
Improvements and New Features
-----------------------------
diff --git a/libcxx/docs/Status/Cxx23Papers.csv b/libcxx/docs/Status/Cxx23Papers.csv
index 4f589cd938d7c..bc13e4d9ebfd3 100644
--- a/libcxx/docs/Status/Cxx23Papers.csv
+++ b/libcxx/docs/Status/Cxx23Papers.csv
@@ -67,7 +67,7 @@
"`P2302R4 <https://wg21.link/P2302R4>`__","LWG","``std::ranges::contains``","July 2022","|Complete|","19.0","|ranges|"
"`P2322R6 <https://wg21.link/P2322R6>`__","LWG","``ranges::fold``","July 2022","","","|ranges|"
"`P2374R4 <https://wg21.link/P2374R4>`__","LWG","``views::cartesian_product``","July 2022","","","|ranges|"
-"`P2404R3 <https://wg21.link/P2404R3>`__","LWG","Move-only types for ``equality_comparable_with``, ``totally_ordered_with``, and ``three_way_comparable_with``","July 2022","",""
+"`P2404R3 <https://wg21.link/P2404R3>`__","LWG","Move-only types for ``equality_comparable_with``, ``totally_ordered_with``, and ``three_way_comparable_with``","July 2022","|Complete|","19.0"
"`P2408R5 <https://wg21.link/P2408R5>`__","LWG","Ranges iterators as inputs to non-Ranges algorithms","July 2022","","","|ranges|"
"`P2417R2 <https://wg21.link/P2417R2>`__","LWG","A more ``constexpr`` ``bitset``","July 2022","|Complete|","16.0"
"`P2419R2 <https://wg21.link/P2419R2>`__","LWG","Clarify handling of encodings in localized formatting of chrono types","July 2022","",""
diff --git a/libcxx/docs/Status/SpaceshipPapers.csv b/libcxx/docs/Status/SpaceshipPapers.csv
index 39e1f968c1754..5fbf6a53b6db7 100644
--- a/libcxx/docs/Status/SpaceshipPapers.csv
+++ b/libcxx/docs/Status/SpaceshipPapers.csv
@@ -1,6 +1,6 @@
"Number","Name","Status","First released version"
`P1614R2 <https://wg21.link/P1614R2>`_,The Mothership has Landed,|In Progress|,
-`P2404R3 <https://wg21.link/P2404R3>`_,"Relaxing ``equality_comparable_with``'s, ``totally_ordered_with``'s, and ``three_way_comparable_with``'s common reference requirements to support move-only types",,
+`P2404R3 <https://wg21.link/P2404R3>`_,"Relaxing ``equality_comparable_with``'s, ``totally_ordered_with``'s, and ``three_way_comparable_with``'s common reference requirements to support move-only types","|Complete|","19.0"
`LWG3330 <https://wg21.link/LWG3330>`_,Include ``<compare>`` from most library headers,"|Complete|","13.0"
`LWG3347 <https://wg21.link/LWG3347>`_,"``std::pair<T, U>`` now requires ``T`` and ``U`` to be *less-than-comparable*",|Nothing To Do|,
`LWG3350 <https://wg21.link/LWG3350>`_,Simplify return type of ``lexicographical_compare_three_way``,|Nothing To Do|,
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index cd64fe91449c2..e618847b1e27c 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -296,6 +296,7 @@ set(files
__concepts/class_or_enum.h
__concepts/common_reference_with.h
__concepts/common_with.h
+ __concepts/comparison_common_type.h
__concepts/constructible.h
__concepts/convertible_to.h
__concepts/copyable.h
diff --git a/libcxx/include/__compare/three_way_comparable.h b/libcxx/include/__compare/three_way_comparable.h
index 7a44ea9158a6f..3b14725be3309 100644
--- a/libcxx/include/__compare/three_way_comparable.h
+++ b/libcxx/include/__compare/three_way_comparable.h
@@ -12,6 +12,7 @@
#include <__compare/common_comparison_category.h>
#include <__compare/ordering.h>
#include <__concepts/common_reference_with.h>
+#include <__concepts/comparison_common_type.h>
#include <__concepts/equality_comparable.h>
#include <__concepts/same_as.h>
#include <__concepts/totally_ordered.h>
@@ -37,6 +38,20 @@ concept three_way_comparable =
{ __a <=> __b } -> __compares_as<_Cat>;
};
+# if _LIBCPP_STD_VER >= 23
+
+template <class _Tp, class _Up, class _cat = partial_ordering>
+concept three_way_comparable_with =
+ three_way_comparable<_Tp, _cat> && three_way_comparable<_Up, _cat> && __comparison_common_type_with<_Tp, _Up> &&
+ three_way_comparable<common_reference_t<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>, _cat> &&
+ __weakly_equality_comparable_with<_Tp, _Up> && __partially_ordered_with<_Tp, _Up> &&
+ requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
+ { __t <=> __u } -> __compares_as<_cat>;
+ { __u <=> __t } -> __compares_as<_cat>;
+ };
+
+# else
+
template <class _Tp, class _Up, class _Cat = partial_ordering>
concept three_way_comparable_with =
three_way_comparable<_Tp, _Cat> && three_way_comparable<_Up, _Cat> &&
@@ -48,6 +63,8 @@ concept three_way_comparable_with =
{ __u <=> __t } -> __compares_as<_Cat>;
};
+# endif // _LIBCPP_STD_VER >= 23
+
#endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__concepts/comparison_common_type.h b/libcxx/include/__concepts/comparison_common_type.h
new file mode 100644
index 0000000000000..a1f246d2a6dca
--- /dev/null
+++ b/libcxx/include/__concepts/comparison_common_type.h
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CONCEPTS_COMPARISON_COMMON_TYPE_H
+#define _LIBCPP___CONCEPTS_COMPARISON_COMMON_TYPE_H
+
+#include "__concepts/convertible_to.h"
+#include "__concepts/same_as.h"
+#include "__config"
+#include "__type_traits/common_reference.h"
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Tp, class _Up, class _C = common_reference_t<const _Tp&, const _Up&>>
+concept __comparison_common_type_with_impl =
+ same_as<common_reference_t<const _Tp&, const _Up&>, common_reference_t<const _Up&, const _Tp&>> && requires {
+ requires convertible_to<const _Tp&, const _C&> || convertible_to<_Tp, const _C&>;
+ requires convertible_to<const _Up&, const _C&> || convertible_to<_Up, const _C&>;
+ };
+
+template <class _Tp, class _Up>
+concept __comparison_common_type_with = __comparison_common_type_with_impl<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___CONCEPTS_COMPARISON_COMMON_TYPE_H
diff --git a/libcxx/include/__concepts/equality_comparable.h b/libcxx/include/__concepts/equality_comparable.h
index 278fc76409289..1904b2e451a8d 100644
--- a/libcxx/include/__concepts/equality_comparable.h
+++ b/libcxx/include/__concepts/equality_comparable.h
@@ -11,6 +11,7 @@
#include <__concepts/boolean_testable.h>
#include <__concepts/common_reference_with.h>
+#include <__concepts/comparison_common_type.h>
#include <__config>
#include <__type_traits/common_reference.h>
#include <__type_traits/make_const_lvalue_ref.h>
@@ -37,6 +38,22 @@ concept __weakly_equality_comparable_with =
template <class _Tp>
concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
+# if _LIBCPP_STD_VER >= 23
+
+// clang-format off
+template <class _Tp, class _Up>
+concept equality_comparable_with =
+ equality_comparable<_Tp> && equality_comparable<_Up> &&
+ __comparison_common_type_with<_Tp, _Up> &&
+ equality_comparable<
+ common_reference_t<
+ __make_const_lvalue_ref<_Tp>,
+ __make_const_lvalue_ref<_Up>>> &&
+ __weakly_equality_comparable_with<_Tp, _Up>;
+// clang-format on
+
+# else
+
// clang-format off
template <class _Tp, class _Up>
concept equality_comparable_with =
@@ -49,6 +66,8 @@ concept equality_comparable_with =
__weakly_equality_comparable_with<_Tp, _Up>;
// clang-format on
+# endif // _LIBCPP_STD_VER >= 23
+
#endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index f4aaa14c1c2ee..eabb32daf2c96 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -1173,43 +1173,44 @@ module std_private_compare_weak_order [system] { header "__c
module std_private_complex_complex_fwd [system] { header "__fwd/complex.h" }
-module std_private_concepts_arithmetic [system] { header "__concepts/arithmetic.h" }
-module std_private_concepts_assignable [system] { header "__concepts/assignable.h" }
-module std_private_concepts_boolean_testable [system] { header "__concepts/boolean_testable.h" }
-module std_private_concepts_class_or_enum [system] { header "__concepts/class_or_enum.h" }
-module std_private_concepts_common_reference_with [system] { header "__concepts/common_reference_with.h" }
-module std_private_concepts_common_with [system] { header "__concepts/common_with.h" }
-module std_private_concepts_constructible [system] {
+module std_private_concepts_arithmetic [system] { header "__concepts/arithmetic.h" }
+module std_private_concepts_assignable [system] { header "__concepts/assignable.h" }
+module std_private_concepts_boolean_testable [system] { header "__concepts/boolean_testable.h" }
+module std_private_concepts_class_or_enum [system] { header "__concepts/class_or_enum.h" }
+module std_private_concepts_common_reference_with [system] { header "__concepts/common_reference_with.h" }
+module std_private_concepts_common_with [system] { header "__concepts/common_with.h" }
+module std_private_cooncepts_comparison_common_type [system] { header "__concepts/comparison_common_type.h" }
+module std_private_concepts_constructible [system] {
header "__concepts/constructible.h"
export std_private_concepts_destructible
}
-module std_private_concepts_convertible_to [system] { header "__concepts/convertible_to.h" }
-module std_private_concepts_copyable [system] { header "__concepts/copyable.h" }
-module std_private_concepts_derived_from [system] { header "__concepts/derived_from.h" }
-module std_private_concepts_destructible [system] {
+module std_private_concepts_convertible_to [system] { header "__concepts/convertible_to.h" }
+module std_private_concepts_copyable [system] { header "__concepts/copyable.h" }
+module std_private_concepts_derived_from [system] { header "__concepts/derived_from.h" }
+module std_private_concepts_destructible [system] {
header "__concepts/destructible.h"
export std_private_type_traits_is_nothrow_destructible
}
-module std_private_concepts_different_from [system] { header "__concepts/different_from.h" }
-module std_private_concepts_equality_comparable [system] {
+module std_private_concepts_different_from [system] { header "__concepts/different_from.h" }
+module std_private_concepts_equality_comparable [system] {
header "__concepts/equality_comparable.h"
export std_private_type_traits_common_reference
}
-module std_private_concepts_invocable [system] { header "__concepts/invocable.h" }
-module std_private_concepts_movable [system] {
+module std_private_concepts_invocable [system] { header "__concepts/invocable.h" }
+module std_private_concepts_movable [system] {
header "__concepts/movable.h"
export std_private_type_traits_is_object
}
-module std_private_concepts_predicate [system] { header "__concepts/predicate.h" }
-module std_private_concepts_regular [system] { header "__concepts/regular.h" }
-module std_private_concepts_relation [system] { header "__concepts/relation.h" }
-module std_private_concepts_same_as [system] {
+module std_private_concepts_predicate [system] { header "__concepts/predicate.h" }
+module std_private_concepts_regular [system] { header "__concepts/regular.h" }
+module std_private_concepts_relation [system] { header "__concepts/relation.h" }
+module std_private_concepts_same_as [system] {
header "__concepts/same_as.h"
export std_private_type_traits_is_same
}
-module std_private_concepts_semiregular [system] { header "__concepts/semiregular.h" }
-module std_private_concepts_swappable [system] { header "__concepts/swappable.h" }
-module std_private_concepts_totally_ordered [system] { header "__concepts/totally_ordered.h" }
+module std_private_concepts_semiregular [system] { header "__concepts/semiregular.h" }
+module std_private_concepts_swappable [system] { header "__concepts/swappable.h" }
+module std_private_concepts_totally_ordered [system] { header "__concepts/totally_ordered.h" }
module std_private_condition_variable_condition_variable [system] {
header "__condition_variable/condition_variable.h"
diff --git a/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp b/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
index e0edd1f332f81..45e3e88a10d14 100644
--- a/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
+++ b/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
@@ -1119,4 +1119,14 @@ static_assert(
std::common_reference_with<one_way_ne const&, explicit_operators const&>);
static_assert(
!check_equality_comparable_with<one_way_ne, explicit_operators>());
+
+#if TEST_STD_VER >= 23
+static_assert(check_equality_comparable_with<move_only_equality_with_int, int>());
+static_assert(check_equality_comparable_with<std::unique_ptr<int>, std::nullptr_t>());
+#else
+static_assert(!check_equality_comparable_with<move_only_equality_with_int, int>());
+static_assert(!check_equality_comparable_with<std::unique_ptr<int>, std::nullptr_t>());
+#endif // TEST_STD_VER >= 23
+
+static_assert(!check_equality_comparable_with<immobile_comparable_with_int, int>());
} // namespace types_fit_for_purpose
diff --git a/libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp b/libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp
index 50d9722aa29c0..2920240dddf55 100644
--- a/libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp
+++ b/libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp
@@ -14,6 +14,7 @@
#include <compare>
#include "compare_types.h"
+#include "test_macros.h"
template <class T, class U = T, typename Cat = std::partial_ordering>
constexpr bool check_three_way_comparable_with() {
@@ -223,4 +224,31 @@ struct SpaceshipNonConstArgument {
};
static_assert(!check_three_way_comparable_with<SpaceshipNonConstArgument>());
+
+struct MoveOnlyIntComparable {
+ MoveOnlyIntComparable(int) {}
+
+ MoveOnlyIntComparable(MoveOnlyIntComparable&&) = default;
+ MoveOnlyIntComparable& operator=(MoveOnlyIntComparable&&) = default;
+
+ friend auto operator<=>(MoveOnlyIntComparable const&, MoveOnlyIntComparable const&) = default;
+};
+
+#if TEST_STD_VER >= 23
+static_assert(check_three_way_comparable_with<MoveOnlyIntComparable, int>());
+#else
+static_assert(!check_three_way_comparable_with<MoveOnlyIntComparable, int>());
+#endif // TEST_STD_VER >= 23
+
+struct ImmobileIntComparable {
+ ImmobileIntComparable(int) {}
+
+ ImmobileIntComparable(ImmobileIntComparable&&) = delete;
+ ImmobileIntComparable& operator=(ImmobileIntComparable&&) = delete;
+
+ friend auto operator<=>(ImmobileIntComparable const&, ImmobileIntComparable const&) = default;
+};
+
+static_assert(!check_three_way_comparable_with<ImmobileIntComparable, int>());
+
} // namespace user_defined
diff --git a/libcxx/test/support/compare_types.h b/libcxx/test/support/compare_types.h
index 8155f6221540c..eea219d033ae9 100644
--- a/libcxx/test/support/compare_types.h
+++ b/libcxx/test/support/compare_types.h
@@ -529,4 +529,27 @@ struct ForwardingTestObject {
constexpr bool operator>=(const ForwardingTestObject&) const& { return false; }
};
+struct move_only_equality_with_int {
+ move_only_equality_with_int(int);
+
+ move_only_equality_with_int(move_only_equality_with_int&&) = default;
+ move_only_equality_with_int& operator=(move_only_equality_with_int&&) = default;
+
+ move_only_equality_with_int(move_only_equality_with_int const&) = delete;
+ move_only_equality_with_int& operator=(move_only_equality_with_int const&) = delete;
+
+ friend bool operator==(move_only_equality_with_int const&, move_only_equality_with_int const&) = default;
+ friend bool operator==(move_only_equality_with_int const&, int);
+};
+
+struct immobile_comparable_with_int {
+ immobile_comparable_with_int(int);
+
+ immobile_comparable_with_int(immobile_comparable_with_int&&) = delete;
+ immobile_comparable_with_int& operator=(immobile_comparable_with_int&&) = delete;
+
+ friend bool operator==(immobile_comparable_with_int const&, immobile_comparable_with_int const&) = default;
+ friend bool operator==(immobile_comparable_with_int const&, int);
+};
+
#endif // TEST_SUPPORT_COMPARE_TYPES_H
>From 400144dbc59f68edb96caacac12e8a6b4bac3352 Mon Sep 17 00:00:00 2001
From: Janet Cobb <git at randomcat.org>
Date: Wed, 17 Jul 2024 23:28:10 -0400
Subject: [PATCH 2/9] Fix _Cat capitalization
---
libcxx/include/__compare/three_way_comparable.h | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git a/libcxx/include/__compare/three_way_comparable.h b/libcxx/include/__compare/three_way_comparable.h
index 3b14725be3309..f43c6fb010332 100644
--- a/libcxx/include/__compare/three_way_comparable.h
+++ b/libcxx/include/__compare/three_way_comparable.h
@@ -40,14 +40,14 @@ concept three_way_comparable =
# if _LIBCPP_STD_VER >= 23
-template <class _Tp, class _Up, class _cat = partial_ordering>
+template <class _Tp, class _Up, class _Cat = partial_ordering>
concept three_way_comparable_with =
- three_way_comparable<_Tp, _cat> && three_way_comparable<_Up, _cat> && __comparison_common_type_with<_Tp, _Up> &&
- three_way_comparable<common_reference_t<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>, _cat> &&
+ three_way_comparable<_Tp, _Cat> && three_way_comparable<_Up, _Cat> && __comparison_common_type_with<_Tp, _Up> &&
+ three_way_comparable<common_reference_t<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>, _Cat> &&
__weakly_equality_comparable_with<_Tp, _Up> && __partially_ordered_with<_Tp, _Up> &&
requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
- { __t <=> __u } -> __compares_as<_cat>;
- { __u <=> __t } -> __compares_as<_cat>;
+ { __t <=> __u } -> __compares_as<_Cat>;
+ { __u <=> __t } -> __compares_as<_Cat>;
};
# else
>From b03940ef26d99003b5858c2420875453003dbf2e Mon Sep 17 00:00:00 2001
From: Janet Cobb <git at randomcat.org>
Date: Wed, 17 Jul 2024 23:31:09 -0400
Subject: [PATCH 3/9] Make test class naming consistent
---
.../equality_comparable_with.compile.pass.cpp | 2 +-
libcxx/test/support/compare_types.h | 12 ++++++------
2 files changed, 7 insertions(+), 7 deletions(-)
diff --git a/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp b/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
index 45e3e88a10d14..9cc7d38d1c490 100644
--- a/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
+++ b/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
@@ -1128,5 +1128,5 @@ static_assert(!check_equality_comparable_with<move_only_equality_with_int, int>(
static_assert(!check_equality_comparable_with<std::unique_ptr<int>, std::nullptr_t>());
#endif // TEST_STD_VER >= 23
-static_assert(!check_equality_comparable_with<immobile_comparable_with_int, int>());
+static_assert(!check_equality_comparable_with<immobile_equality_with_int, int>());
} // namespace types_fit_for_purpose
diff --git a/libcxx/test/support/compare_types.h b/libcxx/test/support/compare_types.h
index eea219d033ae9..ea24454594110 100644
--- a/libcxx/test/support/compare_types.h
+++ b/libcxx/test/support/compare_types.h
@@ -542,14 +542,14 @@ struct move_only_equality_with_int {
friend bool operator==(move_only_equality_with_int const&, int);
};
-struct immobile_comparable_with_int {
- immobile_comparable_with_int(int);
+struct immobile_equality_with_int {
+ immobile_equality_with_int(int);
- immobile_comparable_with_int(immobile_comparable_with_int&&) = delete;
- immobile_comparable_with_int& operator=(immobile_comparable_with_int&&) = delete;
+ immobile_equality_with_int(immobile_equality_with_int&&) = delete;
+ immobile_equality_with_int& operator=(immobile_equality_with_int&&) = delete;
- friend bool operator==(immobile_comparable_with_int const&, immobile_comparable_with_int const&) = default;
- friend bool operator==(immobile_comparable_with_int const&, int);
+ friend bool operator==(immobile_equality_with_int const&, immobile_equality_with_int const&) = default;
+ friend bool operator==(immobile_equality_with_int const&, int);
};
#endif // TEST_SUPPORT_COMPARE_TYPES_H
>From 35d032afa35a5c56303966a91c793b9a76016dca Mon Sep 17 00:00:00 2001
From: Janet Cobb <git at randomcat.org>
Date: Thu, 18 Jul 2024 10:13:09 -0400
Subject: [PATCH 4/9] immobile -> nonmovable
---
.../equality_comparable_with.compile.pass.cpp | 2 +-
.../three_way_comparable_with.compile.pass.cpp | 12 ++++++------
libcxx/test/support/compare_types.h | 12 ++++++------
3 files changed, 13 insertions(+), 13 deletions(-)
diff --git a/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp b/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
index 9cc7d38d1c490..bdb42249b8a27 100644
--- a/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
+++ b/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
@@ -1128,5 +1128,5 @@ static_assert(!check_equality_comparable_with<move_only_equality_with_int, int>(
static_assert(!check_equality_comparable_with<std::unique_ptr<int>, std::nullptr_t>());
#endif // TEST_STD_VER >= 23
-static_assert(!check_equality_comparable_with<immobile_equality_with_int, int>());
+static_assert(!check_equality_comparable_with<nonmovable_equality_with_int, int>());
} // namespace types_fit_for_purpose
diff --git a/libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp b/libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp
index 2920240dddf55..ee3284d42f540 100644
--- a/libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp
+++ b/libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp
@@ -240,15 +240,15 @@ static_assert(check_three_way_comparable_with<MoveOnlyIntComparable, int>());
static_assert(!check_three_way_comparable_with<MoveOnlyIntComparable, int>());
#endif // TEST_STD_VER >= 23
-struct ImmobileIntComparable {
- ImmobileIntComparable(int) {}
+struct NonMovableIntComparable {
+ NonMovableIntComparable(int) {}
- ImmobileIntComparable(ImmobileIntComparable&&) = delete;
- ImmobileIntComparable& operator=(ImmobileIntComparable&&) = delete;
+ NonMovableIntComparable(NonMovableIntComparable&&) = delete;
+ NonMovableIntComparable& operator=(NonMovableIntComparable&&) = delete;
- friend auto operator<=>(ImmobileIntComparable const&, ImmobileIntComparable const&) = default;
+ friend auto operator<=>(NonMovableIntComparable const&, NonMovableIntComparable const&) = default;
};
-static_assert(!check_three_way_comparable_with<ImmobileIntComparable, int>());
+static_assert(!check_three_way_comparable_with<NonMovableIntComparable, int>());
} // namespace user_defined
diff --git a/libcxx/test/support/compare_types.h b/libcxx/test/support/compare_types.h
index ea24454594110..62203318be725 100644
--- a/libcxx/test/support/compare_types.h
+++ b/libcxx/test/support/compare_types.h
@@ -542,14 +542,14 @@ struct move_only_equality_with_int {
friend bool operator==(move_only_equality_with_int const&, int);
};
-struct immobile_equality_with_int {
- immobile_equality_with_int(int);
+struct nonmovable_equality_with_int {
+ nonmovable_equality_with_int(int);
- immobile_equality_with_int(immobile_equality_with_int&&) = delete;
- immobile_equality_with_int& operator=(immobile_equality_with_int&&) = delete;
+ nonmovable_equality_with_int(nonmovable_equality_with_int&&) = delete;
+ nonmovable_equality_with_int& operator=(nonmovable_equality_with_int&&) = delete;
- friend bool operator==(immobile_equality_with_int const&, immobile_equality_with_int const&) = default;
- friend bool operator==(immobile_equality_with_int const&, int);
+ friend bool operator==(nonmovable_equality_with_int const&, nonmovable_equality_with_int const&) = default;
+ friend bool operator==(nonmovable_equality_with_int const&, int);
};
#endif // TEST_SUPPORT_COMPARE_TYPES_H
>From b87e6aafbf348eb8bd897aff45de7f6e667ffdcf Mon Sep 17 00:00:00 2001
From: Janet Cobb <git at randomcat.org>
Date: Thu, 18 Jul 2024 10:16:29 -0400
Subject: [PATCH 5/9] _C -> _CommonRef
---
libcxx/include/__concepts/comparison_common_type.h | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/libcxx/include/__concepts/comparison_common_type.h b/libcxx/include/__concepts/comparison_common_type.h
index a1f246d2a6dca..ed95ee3a66700 100644
--- a/libcxx/include/__concepts/comparison_common_type.h
+++ b/libcxx/include/__concepts/comparison_common_type.h
@@ -22,11 +22,11 @@ _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 23
-template <class _Tp, class _Up, class _C = common_reference_t<const _Tp&, const _Up&>>
+template <class _Tp, class _Up, class _CommonRef = common_reference_t<const _Tp&, const _Up&>>
concept __comparison_common_type_with_impl =
same_as<common_reference_t<const _Tp&, const _Up&>, common_reference_t<const _Up&, const _Tp&>> && requires {
- requires convertible_to<const _Tp&, const _C&> || convertible_to<_Tp, const _C&>;
- requires convertible_to<const _Up&, const _C&> || convertible_to<_Up, const _C&>;
+ requires convertible_to<const _Tp&, const _CommonRef&> || convertible_to<_Tp, const _CommonRef&>;
+ requires convertible_to<const _Up&, const _CommonRef&> || convertible_to<_Up, const _CommonRef&>;
};
template <class _Tp, class _Up>
>From d5ff4aab7751d1bb4e38f2cc5dc87beeb014ce14 Mon Sep 17 00:00:00 2001
From: Janet Cobb <git at randomcat.org>
Date: Thu, 18 Jul 2024 11:53:15 -0400
Subject: [PATCH 6/9] Update other comparison tests
---
.../ranges_partial_sort_copy.pass.cpp | 21 +++++++++++++++++--
.../range.cmp/equal_to.pass.cpp | 7 ++++++-
.../range.cmp/greater.pass.cpp | 7 ++++++-
.../range.cmp/greater_equal.pass.cpp | 7 ++++++-
.../function.objects/range.cmp/less.pass.cpp | 7 ++++++-
.../range.cmp/less_equal.pass.cpp | 7 ++++++-
.../range.cmp/not_equal_to.pass.cpp | 7 ++++++-
7 files changed, 55 insertions(+), 8 deletions(-)
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/ranges_partial_sort_copy.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/ranges_partial_sort_copy.pass.cpp
index 532ee9b03efc0..0f799bca97775 100644
--- a/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/ranges_partial_sort_copy.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/ranges_partial_sort_copy.pass.cpp
@@ -75,7 +75,12 @@ static_assert(!HasPartialSortCopyIter<int*, int*, int*, int*, IndirectUnaryPredi
static_assert(!HasPartialSortCopyIter<int*, int*, int*, int*, IndirectUnaryPredicateNotCopyConstructible>);
// !indirectly_copyable<I1, I2>
-static_assert(!HasPartialSortCopyIter<int*, int*, MoveOnly*>);
+struct OrderedConvertibleToInt {
+ friend auto operator<=>(OrderedConvertibleToInt const&, OrderedConvertibleToInt const&) = default;
+ operator int() const;
+};
+
+static_assert(!HasPartialSortCopyIter<int*, int*, OrderedConvertibleToInt*, OrderedConvertibleToInt*>);
// !sortable<I2, Comp, Proj2>
static_assert(!HasPartialSortCopyIter<int*, int*, const int*, const int*>);
@@ -84,6 +89,12 @@ struct NoComparator {};
// !indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
static_assert(!HasPartialSortCopyIter<NoComparator*, NoComparator*, NoComparator*, NoComparator*>);
+#if TEST_STD_VER >= 23
+static_assert(HasPartialSortCopyIter<int*, int*, MoveOnly*, MoveOnly*>);
+#else
+static_assert(!HasPartialSortCopyIter<int*, int*, MoveOnly*, MoveOnly*>);
+#endif // TEST_STD_VER >= 23
+
// Test constraints of the (range) overload.
// ======================================================
@@ -109,7 +120,7 @@ static_assert(!HasPartialSortCopyRange<R<int*>, RandomAccessRangeNotDerivedFrom>
static_assert(!HasPartialSortCopyRange<R<int*>, RandomAccessRangeBadIndex>);
// !indirectly_copyable<iterator_t<R1>, iterator_t<R2>>
-static_assert(!HasPartialSortCopyRange<R<int*>, R<MoveOnly*>>);
+static_assert(!HasPartialSortCopyRange<R<int*>, R<OrderedConvertibleToInt*>>);
// !sortable<iterator_t<R2>, Comp, Proj2>
static_assert(!HasPartialSortCopyRange<R<int*>, R<const int*>>);
@@ -117,6 +128,12 @@ static_assert(!HasPartialSortCopyRange<R<int*>, R<const int*>>);
// !indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>, projected<iterator_t<R2>, Proj2>>
static_assert(!HasPartialSortCopyRange<R<NoComparator*>, R<NoComparator*>>);
+#if TEST_STD_VER >= 23
+static_assert(HasPartialSortCopyRange<R<int*>, R<MoveOnly*>>);
+#else
+static_assert(!HasPartialSortCopyRange<R<int*>, R<MoveOnly*>>);
+#endif // TEST_STD_VER >= 23
+
static_assert(std::is_same_v<std::ranges::partial_sort_copy_result<int, int>, std::ranges::in_out_result<int, int>>);
template <class Iter, class Sent, class OutIter, class OutSent, std::size_t N>
diff --git a/libcxx/test/std/utilities/function.objects/range.cmp/equal_to.pass.cpp b/libcxx/test/std/utilities/function.objects/range.cmp/equal_to.pass.cpp
index 6d207548b2175..d5431140841e2 100644
--- a/libcxx/test/std/utilities/function.objects/range.cmp/equal_to.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/range.cmp/equal_to.pass.cpp
@@ -28,9 +28,14 @@ struct NotEqualityComparable {
};
static_assert(!std::is_invocable_v<std::ranges::equal_to, NotEqualityComparable, NotEqualityComparable>);
-static_assert(!std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
static_assert(std::is_invocable_v<std::ranges::equal_to, explicit_operators, explicit_operators>);
+#if TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
+#else
+static_assert(!std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
+#endif // TEST_STD_VER >= 23
+
static_assert(requires { typename std::ranges::equal_to::is_transparent; });
constexpr bool test() {
diff --git a/libcxx/test/std/utilities/function.objects/range.cmp/greater.pass.cpp b/libcxx/test/std/utilities/function.objects/range.cmp/greater.pass.cpp
index 002ec10e07aff..7a91a6add6cc0 100644
--- a/libcxx/test/std/utilities/function.objects/range.cmp/greater.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/range.cmp/greater.pass.cpp
@@ -27,9 +27,14 @@ struct NotTotallyOrdered {
};
static_assert(!std::is_invocable_v<std::ranges::greater, NotTotallyOrdered, NotTotallyOrdered>);
-static_assert(!std::is_invocable_v<std::ranges::greater, int, MoveOnly>);
static_assert(std::is_invocable_v<std::ranges::greater, explicit_operators, explicit_operators>);
+#if TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::greater, int, MoveOnly>);
+#else
+static_assert(!std::is_invocable_v<std::ranges::greater, int, MoveOnly>);
+#endif // TEST_STD_VER >= 23
+
static_assert(requires { typename std::ranges::greater::is_transparent; });
constexpr bool test() {
diff --git a/libcxx/test/std/utilities/function.objects/range.cmp/greater_equal.pass.cpp b/libcxx/test/std/utilities/function.objects/range.cmp/greater_equal.pass.cpp
index ad24a98a168cf..7878d6bac04dc 100644
--- a/libcxx/test/std/utilities/function.objects/range.cmp/greater_equal.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/range.cmp/greater_equal.pass.cpp
@@ -27,9 +27,14 @@ struct NotTotallyOrdered {
};
static_assert(!std::is_invocable_v<std::ranges::greater_equal, NotTotallyOrdered, NotTotallyOrdered>);
-static_assert(!std::is_invocable_v<std::ranges::greater_equal, int, MoveOnly>);
static_assert(std::is_invocable_v<std::ranges::greater_equal, explicit_operators, explicit_operators>);
+#if TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::greater_equal, int, MoveOnly>);
+#else
+static_assert(!std::is_invocable_v<std::ranges::greater_equal, int, MoveOnly>);
+#endif // TEST_STD_VER >= 23
+
static_assert(requires { typename std::ranges::greater_equal::is_transparent; });
constexpr bool test() {
diff --git a/libcxx/test/std/utilities/function.objects/range.cmp/less.pass.cpp b/libcxx/test/std/utilities/function.objects/range.cmp/less.pass.cpp
index 5afb7e0ebdef4..8dca5c80da772 100644
--- a/libcxx/test/std/utilities/function.objects/range.cmp/less.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/range.cmp/less.pass.cpp
@@ -27,9 +27,14 @@ struct NotTotallyOrdered {
};
static_assert(!std::is_invocable_v<std::ranges::less, NotTotallyOrdered, NotTotallyOrdered>);
-static_assert(!std::is_invocable_v<std::ranges::less, int, MoveOnly>);
static_assert(std::is_invocable_v<std::ranges::less, explicit_operators, explicit_operators>);
+#if TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::less, int, MoveOnly>);
+#else
+static_assert(!std::is_invocable_v<std::ranges::less, int, MoveOnly>);
+#endif // TEST_STD_VER >= 23
+
static_assert(requires { typename std::ranges::less::is_transparent; });
constexpr bool test() {
diff --git a/libcxx/test/std/utilities/function.objects/range.cmp/less_equal.pass.cpp b/libcxx/test/std/utilities/function.objects/range.cmp/less_equal.pass.cpp
index 3aa903fa6321a..88d001e9fc1e7 100644
--- a/libcxx/test/std/utilities/function.objects/range.cmp/less_equal.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/range.cmp/less_equal.pass.cpp
@@ -27,9 +27,14 @@ struct NotTotallyOrdered {
};
static_assert(!std::is_invocable_v<std::ranges::less_equal, NotTotallyOrdered, NotTotallyOrdered>);
-static_assert(!std::is_invocable_v<std::ranges::less_equal, int, MoveOnly>);
static_assert(std::is_invocable_v<std::ranges::less_equal, explicit_operators, explicit_operators>);
+#if TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::less_equal, int, MoveOnly>);
+#else
+static_assert(!std::is_invocable_v<std::ranges::less_equal, int, MoveOnly>);
+#endif // TEST_STD_VER >= 23
+
static_assert(requires { typename std::ranges::less_equal::is_transparent; });
constexpr bool test() {
diff --git a/libcxx/test/std/utilities/function.objects/range.cmp/not_equal_to.pass.cpp b/libcxx/test/std/utilities/function.objects/range.cmp/not_equal_to.pass.cpp
index 4b46bae76ce48..9463967e7e2f0 100644
--- a/libcxx/test/std/utilities/function.objects/range.cmp/not_equal_to.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/range.cmp/not_equal_to.pass.cpp
@@ -28,9 +28,14 @@ struct NotEqualityComparable {
};
static_assert(!std::is_invocable_v<std::ranges::equal_to, NotEqualityComparable, NotEqualityComparable>);
-static_assert(!std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
static_assert(std::is_invocable_v<std::ranges::equal_to, explicit_operators, explicit_operators>);
+#if TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
+#else
+static_assert(!std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
+#endif // TEST_STD_VER >= 23
+
static_assert(requires { typename std::ranges::not_equal_to::is_transparent; });
struct PtrAndNotEqOperator {
>From 2debff627bd88dc601c1824954deb619e4d84a91 Mon Sep 17 00:00:00 2001
From: Janet Cobb <git at randomcat.org>
Date: Thu, 18 Jul 2024 13:36:47 -0400
Subject: [PATCH 7/9] Invert test conditionals
---
.../equality_comparable_with.compile.pass.cpp | 10 +++++-----
.../three_way_comparable_with.compile.pass.cpp | 8 ++++----
.../function.objects/range.cmp/equal_to.pass.cpp | 8 ++++----
.../function.objects/range.cmp/greater.pass.cpp | 8 ++++----
.../function.objects/range.cmp/greater_equal.pass.cpp | 8 ++++----
.../utilities/function.objects/range.cmp/less.pass.cpp | 8 ++++----
.../function.objects/range.cmp/less_equal.pass.cpp | 8 ++++----
.../function.objects/range.cmp/not_equal_to.pass.cpp | 8 ++++----
8 files changed, 33 insertions(+), 33 deletions(-)
diff --git a/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp b/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
index bdb42249b8a27..d1f41b6701648 100644
--- a/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
+++ b/libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
@@ -1120,13 +1120,13 @@ static_assert(
static_assert(
!check_equality_comparable_with<one_way_ne, explicit_operators>());
-#if TEST_STD_VER >= 23
-static_assert(check_equality_comparable_with<move_only_equality_with_int, int>());
-static_assert(check_equality_comparable_with<std::unique_ptr<int>, std::nullptr_t>());
-#else
+#if TEST_STD_VER < 23
static_assert(!check_equality_comparable_with<move_only_equality_with_int, int>());
static_assert(!check_equality_comparable_with<std::unique_ptr<int>, std::nullptr_t>());
-#endif // TEST_STD_VER >= 23
+#else
+static_assert(check_equality_comparable_with<move_only_equality_with_int, int>());
+static_assert(check_equality_comparable_with<std::unique_ptr<int>, std::nullptr_t>());
+#endif // TEST_STD_VER < 23
static_assert(!check_equality_comparable_with<nonmovable_equality_with_int, int>());
} // namespace types_fit_for_purpose
diff --git a/libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp b/libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp
index ee3284d42f540..5f3f06fb33149 100644
--- a/libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp
+++ b/libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp
@@ -234,11 +234,11 @@ struct MoveOnlyIntComparable {
friend auto operator<=>(MoveOnlyIntComparable const&, MoveOnlyIntComparable const&) = default;
};
-#if TEST_STD_VER >= 23
-static_assert(check_three_way_comparable_with<MoveOnlyIntComparable, int>());
-#else
+#if TEST_STD_VER < 23
static_assert(!check_three_way_comparable_with<MoveOnlyIntComparable, int>());
-#endif // TEST_STD_VER >= 23
+#else
+static_assert(check_three_way_comparable_with<MoveOnlyIntComparable, int>());
+#endif // TEST_STD_VER < 23
struct NonMovableIntComparable {
NonMovableIntComparable(int) {}
diff --git a/libcxx/test/std/utilities/function.objects/range.cmp/equal_to.pass.cpp b/libcxx/test/std/utilities/function.objects/range.cmp/equal_to.pass.cpp
index d5431140841e2..10b9aa6e59fd6 100644
--- a/libcxx/test/std/utilities/function.objects/range.cmp/equal_to.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/range.cmp/equal_to.pass.cpp
@@ -30,11 +30,11 @@ struct NotEqualityComparable {
static_assert(!std::is_invocable_v<std::ranges::equal_to, NotEqualityComparable, NotEqualityComparable>);
static_assert(std::is_invocable_v<std::ranges::equal_to, explicit_operators, explicit_operators>);
-#if TEST_STD_VER >= 23
-static_assert(std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
-#else
+#if TEST_STD_VER < 23
static_assert(!std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
-#endif // TEST_STD_VER >= 23
+#else
+static_assert(std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
+#endif // TEST_STD_VER < 23
static_assert(requires { typename std::ranges::equal_to::is_transparent; });
diff --git a/libcxx/test/std/utilities/function.objects/range.cmp/greater.pass.cpp b/libcxx/test/std/utilities/function.objects/range.cmp/greater.pass.cpp
index 7a91a6add6cc0..b8d1da2d1410f 100644
--- a/libcxx/test/std/utilities/function.objects/range.cmp/greater.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/range.cmp/greater.pass.cpp
@@ -29,11 +29,11 @@ struct NotTotallyOrdered {
static_assert(!std::is_invocable_v<std::ranges::greater, NotTotallyOrdered, NotTotallyOrdered>);
static_assert(std::is_invocable_v<std::ranges::greater, explicit_operators, explicit_operators>);
-#if TEST_STD_VER >= 23
-static_assert(std::is_invocable_v<std::ranges::greater, int, MoveOnly>);
-#else
+#if TEST_STD_VER < 23
static_assert(!std::is_invocable_v<std::ranges::greater, int, MoveOnly>);
-#endif // TEST_STD_VER >= 23
+#else
+static_assert(std::is_invocable_v<std::ranges::greater, int, MoveOnly>);
+#endif // TEST_STD_VER < 23
static_assert(requires { typename std::ranges::greater::is_transparent; });
diff --git a/libcxx/test/std/utilities/function.objects/range.cmp/greater_equal.pass.cpp b/libcxx/test/std/utilities/function.objects/range.cmp/greater_equal.pass.cpp
index 7878d6bac04dc..26ec6663364ee 100644
--- a/libcxx/test/std/utilities/function.objects/range.cmp/greater_equal.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/range.cmp/greater_equal.pass.cpp
@@ -29,11 +29,11 @@ struct NotTotallyOrdered {
static_assert(!std::is_invocable_v<std::ranges::greater_equal, NotTotallyOrdered, NotTotallyOrdered>);
static_assert(std::is_invocable_v<std::ranges::greater_equal, explicit_operators, explicit_operators>);
-#if TEST_STD_VER >= 23
-static_assert(std::is_invocable_v<std::ranges::greater_equal, int, MoveOnly>);
-#else
+#if TEST_STD_VER < 23
static_assert(!std::is_invocable_v<std::ranges::greater_equal, int, MoveOnly>);
-#endif // TEST_STD_VER >= 23
+#else
+static_assert(std::is_invocable_v<std::ranges::greater_equal, int, MoveOnly>);
+#endif // TEST_STD_VER < 23
static_assert(requires { typename std::ranges::greater_equal::is_transparent; });
diff --git a/libcxx/test/std/utilities/function.objects/range.cmp/less.pass.cpp b/libcxx/test/std/utilities/function.objects/range.cmp/less.pass.cpp
index 8dca5c80da772..70ed88fbcea2c 100644
--- a/libcxx/test/std/utilities/function.objects/range.cmp/less.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/range.cmp/less.pass.cpp
@@ -29,11 +29,11 @@ struct NotTotallyOrdered {
static_assert(!std::is_invocable_v<std::ranges::less, NotTotallyOrdered, NotTotallyOrdered>);
static_assert(std::is_invocable_v<std::ranges::less, explicit_operators, explicit_operators>);
-#if TEST_STD_VER >= 23
-static_assert(std::is_invocable_v<std::ranges::less, int, MoveOnly>);
-#else
+#if TEST_STD_VER < 23
static_assert(!std::is_invocable_v<std::ranges::less, int, MoveOnly>);
-#endif // TEST_STD_VER >= 23
+#else
+static_assert(std::is_invocable_v<std::ranges::less, int, MoveOnly>);
+#endif // TEST_STD_VER < 23
static_assert(requires { typename std::ranges::less::is_transparent; });
diff --git a/libcxx/test/std/utilities/function.objects/range.cmp/less_equal.pass.cpp b/libcxx/test/std/utilities/function.objects/range.cmp/less_equal.pass.cpp
index 88d001e9fc1e7..d422bea55f9eb 100644
--- a/libcxx/test/std/utilities/function.objects/range.cmp/less_equal.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/range.cmp/less_equal.pass.cpp
@@ -29,11 +29,11 @@ struct NotTotallyOrdered {
static_assert(!std::is_invocable_v<std::ranges::less_equal, NotTotallyOrdered, NotTotallyOrdered>);
static_assert(std::is_invocable_v<std::ranges::less_equal, explicit_operators, explicit_operators>);
-#if TEST_STD_VER >= 23
-static_assert(std::is_invocable_v<std::ranges::less_equal, int, MoveOnly>);
-#else
+#if TEST_STD_VER < 23
static_assert(!std::is_invocable_v<std::ranges::less_equal, int, MoveOnly>);
-#endif // TEST_STD_VER >= 23
+#else
+static_assert(std::is_invocable_v<std::ranges::less_equal, int, MoveOnly>);
+#endif // TEST_STD_VER < 23
static_assert(requires { typename std::ranges::less_equal::is_transparent; });
diff --git a/libcxx/test/std/utilities/function.objects/range.cmp/not_equal_to.pass.cpp b/libcxx/test/std/utilities/function.objects/range.cmp/not_equal_to.pass.cpp
index 9463967e7e2f0..147a248348da8 100644
--- a/libcxx/test/std/utilities/function.objects/range.cmp/not_equal_to.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/range.cmp/not_equal_to.pass.cpp
@@ -30,11 +30,11 @@ struct NotEqualityComparable {
static_assert(!std::is_invocable_v<std::ranges::equal_to, NotEqualityComparable, NotEqualityComparable>);
static_assert(std::is_invocable_v<std::ranges::equal_to, explicit_operators, explicit_operators>);
-#if TEST_STD_VER >= 23
-static_assert(std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
+#if TEST_STD_VER < 23
+static_assert(!std::is_invocable_v<std::ranges::not_equal_to, int, MoveOnly>);
#else
-static_assert(!std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
-#endif // TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::not_equal_to, int, MoveOnly>);
+#endif // TEST_STD_VER < 23
static_assert(requires { typename std::ranges::not_equal_to::is_transparent; });
>From bb8ee9d7bf238acca940ffbb5c8b57a7ff2bc9fb Mon Sep 17 00:00:00 2001
From: Janet Cobb <git at randomcat.org>
Date: Thu, 18 Jul 2024 13:49:41 -0400
Subject: [PATCH 8/9] Don't split definitions of
equality_comparable_with/totally_ordered_with
---
.../include/__compare/three_way_comparable.h | 17 -----------------
.../__concepts/comparison_common_type.h | 16 ++++++++++++++--
.../include/__concepts/equality_comparable.h | 18 ------------------
libcxx/test/support/compare_types.h | 3 +++
4 files changed, 17 insertions(+), 37 deletions(-)
diff --git a/libcxx/include/__compare/three_way_comparable.h b/libcxx/include/__compare/three_way_comparable.h
index f43c6fb010332..ad6d05a681145 100644
--- a/libcxx/include/__compare/three_way_comparable.h
+++ b/libcxx/include/__compare/three_way_comparable.h
@@ -38,8 +38,6 @@ concept three_way_comparable =
{ __a <=> __b } -> __compares_as<_Cat>;
};
-# if _LIBCPP_STD_VER >= 23
-
template <class _Tp, class _Up, class _Cat = partial_ordering>
concept three_way_comparable_with =
three_way_comparable<_Tp, _Cat> && three_way_comparable<_Up, _Cat> && __comparison_common_type_with<_Tp, _Up> &&
@@ -50,21 +48,6 @@ concept three_way_comparable_with =
{ __u <=> __t } -> __compares_as<_Cat>;
};
-# else
-
-template <class _Tp, class _Up, class _Cat = partial_ordering>
-concept three_way_comparable_with =
- three_way_comparable<_Tp, _Cat> && three_way_comparable<_Up, _Cat> &&
- common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
- three_way_comparable<common_reference_t<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>, _Cat> &&
- __weakly_equality_comparable_with<_Tp, _Up> && __partially_ordered_with<_Tp, _Up> &&
- requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
- { __t <=> __u } -> __compares_as<_Cat>;
- { __u <=> __t } -> __compares_as<_Cat>;
- };
-
-# endif // _LIBCPP_STD_VER >= 23
-
#endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__concepts/comparison_common_type.h b/libcxx/include/__concepts/comparison_common_type.h
index ed95ee3a66700..cff61e14d501d 100644
--- a/libcxx/include/__concepts/comparison_common_type.h
+++ b/libcxx/include/__concepts/comparison_common_type.h
@@ -9,10 +9,12 @@
#ifndef _LIBCPP___CONCEPTS_COMPARISON_COMMON_TYPE_H
#define _LIBCPP___CONCEPTS_COMPARISON_COMMON_TYPE_H
+#include "__concepts/common_reference_with.h"
#include "__concepts/convertible_to.h"
#include "__concepts/same_as.h"
#include "__config"
#include "__type_traits/common_reference.h"
+#include "__type_traits/make_const_lvalue_ref.h"
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -20,7 +22,15 @@
_LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER >= 23
+#if _LIBCPP_STD_VER >= 20
+
+# if _LIBCPP_STD_VER < 23
+
+template <class _Tp, class _Up>
+concept __comparison_common_type_with =
+ common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>;
+
+# else
template <class _Tp, class _Up, class _CommonRef = common_reference_t<const _Tp&, const _Up&>>
concept __comparison_common_type_with_impl =
@@ -32,7 +42,9 @@ concept __comparison_common_type_with_impl =
template <class _Tp, class _Up>
concept __comparison_common_type_with = __comparison_common_type_with_impl<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
-#endif // _LIBCPP_STD_VER >= 23
+# endif // _LIBCPP_STD_VER < 23
+
+#endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__concepts/equality_comparable.h b/libcxx/include/__concepts/equality_comparable.h
index 1904b2e451a8d..56fc6f8b685c0 100644
--- a/libcxx/include/__concepts/equality_comparable.h
+++ b/libcxx/include/__concepts/equality_comparable.h
@@ -38,8 +38,6 @@ concept __weakly_equality_comparable_with =
template <class _Tp>
concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
-# if _LIBCPP_STD_VER >= 23
-
// clang-format off
template <class _Tp, class _Up>
concept equality_comparable_with =
@@ -52,22 +50,6 @@ concept equality_comparable_with =
__weakly_equality_comparable_with<_Tp, _Up>;
// clang-format on
-# else
-
-// clang-format off
-template <class _Tp, class _Up>
-concept equality_comparable_with =
- equality_comparable<_Tp> && equality_comparable<_Up> &&
- common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
- equality_comparable<
- common_reference_t<
- __make_const_lvalue_ref<_Tp>,
- __make_const_lvalue_ref<_Up>>> &&
- __weakly_equality_comparable_with<_Tp, _Up>;
-// clang-format on
-
-# endif // _LIBCPP_STD_VER >= 23
-
#endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/test/support/compare_types.h b/libcxx/test/support/compare_types.h
index 62203318be725..b52e201f240ac 100644
--- a/libcxx/test/support/compare_types.h
+++ b/libcxx/test/support/compare_types.h
@@ -548,6 +548,9 @@ struct nonmovable_equality_with_int {
nonmovable_equality_with_int(nonmovable_equality_with_int&&) = delete;
nonmovable_equality_with_int& operator=(nonmovable_equality_with_int&&) = delete;
+ nonmovable_equality_with_int(nonmovable_equality_with_int const&) = delete;
+ nonmovable_equality_with_int& operator=(nonmovable_equality_with_int const&) = delete;
+
friend bool operator==(nonmovable_equality_with_int const&, nonmovable_equality_with_int const&) = default;
friend bool operator==(nonmovable_equality_with_int const&, int);
};
>From 441884dbb6a4ab3466a982c5b69aac4367a1b53e Mon Sep 17 00:00:00 2001
From: Janet Cobb <git at randomcat.org>
Date: Thu, 18 Jul 2024 15:00:34 -0400
Subject: [PATCH 9/9] Fix last >= 23 check
---
.../ranges_partial_sort_copy.pass.cpp | 16 ++++++++--------
1 file changed, 8 insertions(+), 8 deletions(-)
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/ranges_partial_sort_copy.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/ranges_partial_sort_copy.pass.cpp
index 0f799bca97775..fc00f9c79a94e 100644
--- a/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/ranges_partial_sort_copy.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/ranges_partial_sort_copy.pass.cpp
@@ -89,11 +89,11 @@ struct NoComparator {};
// !indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
static_assert(!HasPartialSortCopyIter<NoComparator*, NoComparator*, NoComparator*, NoComparator*>);
-#if TEST_STD_VER >= 23
-static_assert(HasPartialSortCopyIter<int*, int*, MoveOnly*, MoveOnly*>);
-#else
+#if TEST_STD_VER < 23
static_assert(!HasPartialSortCopyIter<int*, int*, MoveOnly*, MoveOnly*>);
-#endif // TEST_STD_VER >= 23
+#else
+static_assert(HasPartialSortCopyIter<int*, int*, MoveOnly*, MoveOnly*>);
+#endif // TEST_STD_VER < 23
// Test constraints of the (range) overload.
// ======================================================
@@ -128,11 +128,11 @@ static_assert(!HasPartialSortCopyRange<R<int*>, R<const int*>>);
// !indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>, projected<iterator_t<R2>, Proj2>>
static_assert(!HasPartialSortCopyRange<R<NoComparator*>, R<NoComparator*>>);
-#if TEST_STD_VER >= 23
-static_assert(HasPartialSortCopyRange<R<int*>, R<MoveOnly*>>);
-#else
+#if TEST_STD_VER < 23
static_assert(!HasPartialSortCopyRange<R<int*>, R<MoveOnly*>>);
-#endif // TEST_STD_VER >= 23
+#else
+static_assert(HasPartialSortCopyRange<R<int*>, R<MoveOnly*>>);
+#endif // TEST_STD_VER < 23
static_assert(std::is_same_v<std::ranges::partial_sort_copy_result<int, int>, std::ranges::in_out_result<int, int>>);
More information about the libcxx-commits
mailing list