[libc++][regex] Uses operator<=> in sub_match.

[Mordante]

Summary

The removal of operator!= in this header will be done in a separate
commit.

Note in the synopsis of P1614R2 there is a constexpr

template<class BiIter>
  constexpr auto operator<=>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);

In the implementation of P1614R2 there isn't a constexpr

template<class BiIter>
  auto operator<=>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);

There doesn't seem to be an LWG-issue, but it was fixed in the Standard
by removing the constexpr in b050fd474f11441942c88ef69b8622c8036656ac.

Implements part of:

• P1614R2 The Mothership has Landed

[avogelsgesang]

can you please add a new row to the status doc for the removal of the operator!= on match_results? So we don't forget about it...

libcxx/docs/Status/SpaceshipProjects.csv

80

please also add a link to this review

libcxx/include/regex

370

5058

given the class is named sub_match instead of submatch, I would prefer the name __sub_match_cat here

5058–5059

an empty line between the introduction of __submatch_cat and the operator<=> would make this a bit more readable

libcxx/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp

224–225

the parameters should align correctly below each other...

229–230

253

missing whitespace. Here and other places in this header

254–257

shouldn't this rather check sub_match?
Move below the typedef ... sub_match and test for sub_match?

269–270

replace by testComparisons(sm1, sm2, /*isEqual*/ x == y, /*isLess*/ x <= y)?

Same for the other remaining comparison tests

359

we should also add some test case for a character type which does not return a strong_ordering. Currently the static_cast<__submatch_cat<_BiIter>> is completely untested.

One way would be to use the same approach as in https://reviews.llvm.org/D132268 (search for "WeakComp"; "WeakComp" is introduced in https://reviews.llvm.org/D131395)

[avogelsgesang]

libcxx/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp

269–270

missing

#if TEST_STD_VER > 17
    AssertOrderReturn<std::strong_ordering, std::basic_string<CharT>, submatch>();
#else
    AssertCompareReturnBool<std::basic_string<CharT>, submatch>();
#endif

same for the other comparisons

[Mordante]

Thanks for the review! I'll put this on hold until D131395 lands, then I can address your final review comment.

In D132310#3737499, @avogelsgesang wrote:

can you please add a new row to the status doc for the removal of the operator!= on match_results? So we don't forget about it...

I already have a patch for the operator!= removal, changing that in this patch will lead to merge conflicts so I will not add it here. I will upload that patch after this one lands; just to avoid merge conflicts.

libcxx/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp

253

I see I rely too much on clang-format ;-)

254–257

Guess I copy pasted it, but it indeed should be sub_match.

[avogelsgesang]

I'll put this on hold until D131395 lands, then I can address your final review comment.

Well, that might still take a while... That review turned out to be a suprisingly deep rat hole and time sink.

If you want to move ahead with this patch independently, please feel free to just copy the {Weak,Partial}Order helpers. I have no problem rebasing on your change, in case this review here lands first.

[Mordante]

In D132310#3738243, @avogelsgesang wrote:

I'll put this on hold until D131395 lands, then I can address your final review comment.

Well, that might still take a while... That review turned out to be a suprisingly deep rat hole and time sink.

If you want to move ahead with this patch independently, please feel free to just copy the {Weak,Partial}Order helpers. I have no problem rebasing on your change, in case this review here lands first.

I'm not really in a hurry with this patch, it's not really blocking other work and we're not near to branching a new version of LLVM. So I don't mind waiting.

[avogelsgesang]

@Mordante with D131395 landed, this should now be unblocked :)

[Mordante]

In D132310#4122932, @avogelsgesang wrote:

@Mordante with D131395 landed, this should now be unblocked :)

Thanks for the heads up, I'll add it to my TODO list.

[Mordante]

Rebased and addresses review comments.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Zingam]

In D132310#3737499, @avogelsgesang wrote:

can you please add a new row to the status doc for the removal of the operator!= on match_results? So we don't forget about it...

