[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

36

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

libcxx/include/__string/char_traits.h

196

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

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

796

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.

802

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?

805

Nit: can use common_type_t instead - here and elsewhere.

[philnik]

libcxx/include/string_view

803–810

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==?

805

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

796

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.)

802

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.

805

Good point.

[Mordante]

Addresses review comments.

[Mordante]

libcxx/include/string_view

803–810

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

805

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

[philnik]

libcxx/include/string_view

805

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

805

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

805

Here is a reproducer.

[ldionne]

libcxx/include/string_view

805

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

805

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

805

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

802–803

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

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

25 ↗

(On Diff #449037)

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

805

@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!

805

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

801

[Mordante]

libcxx/include/string_view

801

Nice catch!

[Mordante]

libcxx/include/string_view

805

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

141–142

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

141–142

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

141–142

Fixed in D131419.

[mumbleskates]

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

127–130

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/SpaceshipProjects.csv

 | `[unique.ptr.special] <https://wg21.link/unique.ptr.special>`_,| unique_ptr,[comparisons.three.way],Unassigned,|Not Started|
 | `[util.smartptr.shared.cmp] <https://wg21.link/util.smartptr.shared.cmp>`_,| shared_ptr,[comparisons.three.way],Unassigned,|Not Started|
 | `[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 <https://reviews.llvm.org/D80895>`_,None,Christopher Di Bella,|In Progress|
-| `[string.view.comparison] <https://wg21.link/string.view.comparison>`_,| `basic_string_view <https://reviews.llvm.org/D80891>`_,None,Christopher Di Bella,|In Progress|
+| `[string.view.comparison] <https://wg21.link/string.view.comparison>`_,|,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/__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>
     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);
 

 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;
 }
 
 
+#if _LIBCPP_STD_VER > 17
+
+// operator <=>
+
+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; })
+        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,
+    typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) noexcept {
+    if constexpr (requires { typename _Traits::comparison_category; })
+        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 = 2>
+_LIBCPP_HIDE_FROM_ABI constexpr auto operator<=>(
+    typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
+    basic_string_view<_CharT, _Traits> __rhs) noexcept {
+    if constexpr (requires { typename _Traits::comparison_category; })
+        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 = 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>
 
 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), "");
+static_assert(std::is_same_v<std::char_traits<char32_t>::comparison_category, std::strong_ordering>);

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)
+
+template <class T, class Ordering = std::strong_ordering>
+constexpr bool test() {
+  AssertOrderAreNoexcept<T>();
+  AssertOrderReturn<Ordering, T>();
+
+  using CharT = typename T::value_type;
+
+  // sorted values
+  std::array v{
+      SV(""),
+      SV("abc"),
+      SV("abcdef"),
+      SV("acb"),
+  };
+
+  // sorted values with embedded NUL character
+  std::array vn{
+      SV("abc"),
+      SV("abc\0"),
+      SV("abc\0def"),
+      SV("acb\0"),
+  };
+  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));
+    }
+  }
+
+  return true;
+}
+
+constexpr bool test_all_types() {
+  test<std::string_view>();
+  test<std::basic_string_view<char, constexpr_char_traits<char>>, std::weak_ordering>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<std::wstring_view>();
+  test<std::basic_string_view<wchar_t, constexpr_char_traits<wchar_t>>, std::weak_ordering>();
+#endif
+  test<std::u8string_view>();
+  test<std::basic_string_view<char8_t, constexpr_char_traits<char8_t>>, std::weak_ordering>();
+  test<std::u16string_view>();
+  test<std::basic_string_view<char16_t, constexpr_char_traits<char16_t>>, std::weak_ordering>();
+  test<std::u32string_view>();
+  test<std::basic_string_view<char32_t, constexpr_char_traits<char32_t>>, std::weak_ordering>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test_all_types();
+  static_assert(test_all_types());
+
+  return 0;
+}

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 intentionally.
 
     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

 {
     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