[libc++] Uses operator<=> in string_view

[Mordante]

Summary

Implements:

• LWG3432 Missing requirement for comparison_category

Implements part of:

• P1614R2 The Mothership has Landed

[Mordante]

libcxx/docs/Status/SpaceshipProjects.csv

35–36

I noticed the link was a review after making my changes, the same or string below.

libcxx/include/__string/char_traits.h

196–199

These all can be using, this will be done in a NFC follow up.

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp

17–18

These all can be using, this will be done in a NFC follow up.

27

All these test can be a compile.pass.cpp like char32_t, this will be done in a NFC follow up.

[Mordante]

CI fixes.

[jloser]

libcxx/include/string_view

832

We currently repeat this pattern of code three times, which is about when I'd start to look to refactor it into a common detail function -- what do you think?

This will eventually (soon) be needed for operator<=> for std::string I believe, right?

Either way, from a QoI perspective, what do you think about checking the type of comparison_category to make sure it is one of partial_ordering, weak_ordering, or strong_ordering and not some bogus type, like void for example? This would be a bug from the user's perspective and likely IFNDR from the standards perspective, but it could be an easy QoI improvement I think.

838

We may want to copy the comment from above to indicate the int = 1 and int = 2 dummy non-type template parameters are to work around an MSVC mangling issue as noted above in the operator==. It says it applies to the other sufficient overloads below for comparison ops, but I wouldn't be opposed to a comment here for spaceship too. Thoughts?

841

Nit: can use common_type_t instead - here and elsewhere.

[philnik]

libcxx/include/string_view

839–846

What breaks if you drop the other two overloads? The compiler should automatically generate the operator<=>(common_type_t<basic_string_view>, basic_string_view) IIUC. Or is that just for operator==?

841

I think this should actually be type_identity_t. You could theoretically have something like

struct CharT {
  // all the stuff to make it char-like
};

struct CharTT {
  template <class Traits>
  CharTT(std::basic_string_view<CharT, Traits>);
 };

template <class Traits>
struct std::common_type<std::basic_string_view<CharT, Traits>, std::basic_string_view<CharT, Traits>> {
  using type = CharTT;
};

right? That would result in a hard error.

[Mordante]

Thanks for the comments! I'll have a look at them.

libcxx/include/string_view

832

We currently repeat this pattern of code three times, which is about when I'd start to look to refactor it into a common detail function -- what do you think?

I feel these functions are small enough to keep the duplicates.

This will eventually (soon) be needed for operator<=> for std::string I believe, right?

No std::string will call std::string_view's operator<=>. I already have a patch for that.
So there will be no additional duplicates.

Either way, from a QoI perspective, what do you think about checking the type of comparison_category to make sure it is one of partial_ordering, weak_ordering, or strong_ordering and not some bogus type, like void for example? This would be a bug from the user's perspective and likely IFNDR from the standards perspective, but it could be an easy QoI improvement I think.

Good point! Interestingly P1614 "The Mothership has Landed" has no restrictions on R, that's why I didn't add it.
However per [string.view.comparison]/4

Mandates: R denotes a comparison category type ([cmp.categories]).

That was changed by https://wg21.link/lwg3432

(Note that we should be careful with adding non-Standard restrictions. The original wording allowed an int by adding a restriction libc++ would become non-conforming. Instead when we want to add restrictions we should file an LWG issue to make it mandated.)

838

I didn't do it since the 5 other operators also didn't have it. But I was a bit tempted to do it, since I was a bit surprised myself.

841

Good point.

[Mordante]

Addresses review comments.

[Mordante]

libcxx/include/string_view

839–846

One of the two can be removed, when I removed the seconds several tests started to fail.
I didn't do a deep investigation.

841

I'm not entirely clear what you mean, can you elaborate?

[philnik]

libcxx/include/string_view

841

You are allowed to specialize std::common_type for types that depend on at least one user-defined type. That means that you could theoretically specialize it for the identity and return a different type. (std::common_type<T> forwards to std::common_type<T, T>) I think you actually want to type_identity_t<basic_string_view<...>> instead, because that guarantees that you get basic_string_view<...> back.

[jloser]

libcxx/include/string_view

841

type_identity_t does work for creating the non-deduced context which means that only one argument would participate in template argument deduction and then the other one would get implicitly converted to the deduced type. Note this is the "sufficient overloads" wording in the standard for string_view's comparison operators.

However, I'm not convinced yet that our implementation is broken for the reason you claim @philnik. Can you add a test to show it's a problem on top-of-tree with the current comparison/relative operators? Note that whatever we do for operator<=>, we should do the same for the comparison/relative operators (==, !=, <, etc.). Currently, we use common_type there and not type_identity_t.

In particular, take a look at the current tests for the sufficient overloads at libcxx/test/std/strings/string.view/string.view.comparison/equal.pass.cpp and friends.

[philnik]

libcxx/include/string_view

841

Here is a reproducer.

[ldionne]

libcxx/include/string_view

841

I think @philnik's right. We should add a test and use __type_identity_t -- regardless, __type_identity_t makes more sense in that context, IDK why the code was written with common_type<T>::type in the first place (does anybody know?).

I would tackle that as a separate patch since this is a fix to the existing code.