Just a reminder: I am working on to update the status page to include these too.

[Mordante]

In D132310#4271747, @Zingam wrote:

In D132310#3737499, @avogelsgesang wrote:

can you please add a new row to the status doc for the removal of the operator!= on match_results? So we don't forget about it...

Just a reminder: I am working on to update the status page to include these too.

Thanks for the update. Note the I have a patch locally with the changes for regex, these are not uploaded yet.

[ldionne]

libcxx/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp

299–300

Could you do this instead to reduce the boilerplate?

template <class CharT, class Ordering>
struct char_traits : constexpr_char_traits {
    using comparison_category = Ordering;
};

[Mordante]

Thanks for the review!

libcxx/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp

299–300

Thanks for the suggestion, this looks a lot better!

[Mordante]

Rebased and addresses review comment.

[Mordante]

Trigger CI.

[Mordante]

Rebased to trigger CI.

[Mordante]

Trigger CI.

[Mordante]

Test CI.

libcxx/docs/Status/SpaceshipProjects.csv

 "| `[time.zone.nonmembers] <https://wg21.link/time.zone.nonmembers>`_
 | `[time.zone.leap.nonmembers] <https://wg21.link/time.zone.leap.nonmembers>`_
 | `[time.zone.link.nonmembers] <https://wg21.link/time.zone.link.nonmembers>`_","| chrono::time_zone
 | chrono::leap_second
 | chrono::time_zone_link",A ``<chrono>`` implementation,Unassigned,|Not Started|
 | `[fs.filesystem.syn] <https://wg21.link/fs.filesystem.syn>`_,| `filesystem::space_info <https://reviews.llvm.org/D130861>`_,None,Adrian Vogelsgesang,|Complete|
 | `[fs.path.nonmember] <https://wg21.link/fs.path.nonmember>`_,| `filesystem::path <https://reviews.llvm.org/D130859>`_,None,Adrian Vogelsgesang,|Complete|
 | `[fs.dir.entry.obs] <https://wg21.link/fs.dir.entry.obs>`_,| `filesystem::directory_entry <https://reviews.llvm.org/D130860>`_,None,Adrian Vogelsgesang,|Complete|
-| `[re.submatch.op] <https://wg21.link/re.submatch.op>`_,| `sub_match <https://reviews.llvm.org/D132310>`_,None,Mark de Wever,|In Progress|
+| `[re.submatch.op] <https://wg21.link/re.submatch.op>`_,| `sub_match <https://reviews.llvm.org/D132310>`_,None,Mark de Wever,|Complete|
 | `[thread.thread.id] <https://wg21.link/thread.thread.id>`_,| `thread::id <https://reviews.llvm.org/D131362>`_,None,Adrian Vogelsgesang,|Complete|

