feature/spaceship: Clause 20: pair, tuple, optional

stl/inc/compare

@@ -342,6 +342,35 @@ struct compare_three_way {
 };
 // clang-format on
 
+// STRUCT _Synth_three_way
+struct _Synth_three_way {
+    // clang-format off
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(const _Ty1& _Left, const _Ty2& _Right) const
+    requires requires {
+        { _Left < _Right } -> _Boolean_testable;
+        { _Right < _Left } -> _Boolean_testable;
+    }
+    // clang-format on
+    {
+        if constexpr (three_way_comparable_with<_Ty1, _Ty2>) {
+            return _Left <=> _Right;
+        } else {
+            if (_Left < _Right) {
+                return weak_ordering::less;
+            } else if (_Right < _Left) {
+                return weak_ordering::greater;
+            } else {
+                return weak_ordering::equivalent;
+            }
+        }
+    }
+};
+
+// ALIAS TEMPLATE _Synth_three_way_result
+template <class _Ty1, class _Ty2 = _Ty1>
+using _Synth_three_way_result = decltype(_Synth_three_way{}(_STD declval<_Ty1&>(), _STD declval<_Ty2&>()));
+
 // Note: The following CPOs are passing arguments as lvalues; see GH-1374.
 
 // CUSTOMIZATION POINT OBJECT strong_order

stl/inc/optional

@@ -11,6 +11,9 @@
 #if !_HAS_CXX17
 #pragma message("The contents of <optional> are available only with C++17 or later.")
 #else // ^^^ !_HAS_CXX17 / _HAS_CXX17 vvv
+#if _HAS_CXX20
+#include <compare>
+#endif // _HAS_CXX20
 #include <exception>
 #include <initializer_list>
 #include <type_traits>
@@ -480,11 +483,30 @@ _NODISCARD constexpr bool operator>=(const optional<_Ty1>& _Left, const optional
     return !_Right.has_value() || (_Left.has_value() && *_Left >= *_Right);
 }
 
+#ifdef __cpp_lib_concepts
+template <class _Ty1, three_way_comparable_with<_Ty1> _Ty2>
+_NODISCARD constexpr compare_three_way_result_t<_Ty1, _Ty2> operator<=>(
+    const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) {
+    if (_Left && _Right) {
+        return *_Left <=> *_Right;
+    }
+
+    return _Left.has_value() <=> _Right.has_value();
+}
+#endif // __cpp_lib_concepts
+
 // COMPARISONS WITH nullopt [optional.nullops]
 template <class _Ty>
 _NODISCARD constexpr bool operator==(const optional<_Ty>& _Left, nullopt_t) noexcept {
     return !_Left.has_value();
 }
+
+#if _HAS_CXX20
+template <class _Ty>
+_NODISCARD constexpr strong_ordering operator<=>(const optional<_Ty>& _Left, nullopt_t) noexcept {
+    return _Left.has_value() <=> false;
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
 template <class _Ty>
 _NODISCARD constexpr bool operator==(nullopt_t, const optional<_Ty>& _Right) noexcept {
     return !_Right.has_value();
@@ -534,6 +556,7 @@ template <class _Ty>
 _NODISCARD constexpr bool operator>=(nullopt_t, const optional<_Ty>& _Right) noexcept {
     return !_Right.has_value();
 }
+#endif // !_HAS_CXX20
 
 // COMPARISONS WITH T [optional.comp_with_t]
 template <class _Ty>
@@ -567,6 +590,7 @@ template <class _Ty1, class _Ty2, _Enable_if_comparable_with_equal<_Ty1, _Ty2> =
 _NODISCARD constexpr bool operator==(const optional<_Ty1>& _Left, const _Ty2& _Right) {
     return _Left ? *_Left == _Right : false;
 }
+
 template <class _Ty1, class _Ty2, _Enable_if_comparable_with_equal<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator==(const _Ty1& _Left, const optional<_Ty2>& _Right) {
     return _Right ? _Left == *_Right : false;
@@ -617,6 +641,22 @@ _NODISCARD constexpr bool operator>=(const _Ty1& _Left, const optional<_Ty2>& _R
     return _Right ? _Left >= *_Right : true;
 }
 
+#ifdef __cpp_lib_concepts
+// clang-format off
+template <class _Ty1, class _Ty2>
+    requires (!_Is_specialization_v<_Ty2, optional>) // TRANSITION, GH-1674
+        && three_way_comparable_with<_Ty1, _Ty2>
+_NODISCARD constexpr compare_three_way_result_t<_Ty1, _Ty2>
+    operator<=>(const optional<_Ty1>& _Left, const _Ty2& _Right) {
+    // clang-format on
+    if (_Left) {
+        return *_Left <=> _Right;
+    }
+
+    return strong_ordering::less;
+}
+#endif // __cpp_lib_concepts
+
 // FUNCTION TEMPLATE swap [optional.specalg]
 template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_swappable_v<_Ty>, int> = 0>
 void swap(optional<_Ty>& _Left, optional<_Ty>& _Right) noexcept(noexcept(_Left.swap(_Right))) {

stl/inc/regex

@@ -730,35 +730,6 @@ template <class _BidIt>
 _NODISCARD auto operator<=>(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
     return static_cast<typename sub_match<_BidIt>::_Comparison_category>(_Left.compare(_Right) <=> 0);
 }
-
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-900973
-// The compiler incorrectly performs overload resolution by preferring implicit conversions over rewrites.
-// In C++20 mode the only required comparison operators should be == and <=>.
-template <class _BidIt>
-_NODISCARD bool operator!=(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<=(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>=(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-#endif // TRANSITION, VSO-900973
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
 template <class _BidIt>
 _NODISCARD bool operator!=(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
@@ -797,70 +768,6 @@ template <class _BidIt>
 _NODISCARD auto operator<=>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
     return static_cast<typename sub_match<_BidIt>::_Comparison_category>(_Left.compare(_Right) <=> 0);
 }
-
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-900973
-// The compiler incorrectly performs overload resolution by preferring implicit conversions over rewrites.
-// In C++20 mode the only required comparison operators should be == and <=>.
-template <class _BidIt>
-_NODISCARD auto operator<=>(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return static_cast<typename sub_match<_BidIt>::_Comparison_category>(0 <=> (_Right <=> _Left));
-}
-
-template <class _BidIt>
-_NODISCARD bool operator==(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return _Right._Match_equal(_Left);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator!=(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<=(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>=(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator!=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-#endif // TRANSTITION, VSO-900973
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
 template <class _BidIt>
 _NODISCARD bool operator==(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
@@ -930,70 +837,6 @@ _NODISCARD auto operator<=>(const sub_match<_BidIt>& _Left, const _Iter_value_t<
     return static_cast<typename sub_match<_BidIt>::_Comparison_category>(
         _Left._Compare(_STD addressof(_Right), 1) <=> 0);
 }
-
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-900973
-// The compiler incorrectly performs overload resolution by preferring implicit conversions over rewrites.
-// In C++20 mode the only required comparison operators should be == and <=>.
-template <class _BidIt>
-_NODISCARD auto operator<=>(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return static_cast<typename sub_match<_BidIt>::_Comparison_category>(0 <=> (_Right <=> _Left));
-}
-
-template <class _BidIt>
-_NODISCARD bool operator==(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return _Right._Match_equal(_STD addressof(_Left), 1);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator!=(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<=(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>=(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator!=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator<=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt>
-_NODISCARD bool operator>=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-#endif // TRANSITION, VSO-900973
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
 template <class _BidIt>
 _NODISCARD bool operator==(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
@@ -1064,82 +907,6 @@ _NODISCARD auto operator<=>(
     const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
     return static_cast<typename sub_match<_BidIt>::_Comparison_category>(_Left.compare(_Right) <=> 0);
 }
-
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-900973
-// The compiler incorrectly performs overload resolution by preferring implicit conversions over rewrites.
-// In C++20 mode the only required comparison operators should be == and <=>.
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD auto operator<=>(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return static_cast<typename sub_match<_BidIt>::_Comparison_category>(0 <=> (_Right <=> _Left));
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator==(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return _Right._Match_equal(_Left.data(), _Left.size());
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator!=(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator<(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator>(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator<=(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator>=(
-    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator!=(
-    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
-    return !(_Left == _Right);
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator<(
-    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
-    return (_Left <=> _Right) < 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator>(
-    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
-    return (_Left <=> _Right) > 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator<=(
-    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
-    return (_Left <=> _Right) <= 0;
-}
-
-template <class _BidIt, class _Traits, class _Alloc>
-_NODISCARD bool operator>=(
-    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
-    return (_Left <=> _Right) >= 0;
-}
-#endif // TRANSITION, VSO-900973
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
 template <class _BidIt, class _Traits, class _Alloc>
 _NODISCARD bool operator==(