Fix wrong concept usage in synth_three_way_result

Author: saki7

include/iris/compare.hpp

@@ -22,7 +22,7 @@ struct synth_three_way_result_impl
     using type = std::weak_ordering;
 };
 
-template<class T, class U> requires std::three_way_comparable<T, U>
+template<class T, class U> requires std::three_way_comparable_with<T, U>
 struct synth_three_way_result_impl<T, U>
 {
     using type = std::invoke_result_t<std::compare_three_way, T const&, U const&>;
@@ -31,7 +31,7 @@ struct synth_three_way_result_impl<T, U>
 } // detail
 
 template<class T, class U = T>
-using synth_three_way_result_t = detail::synth_three_way_result_impl<T, U>::type;
+using synth_three_way_result = detail::synth_three_way_result_impl<T, U>::type;
 
 template<class T, class U = T>
 inline constexpr bool synth_three_way_noexcept =
@@ -45,7 +45,7 @@ inline constexpr bool synth_three_way_noexcept =
     >::value;
 
 constexpr auto synth_three_way = []<class T, class U>(T const& t, U const& u) noexcept(synth_three_way_noexcept<T, U>)
-    -> synth_three_way_result_t<T, U>
+    -> synth_three_way_result<T, U>
     requires requires {
         { t < u } -> req::boolean_testable;
         { u < t } -> req::boolean_testable;

include/iris/indirect.hpp

@@ -402,7 +402,8 @@ constexpr bool operator==(indirect<T, Allocator> const& lhs, indirect<U, AA> con
 
 template<class T, class Allocator, class U, class AA>
 constexpr auto operator<=>(indirect<T, Allocator> const& lhs, indirect<U, AA> const& rhs)
-    noexcept(synth_three_way_noexcept<T, U>) -> synth_three_way_result_t<T, U>
+    noexcept(noexcept(synth_three_way(*lhs, *rhs)))
+    -> synth_three_way_result<T, U>
 {
     if (lhs.valueless_after_move() || rhs.valueless_after_move()) [[unlikely]] {
         return !lhs.valueless_after_move() <=> !rhs.valueless_after_move();
@@ -424,7 +425,8 @@ constexpr bool operator==(indirect<T, Allocator> const& lhs, U const& rhs)
 
 template<class T, class Allocator, class U> requires (!is_ttp_specialization_of_v<U, indirect>)
 constexpr auto operator<=>(indirect<T, Allocator> const& lhs, U const& rhs)
-    noexcept(synth_three_way_noexcept<T, U>) -> synth_three_way_result_t<T, U>
+    noexcept(noexcept(synth_three_way(*lhs, rhs)))
+    -> synth_three_way_result<T, U>
 {
     if (lhs.valueless_after_move()) [[unlikely]] {
         return std::strong_ordering::less;

include/iris/rvariant/recursive_wrapper.hpp

@@ -178,8 +178,9 @@ constexpr bool operator==(recursive_wrapper<T, TA> const& lhs, recursive_wrapper
 }
 
 template<class T, class TA, class U, class UA>
-constexpr auto operator<=>(recursive_wrapper<T, TA> const& lhs, recursive_wrapper<U, UA> const& rhs) noexcept(synth_three_way_noexcept<T, U>)
-    -> synth_three_way_result_t<T, U>
+constexpr auto operator<=>(recursive_wrapper<T, TA> const& lhs, recursive_wrapper<U, UA> const& rhs)
+    noexcept(noexcept(synth_three_way(*lhs, *rhs)))
+    -> synth_three_way_result<T, U>
 {
     if (lhs.valueless_after_move() || rhs.valueless_after_move()) [[unlikely]] {
         return !lhs.valueless_after_move() <=> !rhs.valueless_after_move();
@@ -200,7 +201,9 @@ constexpr bool operator==(recursive_wrapper<T, A> const& lhs, U const& rhs)
 }
 
 template<class T, class A, class U>
-constexpr auto operator<=>(recursive_wrapper<T, A> const& lhs, U const& rhs) noexcept(synth_three_way_noexcept<T, U>) -> synth_three_way_result_t<T, U>
+constexpr auto operator<=>(recursive_wrapper<T, A> const& lhs, U const& rhs)
+    noexcept(noexcept(synth_three_way(*lhs, rhs)))
+    -> synth_three_way_result<T, U>
 {
     if (lhs.valueless_after_move()) [[unlikely]] {
         return std::strong_ordering::less;

test/rvariant/core_test.cpp

@@ -1,10 +1,13 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: MIT
 
 #include <iris/type_traits.hpp>
 #include <iris/requirements.hpp>
+#include <iris/compare.hpp>
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <concepts>
+
 namespace unit_test {
 
 TEST_CASE("pack_indexing")
@@ -406,4 +409,20 @@ TEST_CASE("Cpp17Swappable")
     }
 }
 
+
+TEST_CASE("synth_three_way")
+{
+    STATIC_CHECK(std::same_as<iris::synth_three_way_result<int>, std::strong_ordering>);
+    STATIC_CHECK(std::same_as<iris::synth_three_way_result<float>, std::partial_ordering>);
+
+    struct NoThreeWay
+    {
+        bool operator<(NoThreeWay const&) const { return false; }
+        bool operator>(NoThreeWay const&) const { return false; }
+        auto operator<=>(NoThreeWay const&) const = delete;
+    };
+
+    STATIC_CHECK(std::same_as<iris::synth_three_way_result<NoThreeWay>, std::weak_ordering>);
+}
+
 } // unit_test