libcxx/test/support/constexpr_char_traits.h

27

[jloser]

libcxx/include/string_view

841

Nice test! It does look to be a bug that we should fix on top-of-tree in the sufficient overload cases. Good find.

Re your question, @ldionne, I don't know. When I added the range constructor for std::string_view late last year or so, I recall having to reason about the sufficient overloads due to the mangling issue. At the time, I justified to myself that common_type_t was OK as it was currently written (it's been like this for a while), but I didn't consider the fact that users could specialize common_type.

[Mordante]

All review comments relevant to this review have been resolved. The open issues will be done in followup patches.

libcxx/include/string_view

841

Agreed I'll look at this issue in a separate patch.

[Mordante]

Address review comment.

[avogelsgesang]

libcxx/include/string_view

39

operator< was also removed

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.compile.pass.cpp

24

what is this include used for?

libcxx/test/std/strings/string.view/string.view.comparison/comparison.pass.cpp

63

factor out

auto expected = i == j ? Ordering::equivalent : i < j ? Ordering::less : Ordering::greater;

This condition seems to be duplicated for all of the following asserts

Or maybe even

auto expected = Ordering{i <=> j};

[ldionne]

LGTM, but please wait for other reviewers to be satisfied too.

My understanding is that there will be a follow-up change to switch from common_type_t to __type_identity_t, as we discussed during live review just now.

libcxx/include/string_view

804–805

This looks really strange to me, I'd suggest using else {...}.

libcxx/test/std/strings/string.view/string.view.comparison/comparison.verify.cpp

26

It would be nice to add a non .verify.cpp test with char_traits that explicitly specify a comparison_category that is weak_ordering.

[jloser]

Still looks good from my perspective.

libcxx/include/string_view

841

@Mordante to clarify, the plan is to stick with common_type_t for both the existing comparison operators and the new operator<=> and the bug of not using type_identity_t (__type_identity_t I guess since we backport string_view to older standard modes) will be fixed in both in a follow-up? If so, I'm OK with that.

[Mordante]

libcxx/include/string_view

39

Good catch!

841

Yes I prefer to do both in the same commit.

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.compile.pass.cpp

24

This is a generic test file which is used in most test, like __config in our include files.
In this case it's required for TEST_STD_VER

libcxx/test/std/strings/string.view/string.view.comparison/comparison.pass.cpp

63

For unit tests I prefer to keep things "simple" and sometimes a bit more verbose than really needed.
That makes it easier to understand what's being tested.

For example i <=> j is strong_ordering which will change the value depending on the type of Ordering.

[Mordante]

Rebased to test CI and addresses review comments.

[Mordante]

Fixes CI.

[philnik]

LGTM % nit.

libcxx/include/string_view

803

[Mordante]

libcxx/include/string_view

803

Nice catch!

[Mordante]

libcxx/include/string_view

841

D131322 switches commont_type_t to type_identity_t for both the spaceship operator as the existing operators.

[mumbleskates]

libcxx/test/support/test_comparisons.h

142–143

For posterity, is there a strong reason this nuance was added? As I understand it, the standard mandates that strong_ordering::equal == strong_ordering::equivalent must hold true and the equal name only exists as a historical alias of the same value.

[Mordante]

libcxx/test/support/test_comparisons.h

142–143

Yes since I missed that detail in the Standard ;-) I had a look and they are indeed the same, thanks for asking the question! I'll make a patch to simplify this.

[Mordante]

libcxx/test/support/test_comparisons.h

142–143

Fixed in D131419.

[mumbleskates]

libcxx/test/std/strings/string.view/string.view.comparison/comparison.pass.cpp

126–129

while looking at asserting the returned ordering type inside testOrder() in test_comparisons.h, i found that the only tests in the entire suite that fail are these right here, because test() above immediately discards the char_traits after the assertions it makes with type T on lines 74 and 75. Only those two lines are effectively different; after that, the basic_string and basic_string_view types are reconstructed from the extracted CharT and, for the same CharT, are completely identical.

is this intentional? it seems like it isn't, because every three-way comparison tested after AssertOrderReturn<Ordering, T>(); on line 75 actually produces a std::strong_ordering no matter what.

The good news is that the string view types do indeed seem to return the correct ordering, as it's tested on the first 2 lines, but it seems like this might be unintentionally missed surface area and i can't be sure on my own.

You can see this yourself, by replacing all the ?: expressions with i and j with i <=> j and adding ASSERT_SAME_TYPE(decltype(t1 <=> t2), Order); inside testOrder() and it will pass.

libcxx/docs/Status/Cxx2bIssues.csv

 "Issue #","Issue Name","Meeting","Status","First released version","Labels"
 "`2839 <https://wg21.link/LWG2839>`__","Self-move-assignment of library types, again","November 2020","|Nothing To Do|",""
 "`3117 <https://wg21.link/LWG3117>`__","Missing ``packaged_task`` deduction guides","November 2020","",""
 "`3143 <https://wg21.link/LWG3143>`__","``monotonic_buffer_resource`` growth policy is unclear","November 2020","",""
 "`3195 <https://wg21.link/LWG3195>`__","What is the stored pointer value of an empty ``weak_ptr``?","November 2020","|Nothing To Do|",""
 "`3211 <https://wg21.link/LWG3211>`__","``std::tuple<>`` should be trivially constructible","November 2020","|Complete|","9.0"
 "`3236 <https://wg21.link/LWG3236>`__","Random access iterator requirements lack limiting relational operators domain to comparing those from the same range","November 2020","|Nothing To Do|","","|ranges|"
 "`3265 <https://wg21.link/LWG3265>`__","``move_iterator``'s conversions are more broken after P1207","November 2020","Fixed by `LWG3435 <https://wg21.link/LWG3435>`__",""
 "`3435 <https://wg21.link/LWG3435>`__","``three_way_comparable_with<reverse_iterator<int*>, reverse_iterator<const int*>>``","November 2020","|Complete|","13.0"
-"`3432 <https://wg21.link/LWG3432>`__","Missing requirement for ``comparison_category``","November 2020","","","|spaceship|"
+"`3432 <https://wg21.link/LWG3432>`__","Missing requirement for ``comparison_category``","November 2020","|Complete|","16.0","|spaceship|"
 "`3447 <https://wg21.link/LWG3447>`__","Deduction guides for ``take_view`` and ``drop_view`` have different constraints","November 2020","|Complete|","14.0"
 "`3450 <https://wg21.link/LWG3450>`__","The const overloads of ``take_while_view::begin/end`` are underconstrained","November 2020","","","|ranges|"
 "`3464 <https://wg21.link/LWG3464>`__","``istream::gcount()`` can overflow","November 2020","",""
 "`2731 <https://wg21.link/LWG2731>`__","Existence of ``lock_guard<MutexTypes...>::mutex_type`` typedef unclear","November 2020","|Complete|","5.0"
 "`2743 <https://wg21.link/LWG2743>`__","P0083R3 ``node_handle`` private members missing ""exposition only"" comment","November 2020","|Nothing To Do|",""
 "`2820 <https://wg21.link/LWG2820>`__","Clarify ``<cstdint>`` macros","November 2020","|Nothing To Do|",""
 "`3120 <https://wg21.link/LWG3120>`__","Unclear behavior of ``monotonic_buffer_resource::release()``","November 2020","",""
 "`3170 <https://wg21.link/LWG3170>`__","``is_always_equal`` added to ``std::allocator`` makes the standard library treat derived types as always equal","November 2020","",""

libcxx/docs/Status/SpaceshipProjects.csv

 | variant",None,Kent Ross,|In Progress|
 | `[unique.ptr.special] <https://wg21.link/unique.ptr.special>`_,| `unique_ptr <https://reviews.llvm.org/D130838>`_,[comparisons.three.way],Adrian Vogelsgesang,|In Progress|
 | `[util.smartptr.shared.cmp] <https://wg21.link/util.smartptr.shared.cmp>`_,| `shared_ptr <https://reviews.llvm.org/D130852>`_,[comparisons.three.way],Adrian Vogelsgesang,|Complete|
 | `[type.index.members] <https://wg21.link/type.index.members>`_,| type_index,None,Unassigned,|Not Started|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| to_chars_result,None,Mark de Wever,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| from_chars_result,None,Mark de Wever,|Complete|
 | `[stacktrace.entry.cmp] <https://wg21.link/stacktrace.entry.cmp>`_,| stacktrace_entry,None,Unassigned,|Not Started|
 | `[stacktrace.basic.cmp] <https://wg21.link/stacktrace.basic.cmp>`_,| basic_stacktrace,[alg.three.way],Unassigned,|Not Started|
 | `[string.cmp] <https://wg21.link/string.cmp>`_,| basic_string,None,Mark de Wever,|In Progress|
-| `[string.view.comparison] <https://wg21.link/string.view.comparison>`_,| `basic_string_view <https://reviews.llvm.org/D130295>`_,None,Mark de Wever,|In Progress|
+| `[string.view.comparison] <https://wg21.link/string.view.comparison>`_,| `basic_string_view <https://reviews.llvm.org/D130295>`_,None,Mark de Wever,|Complete|
 | `[array.syn] <https://wg21.link/array.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| array,[expos.only.func],Unassigned,|Not Started|
 | `[deque.syn] <https://wg21.link/deque.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| deque,[expos.only.func],Unassigned,|Not Started|
 | `[forward.list.syn] <https://wg21.link/forward.list.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| forward_list,[expos.only.func],Unassigned,|Not Started|
 | `[list.syn] <https://wg21.link/list.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| list,[expos.only.func],Unassigned,|Not Started|
 | `[vector.syn] <https://wg21.link/vector.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| vector,[expos.only.func],Unassigned,|Not Started|
 | `[associative.map.syn] <https://wg21.link/associative.map.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),"| map
 | multimap",[expos.only.func],Unassigned,|Not Started|
 | `[associative.set.syn] <https://wg21.link/associative.set.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),"| multiset

libcxx/include/__compare/ordering.h

private:
   _ValueT __value_;
 };
 
 inline constexpr strong_ordering strong_ordering::less(_OrdResult::__less);
 inline constexpr strong_ordering strong_ordering::equal(_OrdResult::__equiv);
 inline constexpr strong_ordering strong_ordering::equivalent(_OrdResult::__equiv);
 inline constexpr strong_ordering strong_ordering::greater(_OrdResult::__greater);
 
+/// [cmp.categories.pre]/1
+/// The types partial_ordering, weak_ordering, and strong_ordering are
+/// collectively termed the comparison category types.
+template <class _Tp>
+concept __comparison_category = __one_of_v<_Tp, partial_ordering, weak_ordering, strong_ordering>;
+
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___COMPARE_ORDERING_H

libcxx/include/__string/char_traits.h

 #include <__algorithm/copy_n.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/find_end.h>
 #include <__algorithm/find_first_of.h>
 #include <__algorithm/min.h>
 #include <__config>
 #include <__functional/hash.h>
 #include <__iterator/iterator_traits.h>
+#include <compare>
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
 #include <iosfwd>
 #include <type_traits>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #   include <cwchar> // for wmemcpy

 
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char>
 {
     typedef char      char_type;
     typedef int       int_type;
     typedef streamoff off_type;
     typedef streampos pos_type;
     typedef mbstate_t state_type;
+#if _LIBCPP_STD_VER > 17
+    using comparison_category = strong_ordering;
+#endif
 
     static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
     void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
             {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
         {return (unsigned char)__c1 < (unsigned char)__c2;}
 

 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>
 {
     typedef wchar_t   char_type;
     typedef wint_t    int_type;
     typedef streamoff off_type;
     typedef streampos pos_type;
     typedef mbstate_t state_type;
+#  if _LIBCPP_STD_VER > 17
+    using comparison_category = strong_ordering;
+#  endif
 
     static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
     void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 < __c2;}
 

 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char8_t>
 {
     typedef char8_t        char_type;
     typedef unsigned int   int_type;
     typedef streamoff      off_type;
     typedef u8streampos    pos_type;
     typedef mbstate_t      state_type;
+#  if _LIBCPP_STD_VER > 17
+    using comparison_category = strong_ordering;
+#  endif
 
     static inline constexpr void assign(char_type& __c1, const char_type& __c2) noexcept
         {__c1 = __c2;}
     static inline constexpr bool eq(char_type __c1, char_type __c2) noexcept
         {return __c1 == __c2;}
     static inline constexpr bool lt(char_type __c1, char_type __c2) noexcept
         {return __c1 < __c2;}
 

 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t>
 {
     typedef char16_t       char_type;
     typedef uint_least16_t int_type;
     typedef streamoff      off_type;
     typedef u16streampos   pos_type;
     typedef mbstate_t      state_type;
+#if _LIBCPP_STD_VER > 17
+    using comparison_category = strong_ordering;
+#endif
 
     static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
     void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 < __c2;}
 

 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char32_t>
 {
     typedef char32_t       char_type;
     typedef uint_least32_t int_type;
     typedef streamoff      off_type;
     typedef u32streampos   pos_type;
     typedef mbstate_t      state_type;
+#if _LIBCPP_STD_VER > 17
+    using comparison_category = strong_ordering;
+#endif
 
     static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
     void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 < __c2;}
 

libcxx/include/string_view

 // -*- 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_STRING_VIEW
 #define _LIBCPP_STRING_VIEW
 
 /*
 
     string_view synopsis
 
+#include <compare>
+
 namespace std {
 
     // 7.2, Class template basic_string_view
     template<class charT, class traits = char_traits<charT>>
         class basic_string_view;
 
     template<class charT, class traits>
     inline constexpr bool ranges::enable_view<basic_string_view<charT, traits>> = true;
 
     template<class charT, class traits>
     inline constexpr bool ranges::enable_borrowed_range<basic_string_view<charT, traits>> = true;  // C++20
 
     // 7.9, basic_string_view non-member comparison functions
     template<class charT, class traits>
     constexpr bool operator==(basic_string_view<charT, traits> x,
                               basic_string_view<charT, traits> y) noexcept;
-    template<class charT, class traits>
+    template<class charT, class traits>                                                            // Removed in C++20
     constexpr bool operator!=(basic_string_view<charT, traits> x,
                               basic_string_view<charT, traits> y) noexcept;
-    template<class charT, class traits>
+    template<class charT, class traits>                                                            // Removed in C++20
     constexpr bool operator< (basic_string_view<charT, traits> x,
                                  basic_string_view<charT, traits> y) noexcept;
-    template<class charT, class traits>
+    template<class charT, class traits>                                                            // Removed in C++20
     constexpr bool operator> (basic_string_view<charT, traits> x,
                               basic_string_view<charT, traits> y) noexcept;
-    template<class charT, class traits>
+    template<class charT, class traits>                                                            // Removed in C++20
     constexpr bool operator<=(basic_string_view<charT, traits> x,
                                  basic_string_view<charT, traits> y) noexcept;
-    template<class charT, class traits>
+    template<class charT, class traits>                                                            // Removed in C++20
     constexpr bool operator>=(basic_string_view<charT, traits> x,
                               basic_string_view<charT, traits> y) noexcept;
+    template<class charT, class traits>                                                            // Since C++20
+    constexpr see below operator<=>(basic_string_view<charT, traits> x,
+                                    basic_string_view<charT, traits> y) noexcept;
+
     // see below, sufficient additional overloads of comparison functions
 
     // 7.10, Inserters and extractors
     template<class charT, class traits>
       basic_ostream<charT, traits>&
         operator<<(basic_ostream<charT, traits>& os,
                    basic_string_view<charT, traits> str);
 

 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator==(basic_string_view<_CharT, _Traits> __lhs,
                 typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 {
     if ( __lhs.size() != __rhs.size()) return false;
     return __lhs.compare(__rhs) == 0;
 }
 
+#if _LIBCPP_STD_VER < 20
+// This overload is automatically generated in C++20.
 template<class _CharT, class _Traits, int = 2>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator==(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
                 basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
     if ( __lhs.size() != __rhs.size()) return false;
     return __lhs.compare(__rhs) == 0;
 }
+#endif // _LIBCPP_STD_VER > 17
+
+// operator <=>
+
+#if _LIBCPP_STD_VER > 17
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI constexpr auto
+operator<=>(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) noexcept {
+    if constexpr (requires { typename _Traits::comparison_category; }) {
+        // [string.view]/4
+        static_assert(
+            __comparison_category<typename _Traits::comparison_category>,
+            "return type is not a comparison category type");
+        return static_cast<typename _Traits::comparison_category>(__lhs.compare(__rhs) <=> 0);
+    } else {
+        return static_cast<weak_ordering>(__lhs.compare(__rhs) <=> 0);
+    }
+}
 
+template <class _CharT, class _Traits, int = 1>
+_LIBCPP_HIDE_FROM_ABI constexpr auto operator<=>(
+    basic_string_view<_CharT, _Traits> __lhs, common_type_t<basic_string_view<_CharT, _Traits>> __rhs) noexcept {
+    if constexpr (requires { typename _Traits::comparison_category; }) {
+        // [string.view]/4
+        static_assert(
+            __comparison_category<typename _Traits::comparison_category>,
+            "return type is not a comparison category type");
+        return static_cast<typename _Traits::comparison_category>(__lhs.compare(__rhs) <=> 0);
+    } else {
+        return static_cast<weak_ordering>(__lhs.compare(__rhs) <=> 0);
+    }
+}
+
+#else //  _LIBCPP_STD_VER > 17
 
 // operator !=
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
     if ( __lhs.size() != __rhs.size())
         return true;
     return __lhs.compare(__rhs) != 0;
 }
 
 template<class _CharT, class _Traits, int = 1>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator!=(basic_string_view<_CharT, _Traits> __lhs,
                 typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 {
     if ( __lhs.size() != __rhs.size())
         return true;
     return __lhs.compare(__rhs) != 0;
 }
 
 template<class _CharT, class _Traits, int = 2>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator!=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
                 basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
     if ( __lhs.size() != __rhs.size())
         return true;
     return __lhs.compare(__rhs) != 0;
 }
 

 template<class _CharT, class _Traits, int = 2>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator>=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
                 basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
     return __lhs.compare(__rhs) >= 0;
 }
 
+#endif //  _LIBCPP_STD_VER > 17
 
 template<class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
            basic_string_view<_CharT, _Traits> __str);
 
 // [string.view.hash]
 template<class _CharT>

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<> struct char_traits<char>
 
 // typedef char      char_type;
 // typedef int       int_type;
 // typedef streamoff off_type;
 // typedef streampos pos_type;
 // typedef mbstate_t state_type;
+// using comparison_category = strong_ordering;
 
 #include <string>
 #include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     static_assert((std::is_same<std::char_traits<char>::char_type, char>::value), "");
     static_assert((std::is_same<std::char_traits<char>::int_type, int>::value), "");
     static_assert((std::is_same<std::char_traits<char>::off_type, std::streamoff>::value), "");
     static_assert((std::is_same<std::char_traits<char>::pos_type, std::streampos>::value), "");
     static_assert((std::is_same<std::char_traits<char>::state_type, std::mbstate_t>::value), "");
+#if TEST_STD_VER > 17
+    static_assert(std::is_same_v<std::char_traits<char>::comparison_category, std::strong_ordering>);
+#endif
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp

 
 // template<> struct char_traits<char16_t>
 
 // typedef char16_t       char_type;
 // typedef uint_least16_t int_type;
 // typedef streamoff      off_type;
 // typedef u16streampos   pos_type;
 // typedef mbstate_t      state_type;
+// using comparison_category = strong_ordering;
 
 #include <string>
 #include <type_traits>
 #include <cstdint>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     static_assert((std::is_same<std::char_traits<char16_t>::char_type, char16_t>::value), "");
     static_assert((std::is_same<std::char_traits<char16_t>::int_type, std::uint_least16_t>::value), "");
     static_assert((std::is_same<std::char_traits<char16_t>::off_type, std::streamoff>::value), "");
     static_assert((std::is_same<std::char_traits<char16_t>::pos_type, std::u16streampos>::value), "");
     static_assert((std::is_same<std::char_traits<char16_t>::state_type, std::mbstate_t>::value), "");
+#if TEST_STD_VER > 17
+    static_assert(std::is_same_v<std::char_traits<char16_t>::comparison_category, std::strong_ordering>);
+#endif
 
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.compile.pass.cpp

 
 // template<> struct char_traits<char32_t>
 
 // typedef char32_t       char_type;
 // typedef uint_least32_t int_type;
 // typedef streamoff      off_type;
 // typedef u32streampos   pos_type;
 // typedef mbstate_t      state_type;
+// using comparison_category = strong_ordering;
 
 #include <string>
 #include <type_traits>
 #include <cstdint>
 
+#include "test_macros.h"
+
 static_assert((std::is_same<std::char_traits<char32_t>::char_type, char32_t>::value), "");
 static_assert((std::is_same<std::char_traits<char32_t>::int_type, std::uint_least32_t>::value), "");
 static_assert((std::is_same<std::char_traits<char32_t>::off_type, std::streamoff>::value), "");
 static_assert((std::is_same<std::char_traits<char32_t>::pos_type, std::u32streampos>::value), "");
 static_assert((std::is_same<std::char_traits<char32_t>::state_type, std::mbstate_t>::value), "");
+#if TEST_STD_VER > 17
+static_assert(std::is_same_v<std::char_traits<char32_t>::comparison_category, std::strong_ordering>);
+#endif

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp

 
 // template<> struct char_traits<char8_t>
 
 // typedef char8_t        char_type;
 // typedef unsigned int   int_type;
 // typedef streamoff      off_type;
 // typedef u8streampos    pos_type;
 // typedef mbstate_t      state_type;
+// using comparison_category = strong_ordering;
 
 #include <string>
 #include <type_traits>
 #include <cstdint>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     static_assert((std::is_same<std::char_traits<char8_t>::char_type,  char8_t>::value), "");
     static_assert((std::is_same<std::char_traits<char8_t>::int_type,   unsigned int>::value), "");
     static_assert((std::is_same<std::char_traits<char8_t>::off_type,   std::streamoff>::value), "");
     static_assert((std::is_same<std::char_traits<char8_t>::pos_type,   std::u8streampos>::value), "");
     static_assert((std::is_same<std::char_traits<char8_t>::state_type, std::mbstate_t>::value), "");
+    static_assert(std::is_same_v<std::char_traits<char8_t>::comparison_category, std::strong_ordering>);
 #endif
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp

 
 // template<> struct char_traits<wchar_t>
 
 // typedef wchar_t   char_type;
 // typedef int       int_type;
 // typedef streamoff off_type;
 // typedef streampos pos_type;
 // typedef mbstate_t state_type;
+// using comparison_category = strong_ordering;
 
 // UNSUPPORTED: no-wide-characters
 
 #include <string>
 #include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     static_assert((std::is_same<std::char_traits<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::char_traits<wchar_t>::int_type, std::wint_t>::value), "");
     static_assert((std::is_same<std::char_traits<wchar_t>::off_type, std::streamoff>::value), "");
     static_assert((std::is_same<std::char_traits<wchar_t>::pos_type, std::wstreampos>::value), "");
     static_assert((std::is_same<std::char_traits<wchar_t>::state_type, std::mbstate_t>::value), "");
+#if TEST_STD_VER > 17
+    static_assert(std::is_same_v<std::char_traits<wchar_t>::comparison_category, std::strong_ordering>);
+#endif
 
   return 0;
 }

libcxx/test/std/strings/string.view/string.view.comparison/comparison.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
+//
+//===----------------------------------------------------------------------===//
+
+// Starting with C++20 the spaceship operator was included. This tests
+// comparison in that context, thus doesn't support older language versions.
+// These are tested per operator.
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <string_view>
+
+// template<class charT, class traits>
+//   constexpr bool operator==(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
+// template<class charT, class traits>
+//   constexpr auto operator<=>(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
+// (plus "sufficient additional overloads" to make implicit conversions work as intended)
+
+#include <string_view>
+
+#include <array>
+#include <cassert>
+#include <string>
+
+#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)
+
+// Copied from constexpr_char_traits, but it doesn't have a full implementation.
+// It has a comparison_category used in the tests.
+template <class CharT, class Ordering>
+struct char_traits {
+  using char_type           = CharT;
+  using int_type            = int;
+  using off_type            = std::streamoff;
+  using pos_type            = std::streampos;
+  using state_type          = std::mbstate_t;
+  using comparison_category = Ordering;
+
+  static constexpr void assign(char_type& __c1, const char_type& __c2) noexcept { __c1 = __c2; }
+  static constexpr bool eq(char_type __c1, char_type __c2) noexcept { return __c1 == __c2; }
+  static constexpr bool lt(char_type __c1, char_type __c2) noexcept { return __c1 < __c2; }
+  static constexpr int compare(const char_type* __s1, const char_type* __s2, size_t __n) {
+    for (; __n; --__n, ++__s1, ++__s2) {
+      if (lt(*__s1, *__s2))
+        return -1;
+      if (lt(*__s2, *__s1))
+        return 1;
+    }
+    return 0;
+  }
+
+  static constexpr size_t length(const char_type* __s);
+  static constexpr const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
+  static constexpr char_type* move(char_type* __s1, const char_type* __s2, size_t __n);
+  static constexpr char_type* copy(char_type* __s1, const char_type* __s2, size_t __n);
+  static constexpr char_type* assign(char_type* __s, size_t __n, char_type __a);
+  static constexpr int_type not_eof(int_type __c) noexcept { return eq_int_type(__c, eof()) ? ~eof() : __c; }
+  static constexpr char_type to_char_type(int_type __c) noexcept { return char_type(__c); }
+  static constexpr int_type to_int_type(char_type __c) noexcept { return int_type(__c); }
+  static constexpr bool eq_int_type(int_type __c1, int_type __c2) noexcept { return __c1 == __c2; }
+  static constexpr int_type eof() noexcept { return int_type(EOF); }
+};
+
+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 v{
+      SV(""),
+      SV("abc"),
+      SV("abcdef"),
+  };
+
+  // sorted values with embedded NUL character
+  std::array vn{
+      SV("abc"),
+      SV("abc\0"),
+      SV("abc\0def"),
+  };
+  static_assert(v.size() == vn.size());
+
+  for (size_t i = 0; i < v.size(); ++i) {
+    for (size_t j = 0; j < v.size(); ++j) {
+      assert(testOrder(v[i], v[j], i == j ? Ordering::equivalent : i < j ? Ordering::less : Ordering::greater));
+      assert(testOrder(
+          v[i],
+          std::basic_string<CharT>{v[j]},
+          i == j  ? Ordering::equivalent
+          : i < j ? Ordering::less
+                  : Ordering::greater));
+
+      assert(testOrder(
+          v[i],
+          std::basic_string<CharT>{v[j]}.c_str(),
+          i == j  ? Ordering::equivalent
+          : i < j ? Ordering::less
+                  : Ordering::greater));
+
+      // NUL test omitted for c-strings since it will fail.
+      assert(testOrder(vn[i], vn[j], i == j ? Ordering::equivalent : i < j ? Ordering::less : Ordering::greater));
+      assert(testOrder(
+          vn[i],
+          std::basic_string<CharT>{vn[j]},
+          i == j  ? Ordering::equivalent
+          : i < j ? Ordering::less
+                  : Ordering::greater));
+    }
+  }
+}
+
+template <class CharT>
+constexpr void test_all_orderings() {
+  test<std::basic_string_view<CharT>>(); // Strong ordering in its char_traits
+  test<std::basic_string_view<CharT, constexpr_char_traits<CharT>>,
+       std::weak_ordering>(); // No ordering in its char_traits
+  test<std::basic_string_view<CharT, char_traits<CharT, std::weak_ordering>>, std::weak_ordering>();
+  test<std::basic_string_view<CharT, char_traits<CharT, std::partial_ordering>>, std::partial_ordering>();
+}
+
+constexpr bool test_all_types() {
+  test_all_orderings<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_all_orderings<wchar_t>();
+#endif
+  test_all_orderings<char8_t>();
+  test_all_orderings<char16_t>();
+  test_all_orderings<char32_t>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test_all_types();
+  static_assert(test_all_types());
+
+  return 0;
+}

libcxx/test/std/strings/string.view/string.view.comparison/comparison.verify.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <string_view>
+
+// template<class charT, class traits>
+//   constexpr auto operator<=>(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
+//
+// LWG 3432
+// [string.view]/4
+// Mandates: R denotes a comparison category type ([cmp.categories]).
+
+#include <string_view>
+
+#include "test_macros.h"
+
+template <class CharT, class Ordering>
+struct traits {
+  typedef CharT char_type;
+  typedef int int_type;
+  typedef std::streamoff off_type;
+  typedef std::streampos pos_type;
+  typedef std::mbstate_t state_type;
+  using comparison_category = Ordering;
+
+  static constexpr void assign(char_type&, const char_type&) noexcept;
+  static constexpr bool eq(char_type&, const char_type&) noexcept;
+  static constexpr bool lt(char_type&, const char_type&) noexcept;
+
+  static constexpr int compare(const char_type*, const char_type*, size_t) { return 0; }
+  static constexpr size_t length(const char_type*);
+  static constexpr const char_type* find(const char_type*, size_t, const char_type&);
+  static constexpr char_type* move(char_type*, const char_type*, size_t);
+  static constexpr char_type* copy(char_type*, const char_type*, size_t);
+  static constexpr char_type* assign(char_type*, size_t, char_type);
+
+  static constexpr int_type not_eof(int_type) noexcept;
+
+  static constexpr char_type to_char_type(int_type) noexcept;
+
+  static constexpr int_type to_int_type(char_type) noexcept;
+
+  static constexpr bool eq_int_type(int_type, int_type) noexcept;
+
+  static constexpr int_type eof() noexcept;
+};
+
+template <class CharT, class Ordering, bool Valid>
+void test() {
+  using type = std::basic_string_view<CharT, traits<CharT, Ordering>>;
+  if constexpr (Valid)
+    type{} <=> type{};
+  else
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  // These diagnostics are issued for
+  // - Every invalid ordering
+  // - Every type
+  // expected-error-re@string_view:* 15 {{{{(static_assert|static assertion)}} failed{{.*}}return type is not a comparison category type}}
+
+  // This diagnostic is not issued for Ordering == void.
+  // expected-error@string_view:* 10 {{no matching conversion for static_cast from}}
+#else
+  // One less test run when wchar_t is unavailable.
+  // expected-error-re@string_view:* 12 {{{{(static_assert|static assertion)}} failed{{.*}}return type is not a comparison category type}}
+  // expected-error@string_view:* 8 {{no matching conversion for static_cast from}}
+#endif
+    type{} <=> type{};
+}
+
+template <class CharT>
+void test_all_orders() {
+  test<CharT, std::strong_ordering, true>();
+  test<CharT, std::weak_ordering, true>();
+  test<CharT, std::partial_ordering, true>();
+
+  test<CharT, void, false>();
+  test<CharT, int, false>();
+  test<CharT, float, false>();
+}
+
+void test_all_types() {
+  test_all_orders<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_all_orders<wchar_t>();
+#endif
+  test_all_orders<char8_t>();
+  test_all_orders<char16_t>();
+  test_all_orders<char32_t>();
+}

libcxx/test/support/constexpr_char_traits.h

 template <class _CharT>
 struct constexpr_char_traits
 {
     typedef _CharT    char_type;
     typedef int       int_type;
     typedef std::streamoff off_type;
     typedef std::streampos pos_type;
     typedef std::mbstate_t state_type;
+    // The comparison_category is omitted so the class will have weak_ordering
+    // in C++20. This is intentional.
 
     static TEST_CONSTEXPR_CXX14 void assign(char_type& __c1, const char_type& __c2) TEST_NOEXCEPT
         {__c1 = __c2;}
 
     static TEST_CONSTEXPR bool eq(char_type __c1, char_type __c2) TEST_NOEXCEPT
         {return __c1 == __c2;}
 
     static TEST_CONSTEXPR  bool lt(char_type __c1, char_type __c2) TEST_NOEXCEPT

libcxx/test/support/test_comparisons.h

 //
 //      AssertOrderConvertibleToBool doesn't exist yet. It will be implemented when needed.
 
 #ifndef TEST_COMPARISONS_H
 #define TEST_COMPARISONS_H
 
 #include <type_traits>
 #include <cassert>
+#include <concepts>
 #include "test_macros.h"
 
 //  Test all six comparison operations for sanity
 template <class T, class U = T>
 TEST_CONSTEXPR_CXX14 bool testComparisons(const T& t1, const U& t2, bool isEqual, bool isLess)
 {
     assert(!(isEqual && isLess) && "isEqual and isLess cannot be both true");
     if (isEqual)

 {
     const bool isEqual = val1 == val2;
     const bool isLess  = val1  < val2;
 
     return testComparisons(T(val1), T(val2), isEqual, isLess);
 }
 
 template <class T, class U = T>
-void AssertComparisonsAreNoexcept()
-{
+TEST_CONSTEXPR_CXX14 void AssertComparisonsAreNoexcept() {
     ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() <  std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() <= std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() >  std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() >= std::declval<const U&>());
 }
 
 template <class T, class U = T>
-void AssertComparisonsReturnBool()
-{
+TEST_CONSTEXPR_CXX14 void AssertComparisonsReturnBool() {
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const U&>()), bool);
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const U&>()), bool);
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <  std::declval<const U&>()), bool);
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <= std::declval<const U&>()), bool);
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >  std::declval<const U&>()), bool);
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >= std::declval<const U&>()), bool);
 }
 
-
 template <class T, class U = T>
 void AssertComparisonsConvertibleToBool()
 {
     static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const U&>()), bool>::value), "");
     static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const U&>()), bool>::value), "");
     static_assert((std::is_convertible<decltype(std::declval<const T&>() <  std::declval<const U&>()), bool>::value), "");
     static_assert((std::is_convertible<decltype(std::declval<const T&>() <= std::declval<const U&>()), bool>::value), "");
     static_assert((std::is_convertible<decltype(std::declval<const T&>() >  std::declval<const U&>()), bool>::value), "");
     static_assert((std::is_convertible<decltype(std::declval<const T&>() >= std::declval<const U&>()), bool>::value), "");
 }
 
 #if TEST_STD_VER > 17
 template <class T, class U = T>
-void AssertOrderAreNoexcept() {
+constexpr void AssertOrderAreNoexcept() {
     AssertComparisonsAreNoexcept<T, U>();
     ASSERT_NOEXCEPT(std::declval<const T&>() <=> std::declval<const U&>());
 }
 
 template <class Order, class T, class U = T>
-void AssertOrderReturn() {
+constexpr void AssertOrderReturn() {
     AssertComparisonsReturnBool<T, U>();
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <=> std::declval<const U&>()), Order);
 }
 
 template <class Order, class T, class U = T>
 constexpr bool testOrder(const T& t1, const U& t2, Order order) {
-  return (t1 <=> t2 == order) &&
-         testComparisons(t1, t2, order == Order::equal || order == Order::equivalent, order == Order::less);
+    bool equal = order == Order::equivalent;
+    if constexpr (std::same_as<Order, std::strong_ordering>)
+        equal |= order == Order::equal;
+
+    bool less = order == Order::less;
+
+    return (t1 <=> t2 == order) && testComparisons(t1, t2, equal, less);
 }
 
 template <class T, class Param>
 constexpr bool testOrderValues(Param val1, Param val2) {
   return testOrder(T(val1), T(val2), val1 <=> val2);
 }
 
 #endif