libcxx/include/regex

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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_REGEX
 #define _LIBCPP_REGEX
 
 /*
     regex synopsis
 
+#include <compare>
 #include <initializer_list>
 
 namespace std
 {
 
 namespace regex_constants
 {
 

 typedef sub_match<string::const_iterator>  ssub_match;
 typedef sub_match<wstring::const_iterator> wssub_match;
 
 template <class BiIter>
     bool
     operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
 template <class BiIter>
+    auto
+    operator<=>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs); // Since C++20
+
+ template <class BiIter>                                                     // Removed in C++20
     bool
     operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
-template <class BiIter, class ST, class SA>
+template <class BiIter, class ST, class SA>                                  // Removed in C++20
     bool
     operator==(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
                const sub_match<BiIter>& rhs);
 
-template <class BiIter, class ST, class SA>
+template <class BiIter, class ST, class SA>                                  // Removed in C++20
     bool
     operator!=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
                const sub_match<BiIter>& rhs);
 
-template <class BiIter, class ST, class SA>
+template <class BiIter, class ST, class SA>                                  // Removed in C++20
     bool
     operator<(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
               const sub_match<BiIter>& rhs);
 
-template <class BiIter, class ST, class SA>
+template <class BiIter, class ST, class SA>                                  // Removed in C++20
     bool
     operator>(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
               const sub_match<BiIter>& rhs);
 
-template <class BiIter, class ST, class SA>
+template <class BiIter, class ST, class SA>                                  // Removed in C++20
     bool operator>=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
                     const sub_match<BiIter>& rhs);
 
-template <class BiIter, class ST, class SA>
+template <class BiIter, class ST, class SA>                                  // Removed in C++20
     bool
     operator<=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool
     operator==(const sub_match<BiIter>& lhs,
                const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
-template <class BiIter, class ST, class SA>
+template <class BiIter, class ST, class SA>                                  // Since C++20
+    auto
+    operator<=>(const sub_match<BiIter>& lhs,
+                const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
+template <class BiIter, class ST, class SA>                                  // Removed in C++20
     bool
     operator!=(const sub_match<BiIter>& lhs,
                const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
-template <class BiIter, class ST, class SA>
+template <class BiIter, class ST, class SA>                                  // Removed in C++20
     bool
     operator<(const sub_match<BiIter>& lhs,
               const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
-template <class BiIter, class ST, class SA>
-    bool operator>(const sub_match<BiIter>& lhs,
+template <class BiIter, class ST, class SA>                                  // Removed in C++20
+    bool
+    operator>(const sub_match<BiIter>& lhs,
                    const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
-template <class BiIter, class ST, class SA>
+template <class BiIter, class ST, class SA>                                  // Removed in C++20
     bool
     operator>=(const sub_match<BiIter>& lhs,
                const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
-template <class BiIter, class ST, class SA>
+template <class BiIter, class ST, class SA>                                  // Removed in C++20
     bool
     operator<=(const sub_match<BiIter>& lhs,
                const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator==(typename iterator_traits<BiIter>::value_type const* lhs,
                const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator!=(typename iterator_traits<BiIter>::value_type const* lhs,
                const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator<(typename iterator_traits<BiIter>::value_type const* lhs,
               const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator>(typename iterator_traits<BiIter>::value_type const* lhs,
               const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator>=(typename iterator_traits<BiIter>::value_type const* lhs,
                const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator<=(typename iterator_traits<BiIter>::value_type const* lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator==(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const* rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Since C++20
+    auto
+    operator<=>(const sub_match<BiIter>& lhs,
+                typename iterator_traits<BiIter>::value_type const* rhs);
+
+template <class BiIter, class ST, class SA>                                  // Removed in C++20
     bool
     operator!=(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const* rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator<(const sub_match<BiIter>& lhs,
               typename iterator_traits<BiIter>::value_type const* rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator>(const sub_match<BiIter>& lhs,
               typename iterator_traits<BiIter>::value_type const* rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator>=(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const* rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator<=(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const* rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator==(typename iterator_traits<BiIter>::value_type const& lhs,
                const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator!=(typename iterator_traits<BiIter>::value_type const& lhs,
                const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator<(typename iterator_traits<BiIter>::value_type const& lhs,
               const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator>(typename iterator_traits<BiIter>::value_type const& lhs,
               const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator>=(typename iterator_traits<BiIter>::value_type const& lhs,
                const sub_match<BiIter>& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator<=(typename iterator_traits<BiIter>::value_type const& lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator==(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Since C++20
+    auto
+    operator<=>(const sub_match<BiIter>& lhs,
+                typename iterator_traits<BiIter>::value_type const& rhs);
+
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator!=(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator<(const sub_match<BiIter>& lhs,
               typename iterator_traits<BiIter>::value_type const& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator>(const sub_match<BiIter>& lhs,
               typename iterator_traits<BiIter>::value_type const& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator>=(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const& rhs);
 
-template <class BiIter>
+template <class BiIter>                                                      // Removed in C++20
     bool
     operator<=(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const& rhs);
 
 template <class charT, class ST, class BiIter>
     basic_ostream<charT, ST>&
     operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
 

 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
 {
     return __x.compare(__y) == 0;
 }
 
+#if _LIBCPP_STD_VER >= 20
+template<class _BiIter>
+using __sub_match_cat = compare_three_way_result_t<basic_string<typename iterator_traits<_BiIter>::value_type>>;
+
+template <class _BiIter>
+_LIBCPP_HIDE_FROM_ABI auto operator<=>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
+    return static_cast<__sub_match_cat<_BiIter>>(__x.compare(__y) <=> 0);
+}
+#else // _LIBCPP_STD_VER >= 20
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
 {
     return !(__x == __y);
 }
 

 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
            const sub_match<_BiIter>& __y)
 {
     return !(__y < __x);
 }
+#endif // _LIBCPP_STD_VER >= 20
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const sub_match<_BiIter>& __x,
            const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
 {
     return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) == 0;
 }
 
+#if _LIBCPP_STD_VER >= 20
+template <class _BiIter, class _ST, class _SA>
+_LIBCPP_HIDE_FROM_ABI auto operator<=>(
+    const sub_match<_BiIter>& __x, const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
+    return static_cast<__sub_match_cat<_BiIter>>(
+        __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) <=> 0);
+}
+#else // _LIBCPP_STD_VER >= 20
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const sub_match<_BiIter>& __x,
            const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
 {
     return !(__x == __y);
 }

 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(typename iterator_traits<_BiIter>::value_type const* __x,
            const sub_match<_BiIter>& __y)
 {
     return !(__y < __x);
 }
+#endif // _LIBCPP_STD_VER >= 20
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const* __y)
 {
     return __x.compare(__y) == 0;
 }
 
+#if _LIBCPP_STD_VER >= 20
+template <class _BiIter>
+_LIBCPP_HIDE_FROM_ABI auto
+operator<=>(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
+    return static_cast<__sub_match_cat<_BiIter>>(__x.compare(__y) <=> 0);
+}
+#else // _LIBCPP_STD_VER >= 20
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const* __y)
 {
     return !(__x == __y);
 }

 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(typename iterator_traits<_BiIter>::value_type const& __x,
            const sub_match<_BiIter>& __y)
 {
     return !(__y < __x);
 }
+#endif // _LIBCPP_STD_VER >= 20
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const& __y)
 {
     typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
     return __x.compare(string_type(1, __y)) == 0;
 }
 
+#if _LIBCPP_STD_VER >= 20
+template <class _BiIter>
+_LIBCPP_HIDE_FROM_ABI auto
+operator<=>(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
+    using string_type = basic_string<typename iterator_traits<_BiIter>::value_type>;
+    return static_cast<__sub_match_cat<_BiIter>>(__x.compare(string_type(1, __y)) <=> 0);
+}
+#else // _LIBCPP_STD_VER >= 20
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const& __y)
 {
     return !(__x == __y);
 }

 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const& __y)
 {
     return !(__y < __x);
 }
+#endif // _LIBCPP_STD_VER >= 20
 
 template <class _CharT, class _ST, class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _ST>&
 operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m)
 {
     return __os << __m.str();
 }

libcxx/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
 
 // template <class BidirectionalIterator> class sub_match;
 
+// Note in C++20 several of these operators have been removed and implicitly
+// generated by the compiler using operator== and operator<=>.
+
 // template <class BiIter>
 //     bool
 //     operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 //
 // template <class BiIter>
 //     bool
 //     operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 //

 //     operator>=(const sub_match<BiIter>& lhs,
 //                typename iterator_traits<BiIter>::value_type const& rhs);
 //
 // template <class BiIter>
 //     bool
 //     operator<=(const sub_match<BiIter>& lhs,
 //                typename iterator_traits<BiIter>::value_type const& rhs);
 
+// Added in C++20
+// template <class BiIter>
+//     auto
+//     operator<=>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
+// template <class BiIter, class ST, class SA>
+//     auto
+//     operator<=>(const sub_match<BiIter>& lhs,
+//                 const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+//
+// template <class BiIter>
+//     auto
+//     operator<=>(const sub_match<BiIter>& lhs,
+//                 typename iterator_traits<BiIter>::value_type const* rhs);
+//
+// template <class BiIter>
+//     auto
+//     operator<=>(const sub_match<BiIter>& lhs,
+//                 typename iterator_traits<BiIter>::value_type const& rhs);
+
 #include <regex>
+#include <array>
 #include <cassert>
+
+#include "constexpr_char_traits.h"
+#include "make_string.h"
+#include "test_comparisons.h"
 #include "test_macros.h"
 
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
 template <class CharT>
 void
 test(const std::basic_string<CharT>& x, const std::basic_string<CharT>& y, bool doCStrTests = true)
 {
     typedef std::basic_string<CharT> string;
     typedef std::sub_match<typename string::const_iterator> sub_match;
+#if TEST_STD_VER > 17
+    AssertOrderReturn<std::strong_ordering, sub_match>();
+    AssertOrderReturn<std::strong_ordering, sub_match, string>();
+#else
+    AssertComparisonsReturnBool<sub_match>();
+    AssertComparisonsReturnBool<sub_match, string>();
+#endif
     sub_match sm1;
     sm1.first = x.begin();
     sm1.second = x.end();
     sm1.matched = true;
     sub_match sm2;
     sm2.first = y.begin();
     sm2.second = y.end();
     sm2.matched = true;
-    assert((sm1 == sm2) == (x == y));
-    assert((sm1 != sm2) == (x != y));
-    assert((sm1 < sm2) == (x < y));
-    assert((sm1 > sm2) == (x > y));
-    assert((sm1 <= sm2) == (x <= y));
-    assert((sm1 >= sm2) == (x >= y));
-    assert((x == sm2) == (x == y));
-    assert((x != sm2) == (x != y));
-    assert((x < sm2) == (x < y));
-    assert((x > sm2) == (x > y));
-    assert((x <= sm2) == (x <= y));
-    assert((x >= sm2) == (x >= y));
-    assert((sm1 == y) == (x == y));
-    assert((sm1 != y) == (x != y));
-    assert((sm1 < y) == (x < y));
-    assert((sm1 > y) == (x > y));
-    assert((sm1 <= y) == (x <= y));
-    assert((sm1 >= y) == (x >= y));
+
+    assert(testComparisons(sm1, sm2, x == y, x < y));
+    assert(testComparisons(x, sm2, x == y, x < y));
+    assert(testComparisons(sm1, y, x == y, x < y));
+#if TEST_STD_VER > 17
+    assert(testOrder(sm1, sm2, x <=> y));
+    assert(testOrder(x, sm2, x <=> y));
+    assert(testOrder(sm1, y, x <=> y));
+#endif
+
     if (doCStrTests) {
-        assert((x.c_str() == sm2) == (x == y));
-        assert((x.c_str() != sm2) == (x != y));
-        assert((x.c_str() < sm2) == (x < y));
-        assert((x.c_str() > sm2) == (x > y));
-        assert((x.c_str() <= sm2) == (x <= y));
-        assert((x.c_str() >= sm2) == (x >= y));
-        assert((sm1 == y.c_str()) == (x == y));
-        assert((sm1 != y.c_str()) == (x != y));
-        assert((sm1 < y.c_str()) == (x < y));
-        assert((sm1 > y.c_str()) == (x > y));
-        assert((sm1 <= y.c_str()) == (x <= y));
-        assert((sm1 >= y.c_str()) == (x >= y));
-        }
-    assert((x[0] == sm2) == (string(1, x[0]) == y));
-    assert((x[0] != sm2) == (string(1, x[0]) != y));
-    assert((x[0] < sm2) == (string(1, x[0]) < y));
-    assert((x[0] > sm2) == (string(1, x[0]) > y));
-    assert((x[0] <= sm2) == (string(1, x[0]) <= y));
-    assert((x[0] >= sm2) == (string(1, x[0]) >= y));
-    assert((sm1 == y[0]) == (x == string(1, y[0])));
-    assert((sm1 != y[0]) == (x != string(1, y[0])));
-    assert((sm1 < y[0]) == (x < string(1, y[0])));
-    assert((sm1 > y[0]) == (x > string(1, y[0])));
-    assert((sm1 <= y[0]) == (x <= string(1, y[0])));
-    assert((sm1 >= y[0]) == (x >= string(1, y[0])));
+        assert(testComparisons(x.c_str(), sm2, x == y, x < y));
+        assert(testComparisons(sm1, y.c_str(), x == y, x < y));
+#if TEST_STD_VER > 17
+        assert(testOrder(x.c_str(), sm2, x <=> y));
+        assert(testOrder(sm1, y.c_str(), x <=> y));
+#endif
+
+    assert(testComparisons(x[0], sm2, string(1, x[0]) == y, string(1, x[0]) < y));
+    assert(testComparisons(sm1, y[0], x == string(1, y[0]), x < string(1, y[0])));
+#if TEST_STD_VER > 17
+    assert(testOrder(x[0], sm2, (string(1, x[0]) <=> y)));
+    assert(testOrder(sm1, y[0], x <=> (string(1, y[0]))));
+#endif
 }
 
+#if TEST_STD_VER > 17
+template <class CharT, class Ordering>
+struct char_traits : public constexpr_char_traits<CharT> {
+    using comparison_category = Ordering;
+};
+
+template <class T, class Ordering = std::strong_ordering>
+constexpr void test() {
+  AssertOrderAreNoexcept<T>();
+  AssertOrderReturn<Ordering, T>();
+
+  using CharT = typename T::value_type;
+
+  // sorted values
+  std::array s = [] {
+    std::array input{SV(""), SV("abc"), SV("abcdef")};
+    return std::array{
+        T{input[0].begin(), input[0].end()}, T{input[1].begin(), input[1].end()}, T{input[2].begin(), input[2].end()}};
+  }();
+  auto ctor = [](const T& string) {
+    std::sub_match<typename T::const_iterator> sm;
+    sm.first   = string.begin();
+    sm.second  = string.end();
+    sm.matched = true;
+    return sm;
+  };
+  std::array sm{ctor(s[0]), ctor(s[1]), ctor(s[2])};
+
+  for (std::size_t i = 0; i < s.size(); ++i) {
+    for (std::size_t j = 0; j < s.size(); ++j) {
+      assert(testOrder(s[i], sm[j], i == j ? Ordering::equivalent : i < j ? Ordering::less : Ordering::greater));
+    }
+  }
+}
+
+template <class CharT>
+constexpr void test_all_orderings() {
+  test<std::basic_string<CharT>>(); // Strong ordering in its char_traits
+  test<std::basic_string<CharT, constexpr_char_traits<CharT>>,
+       std::weak_ordering>(); // No ordering in its char_traits
+  test<std::basic_string<CharT, char_traits<CharT, std::weak_ordering>>, std::weak_ordering>();
+  test<std::basic_string<CharT, char_traits<CharT, std::partial_ordering>>, std::partial_ordering>();
+}
+#endif //  TEST_STD_VER > 17
+
 int main(int, char**)
 {
     test(std::string("123"), std::string("123"));
     test(std::string("1234"), std::string("123"));
     test(std::string("123\000" "56", 6), std::string("123\000" "56", 6), false);
+#if TEST_STD_VER > 17
+    test_all_orderings<char>();
+#endif
+
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test(std::wstring(L"123"), std::wstring(L"123"));
     test(std::wstring(L"1234"), std::wstring(L"123"));
     test(std::wstring(L"123\000" L"56", 6), std::wstring(L"123\000" L"56", 6), false);
+#if TEST_STD_VER > 17
+    test_all_orderings<wchar_t>();
 #endif
+#endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }