[libcxx] adds consistent comparison for `basic_string_view`

[mumbleskates]

Summary

• Adds comparison_category alias to specialised char_traits.
• Removes operator!= and inequality operators for basic_string_view (in C++20 mode).
• Adds operator<=> for basic_string_view (in C++20 mode).

Implements parts of P1614 'The Mothership Has Landed'.

Depends on D101708.

[miscco]

Thanks for working on this. I have some small nits.

libcxx/include/__string

62

I would suggest to create define like the other we usually find, e.g _LIBCPP_STRING_HAS_NO_SPACESHIP_OPERATOR (Note that they are usually negated)

Then these could all be turned into
#ifndef _LIBCPP_STRING_HAS_NO_SPACESHIP_OPERATOR

libcxx/include/compare

250

I guess this is missing _LIBCPP_INLINE_VISIBILITY

368

Missing _LIBCPP_INLINE_VISIBILITY here?

libcxx/include/string_view

807

Could you define operator== outside of the #ifdef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR so you do not have to duplicate the logic

830

Out of curriosity. Do you have a working example where result `would *not* be the right comparison category?

[cjdb]

Applies @miscco's suggestions.

[cjdb]

Thanks @miscco!

libcxx/include/__string

62

Ack, I forgot to clean this one up. What's the advantage of _LIBCPP_STRING_HAS_NO_SPACESHIP_OPERATOR over _LIBCPP_HAS_NO_SPACESHIP_OPERATOR?

libcxx/include/compare

250

Does it need that? We've defined it here, so it should already have inline visibility.

libcxx/include/string_view

830

For a live example, see lines 64-79 in the test case below.

I guess the reason it was designed this way is for backwards compatibility. Someone who designed their char_traits specialisation 20 years ago shouldn't be penalised for not having this trait.

[miscco]

libcxx/include/__string

62

I thought that is defined as:

#if !defined(__cpp_impl_three_way_comparison)
    #define _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
#endif

Which honestly should be essentially the same

libcxx/include/compare

250

In the worst case we improved the consitency with all other methods.

libcxx/include/string_view

631

While I personally am in favor of reusing code I want to note that this carries some nonzero cost of creating a string_view.

This will almost certainly be optimized aways in RELEASE but will be noticeable in DEBUG.

I am kind of curios what the maintainers think about this. I know @BillyONeal avoids these miniscule pessimizations like the plague.

[EricWF]

libcxx/include/__string

63

Please use unconditional includes.

360

Please use _LIBCPP_STD_VER, never __cplusplus.

Also, isn't this check the same as #if !defined(_LIBCPP_HAS_NO_SPACESHP_OPERATOR).

468

#if blocks should be left justified.

603

What's the reason for the different preprocessor guards?

libcxx/include/compare

368

Does this work if we don't have support for the spaceship operator?

libcxx/include/string_view

632

Aren't we losing the short circuit for strings of different lengths?
That optimization seems pretty important.

[cjdb]

Fixes some of @EricWF's comments.

libcxx/include/__string

603

I think I didn't know about _LIBCPP_HAS_NO_SPACESHP_OPERATOR when I was writing these and forgot to change them all.

libcxx/include/compare

368

Can weak_ordering, etc., even be available if we don't have spaceship support?

libcxx/include/string_view

632

It is still present in operator==(basic_string_view, basic_string_view), which is where the body of work happens. Do you want it put back into this "delegating" operator?

Alternatively, I can follow @miscco's note above. I left that unresolved as I felt it was pending further input.

[EricWF]

libcxx/include/string_view

631

Why are we creating a copy of the string view at all?

Isn't the point of this overload to create a string view in the conversion of the argument to the parameter type?

That is, common_type_t<basic_string_view<_Char, _Traits>> == basic_string_view<_Char, _Traits>, no?

641

Please don't introduce a dependency on concepts here.

Instead, use something like:

template <class _Tp>
using __test_for_comparison_category = typename _Tp::comparison_category;

if constexpr ( _IsValidExpansion<__test_for_comparison_category, _Traits>::value ) {

[cjdb]

Applies @EricWF's comments.

[cjdb]

libcxx/include/string_view

631

Makes sense, reverting. Also applied to <=> below.

641

Done. Why don't we want concepts here? (Note: this is just so I understand for next time).

[cjdb]

Rebases on D81823.

[cjdb]

I think all the comments requesting changes have been addressed now. @miscco @EricWF could you please confirm?

libcxx/include/__string

468

Whoops, I misunderstood this to mean "please justify why you're using an #if block" and not "please remove the spaces before #if". Fixed up now.

[cjdb]

Ping.

[curdeius]

libcxx/include/__string

362

Nit: please be consistent. Here you use #ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR and in other places you use #if !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) (e.g. line 469).

libcxx/include/string_view

639

Nit: why using _LIBCPP_CONSTEXPR_AFTER_CXX11 and not just constexpr?

653

As above, why _LIBCPP_CONSTEXPR_AFTER_CXX11 and not constexpr?

654–655

Should it be in the synopsis? Or rather, I don't think it should (according to http://eel.is/c++draft/string.view.synop), but why is this overload needed? Isn't operator<=>(basic_string_view, basic_string_view) enough?

Oh, I got my answer, http://eel.is/c++draft/string.view#comparison.

libcxx/test/std/strings/string.view/string.view.comparison/opcmp.string_view.pointer.pass.cpp

66–68

Isn't it possible to factor out a test-all function from main, mark it constexpr and call it from both run- and compile-time context?

E.g.

template <...>
TEST_CONSTEXPR bool test(...) // as above but with constexpr and return bool.

TEST_CONSTEXPR bool test_all() // the first part of current main and return bool

main() {
  test_all();
  static_assert(test_all(), "");
}

[curdeius]

libcxx/include/string_view

42

Return type is not bool.

[curdeius]

libcxx/include/string_view

655

Just noexcept?

[cjdb]

rebases to HEAD

[• Quuxplusone]

libcxx/include/__string

842–844

AFAICT, _LIBCPP_HAS_NO_SPACESHIP_OPERATOR controls whether libc++ is able to use the <=> token. It has nothing to do with whether we define the strong_ordering enumeration or anything like that. So this member typedef should be conditioned on #if _LIBCPP_STD_VER > 17 only. Ditto throughout: anywhere you've got something C++20-related under _LIBCPP_HAS_NO_SPACESHIP_OPERATOR, you shouldn't — unless it depends on the compiler being able to parse the <=> token, in which case you should.

libcxx/include/string_view

654

Remove const on lines 703 and 704. (Pass-by-const-value is usually a typo for pass-by-const-reference; in this case we want pass-by-value alone.)
Remove common_type_t on line 704. Or is it doing something? We do have __identity_t<X> now, if you need that... but cppreference seems pretty sure that operator<=>(basic_string_view, basic_string_view) is the correct signature.

I would make this a hidden friend, unless there's a demonstrable reason not to. Saves typing and saves overload-resolution time.

libcxx/test/std/strings/string.view/string.view.comparison/opcmp.string_view.pointer.pass.cpp

27–30

Instead of passing y by hand, just make it a local variable auto y = (0 <=> x);

52

Add at least one simple test for basic_string_view<wchar_t>, basic_string_view<char8_t>, etc.
Add at least one simple test for basic_string_view<char, CT> where CT has no comparison_category member.
Add at least one simple test for basic_string_view<char, CT> where CT has a non-type member named comparison_category.
Double-check our coverage for situations like

struct T { operator std::string_view() const; };
std::string_view sv;
ASSERT_SAME_TYPE(decltype(sv <=> T()), std::strong_ordering);
ASSERT_SAME_TYPE(decltype(T() <=> sv), std::strong_ordering);
ASSERT_SAME_TYPE(decltype(sv == T()), bool);
ASSERT_SAME_TYPE(decltype(T() == sv), bool);
ASSERT_SAME_TYPE(decltype(sv != T()), bool);
ASSERT_SAME_TYPE(decltype(T() != sv), bool);

66–68

Please match @curdeius's style here: first test_all(); (no assert), then static_assert(test_all()); afterward. This is how it's done in all libc++ tests so far.
Also, obviously, remove [[nodiscard]] from your test function.

[cjdb]

• adds tests for wstring_view, u8string_view, u16string_view, u32string_view
• adds tests for char_traits without comparison_category member alias
• adds TEST_SAME_AS checks for <=> return types
• adds dependency on D101708

[cjdb]

libcxx/include/__string

842–844

Is there a reason strong_ordering should be available when operator<=> isn't? The two are very tightly coupled.

Also, I believe @EricWF suggested I use it: https://reviews.llvm.org/D80891?id=267623#inline-749046.

libcxx/include/string_view

654

(Pass-by-const-value is usually a typo for pass-by-const-reference; in this case we want pass-by-value alone.)

If it were a proper declaration, I'd agree. It's a definition, and const-qualifying the parameter is desirable for read-only objects.

... but cppreference seems pretty sure that operator<=>(basic_string_view, basic_string_view) is the correct signature.

I would make this a hidden friend, unless there's a demonstrable reason not to. Saves typing and saves overload-resolution time.

cpprefernece is not the standard. Please do the required readings before submitting your review.

[• Quuxplusone]

libcxx/include/__string

842–844

Right now, _LIBCPP_HAS_NO_SPACESHIP_OPERATOR is defined if-and-only-if the compiler defines __cpp_impl_three_way_comparison. It is not (yet) directly related to whether libc++ itself is planning to define __cpp_lib_three_way_comparison — but that might just be because libc++ itself hasn't done anything with __cpp_lib_three_way_comparison yet. This D80891 is one of the first steps toward implementing __cpp_lib_three_way_comparison.

So, okay, if we want to say that libc++ will implement __cpp_lib_three_way_comparison only on compilers that implement __cpp_impl_three_way_comparison (which does seem reasonable), then it makes sense to guard everything <=>-related under __cpp_impl_three_way_comparison (which is to say, under _LIBCPP_HAS_NO_SPACESHIP_OPERATOR).

This logic applies even to
https://en.cppreference.com/w/cpp/utility/compare/compare_strong_order_fallback
By this logic, libc++ should provide std::compare_strong_order_fallback(x, y) for types lacking an operator<=> function, but should not provide std::compare_strong_order_fallback(x, y) on compilers lacking support for the <=> token.

In that case, please just update this line to

#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)

(and ditto throughout).

libcxx/include/string_view

654

I see you're working on hidden-friend-ifying some other operators in D101707, so I hope you get around to these ones soon. As you say over there, hidden friends have well-documented advantages for overload resolution.

The standard actually provides a reference implementation for this operator<=>! So I guess I'd recommend copying it: http://eel.is/c++draft/string.view.comparison#example-1
The reference implementation uses type_identity_t<X> as I suggested; indeed common_type_t is not supposed to be involved here.

[cjdb]

libcxx/include/__string

842–844

FWIW I think a lot of the #if _LIBCPP_STD_VER > 17 && ... will become just #if _LIBCPP_STD_VER > 17 in a little over a year, given our new support model.

Right now, _LIBCPP_HAS_NO_SPACESHIP_OPERATOR is defined if-and-only-if the compiler defines __cpp_impl_three_way_comparison. It is not (yet) directly related to whether libc++ itself is planning to define __cpp_lib_three_way_comparison — but that might just be because libc++ itself hasn't done anything with __cpp_lib_three_way_comparison yet. This D80891 is one of the first steps toward implementing __cpp_lib_three_way_comparison.

So, okay, if we want to say that libc++ will implement __cpp_lib_three_way_comparison only on compilers that implement __cpp_impl_three_way_comparison (which does seem reasonable), then it makes sense to guard everything <=>-related under __cpp_impl_three_way_comparison (which is to say, under _LIBCPP_HAS_NO_SPACESHIP_OPERATOR).

This logic applies even to
https://en.cppreference.com/w/cpp/utility/compare/compare_strong_order_fallback
By this logic, libc++ should provide std::compare_strong_order_fallback(x, y) for types lacking an operator<=> function, but should not provide std::compare_strong_order_fallback(x, y) on compilers lacking support for the <=> token.

Looks like we're on the same page here.

(Off-topic: this context is one where I'm perfectly fine with cppreference being used for convenience, because we're not discussing technical details of proposed code.)

In that case, please just update this line to

#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)

(and ditto throughout).

That line's the same as what's present (confirmed by browser find); is there a typo?

libcxx/include/string_view

654

I see you're working on hidden-friend-ifying some other operators in D101707, so I hope you get around to these ones soon. As you say over there, hidden friends have well-documented advantages for overload resolution.

I really wish we could do this, but string.view.synop says they're free functions :(
I'll probably put forward some of the other mothership contributions once ranges work becomes embarrassingly parallel, so feel free to call these out if the synopses are more friendly elsewhere.

The standard actually provides a reference implementation for this operator<=>! So I guess I'd recommend copying it: http://eel.is/c++draft/string.view.comparison#example-1
The reference implementation uses type_identity_t<X> as I suggested; indeed common_type_t is not supposed to be involved here.

Thanks, I missed that. On further inspection, it looks like C++17 doesn't use common_type_t either (it uses an alias for decay_t called __identity), so you're right on all counts, not just operator<=>! I'm happy to replace all common_type_ts with an __identity that's switched on C++17/C++20. WDYT?

Having said that, it baffles me that f(T, type_identity_t<T>) isn't another spelling of f(T, T).

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[cjdb]

rebases to fix CI (and revert local experiment that made its way on to Phab)

[mumbleskates]

libcxx/include/string_view

28

As I understand it, the functions for the operators {<,<=,>=,>,!=} are no longer supposed to be defined in C++20, and should always be synthesized from <=> and == by the compiler. That is, if we are defining operator<=> we should be doing it instead of the five non-== operators. Is there another reason these symbols still need to be defined?

[cjdb]

libcxx/include/string_view

28

We still need to support pre-C++20 modes, which don't have a spaceship operator. Everything is conditionally guarded to make sure the right mode exposes the correct operators.

This is just a huge comment that exposes what we've implemented: see below for the actual implementation.

[mumbleskates]

Feeling like getting something done this weekend

[Mordante]

In D80891#3704577, @mumbleskates wrote:

Feeling like getting something done this weekend

Welcome back @mumbleskates. Unfortunately this review is no longer needed. I implemented this in D130295 which landed earlier this week. I've also been working on std::string. The status page is up-to date https://libcxx.llvm.org/Status/Spaceship.html. Did I miss the reviews for the items on your name; nullopt and monostate?

libcxx/include/__string

 template <> struct char_traits<char8_t>;  // c++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <algorithm>  // for search and min
+#include <compare>    // for spaceship support
 #include <cstdio>     // For EOF.
 #include <memory>     // for __murmur2_or_cityhash
 
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

 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;
 
+    // comparison_category is only available in C++20 on.
+    #ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+    using comparison_category = strong_ordering;
+    #endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+
     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;}
 
     static _LIBCPP_CONSTEXPR_AFTER_CXX14

 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;
 
+    // comparison_category is only available in C++20 on.
+    #if !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+    using comparison_category = strong_ordering;
+    #endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+
     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;}
 
     static _LIBCPP_CONSTEXPR_AFTER_CXX14

 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;
 
+    // comparison_category is only available in C++20 on.
+    #if !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+    using comparison_category = strong_ordering;
+    #endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+
     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;}
 
     static constexpr

 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;
 
+    // comparison_category is only available in C++20 on.
+    #if !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+    using comparison_category = strong_ordering;
+    #endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+
     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;}
 
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14

 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;
 
+    // comparison_category is only available in C++20 on.
+    #if !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+    using comparison_category = strong_ordering;
+    #endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+
     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;}
 
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14

libcxx/include/compare

public:
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (_CmpUnspecifiedParam, partial_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (_CmpUnspecifiedParam, partial_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
 
+  _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(partial_ordering, partial_ordering) noexcept = default;
+
 #ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
   _LIBCPP_INLINE_VISIBILITY friend constexpr partial_ordering operator<=>(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr partial_ordering operator<=>(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
 #endif
 
 private:
   _ValueT __value_;
 };
public:
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (_CmpUnspecifiedParam, weak_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (_CmpUnspecifiedParam, weak_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
 
+  _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(weak_ordering, weak_ordering) noexcept = default;
+
 #ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
   _LIBCPP_INLINE_VISIBILITY friend constexpr weak_ordering operator<=>(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
 #endif
 
 private:
   _ValueT __value_;
 };
public:
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (_CmpUnspecifiedParam, strong_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (_CmpUnspecifiedParam, strong_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
 
+  _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(strong_ordering, strong_ordering) noexcept = default;
+
 #ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
   _LIBCPP_INLINE_VISIBILITY friend constexpr strong_ordering operator<=>(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr strong_ordering operator<=>(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
 #endif
 
 private:
   _ValueT __value_;
 };

libcxx/include/string_view

template<class charT, class traits = char_traits<charT>>
         class basic_string_view;
 
     // 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>
     constexpr bool operator!=(basic_string_view<charT, traits> x,
-                              basic_string_view<charT, traits> y) noexcept;
+                              basic_string_view<charT, traits> y) noexcept; // C++17
     template<class charT, class traits>
     constexpr bool operator< (basic_string_view<charT, traits> x,
-                                 basic_string_view<charT, traits> y) noexcept;
+                              basic_string_view<charT, traits> y) noexcept; // C++17
     template<class charT, class traits>
-    constexpr bool operator> (basic_string_view<charT, traits> x,
-                              basic_string_view<charT, traits> y) noexcept;
+    constexpr bool operato> (basic_string_view<charT, traits> x,
+                              basic_string_view<charT, traits> y) noexcept; // C++17
     template<class charT, class traits>
     constexpr bool operator<=(basic_string_view<charT, traits> x,
-                                 basic_string_view<charT, traits> y) noexcept;
+                              basic_string_view<charT, traits> y) noexcept; // C++17
     template<class charT, class traits>
     constexpr bool operator>=(basic_string_view<charT, traits> x,
-                              basic_string_view<charT, traits> y) noexcept;
+                              basic_string_view<charT, traits> y) noexcept; // C++17
+    template<class charT, class traits>
+    constexpr bool operator<=>(basic_string_view<charT, traits> x,
+                               basic_string_view<charT, traits> y) noexcept; // C++20
     // 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);
 

 
 private:
     const   value_type* __data;
     size_type           __size;
 };
 
 
 // [string.view.comparison]
+
 // 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 false;
     return __lhs.compare(__rhs) == 0;
 }
 
 template<class _CharT, class _Traits>
 _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 !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+template <class _Tp>
+using __test_for_comparison_category = typename _Tp::comparison_category;
+
+template<class _CharT, class _Traits>
+_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+auto operator<=>(basic_string_view<_CharT, _Traits> __lhs,
+                 basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
+{
+    const auto result = __lhs.compare(__rhs) <=> 0;
+    if constexpr (_IsValidExpansion<__test_for_comparison_category, _Traits>::value) {
+        return static_cast<typename _Traits::comparison_category>(result);
+    }
+    else {
+        return static_cast<weak_ordering>(result);
+    }
+}
+
+template<class _CharT, class _Traits>
+_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+auto operator<=>(basic_string_view<_CharT, _Traits> __lhs,
+                 typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
+{
+    const auto result = __lhs.compare(__rhs) <=> 0;
+    if constexpr (_IsValidExpansion<__test_for_comparison_category, _Traits>::value) {
+        return static_cast<typename _Traits::comparison_category>(result);
+    }
+    else {
+        return static_cast<weak_ordering>(result);
+    }
+}
+#else
 template<class _CharT, class _Traits>
 _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;
 }

 
 template<class _CharT, class _Traits>
 _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_HAS_NO_SPACESHIP_OPERATOR
 
 
 template<class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
            basic_string_view<_CharT, _Traits> __str);
 
 typedef basic_string_view<char>     string_view;
 #ifndef _LIBCPP_NO_HAS_CHAR8_T
 typedef basic_string_view<char8_t>  u8string_view;
 #endif
 typedef basic_string_view<char16_t> u16string_view;
 typedef basic_string_view<char32_t> u32string_view;
 typedef basic_string_view<wchar_t>  wstring_view;
 
 // [string.view.hash]
 template<class _CharT>
 struct _LIBCPP_TEMPLATE_VIS hash<basic_string_view<_CharT, char_traits<_CharT> > >
     : public unary_function<basic_string_view<_CharT, char_traits<_CharT> >, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const basic_string_view<_CharT, char_traits<_CharT> > __val) const _NOEXCEPT {
         return __do_string_hash(__val.data(), __val.data() + __val.size());
     }
 };
 
 
 #if _LIBCPP_STD_VER > 11
 inline namespace literals
 {
   inline namespace string_view_literals
   {

libcxx/test/std/strings/string.view/string.view.comparison/opcmp.string_view.pointer.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<class charT, class traits, class Allocator>
+//   constexpr bool operator<=>(const charT* lhs, basic_string_view<charT,traits> rhs);
+// template<class charT, class traits, class Allocator>
+//   constexpr bool operator<=>(basic_string_view<charT,traits> lhs, const charT* rhs);
+
+#include <string_view>
+#include <compare>
+#include <cassert>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.h"
+
+template <class S>
+void test(const typename S::value_type* lhs, const S& rhs,
+          std::strong_ordering x, std::strong_ordering y) {
+  assert((lhs <=> rhs) == x);
+  assert((rhs <=> lhs) == y);
+}
+
+int main(int, char**) {
+  {
+    using std::strong_ordering;
+    typedef std::string_view S;
+    test("", S(""), strong_ordering::equal, strong_ordering::equal);
+    test("", S("abcde"), strong_ordering::less, strong_ordering::greater);
+    test("", S("abcdefghij"), strong_ordering::less, strong_ordering::greater);
+    test("", S("abcdefghijklmnopqrst"), strong_ordering::less,
+         strong_ordering::greater);
+    test("abcde", S(""), strong_ordering::greater, strong_ordering::less);
+    test("abcde", S("abcde"), strong_ordering::equal, strong_ordering::equal);
+    test("abcde", S("abcdefghij"), strong_ordering::less,
+         strong_ordering::greater);
+    test("abcde", S("abcdefghijklmnopqrst"), strong_ordering::less,
+         strong_ordering::greater);
+    test("abcdefghij", S(""), strong_ordering::greater, strong_ordering::less);
+    test("abcdefghij", S("abcde"), strong_ordering::greater,
+         strong_ordering::less);
+    test("abcdefghij", S("abcdefghij"), strong_ordering::equal,
+         strong_ordering::equal);
+    test("abcdefghij", S("abcdefghijklmnopqrst"), strong_ordering::less,
+         strong_ordering::greater);
+    test("abcdefghijklmnopqrst", S(""), strong_ordering::greater,
+         strong_ordering::less);
+    test("abcdefghijklmnopqrst", S("abcde"), strong_ordering::greater,
+         strong_ordering::less);
+    test("abcdefghijklmnopqrst", S("abcdefghij"), strong_ordering::greater,
+         strong_ordering::less);
+    test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"),
+         strong_ordering::equal, strong_ordering::equal);
+  }
+
+  {
+    typedef std::basic_string_view<char, constexpr_char_traits<char> > SV;
+    constexpr SV sv1;
+    constexpr SV sv2{"abcde", 5};
+
+    static_assert((sv1 <=> "") == std::weak_ordering::equivalent);
+    static_assert(("" <=> sv1) == std::weak_ordering::equivalent);
+    static_assert((sv1 <=> "abcde") == std::weak_ordering::less);
+    static_assert(("abcde" <=> sv1) == std::weak_ordering::greater);
+
+    static_assert((sv2 <=> "") == std::weak_ordering::greater);
+    static_assert(("" <=> sv2) == std::weak_ordering::less);
+    static_assert((sv2 <=> "abcde") == std::weak_ordering::equivalent);
+    static_assert(("abcde" <=> sv2) == std::weak_ordering::equivalent);
+    static_assert((sv2 <=> "abcde0") == std::weak_ordering::less);
+    static_assert(("abcde0" <=> sv2) == std::weak_ordering::greater);
+  }
+
+  return 0;
+}

libcxx/test/std/strings/string.view/string.view.comparison/opcmp.string_view.string_view.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template<class charT, class traits, class Allocator>
+//   constexpr bool operator<=>(const charT* lhs, basic_string_view<charT,traits> rhs);
+// template<class charT, class traits, class Allocator>
+//   constexpr bool operator<=>(basic_string_view<charT,traits> lhs, const charT* rhs);
+
+#include <string_view>
+#include <compare>
+#include <cassert>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.h"
+
+template <class S>
+void test(const S lhs, const S& rhs, std::strong_ordering x,
+          std::strong_ordering y) {
+  assert((lhs <=> rhs) == x);
+  assert((rhs <=> lhs) == y);
+}
+
+int main(int, char**) {
+  {
+    typedef std::string_view S;
+    test(S(""), S(""), std::strong_ordering::equal,
+         std::strong_ordering::equal);
+    test(S(""), S("abcde"), std::strong_ordering::less,
+         std::strong_ordering::greater);
+    test(S(""), S("abcdefghij"), std::strong_ordering::less,
+         std::strong_ordering::greater);
+    test(S(""), S("abcdefghijklmnopqrst"), std::strong_ordering::less,
+         std::strong_ordering::greater);
+    test(S("abcde"), S(""), std::strong_ordering::greater,
+         std::strong_ordering::less);
+    test(S("abcde"), S("abcde"), std::strong_ordering::equal,
+         std::strong_ordering::equal);
+    test(S("abcde"), S("abcdefghij"), std::strong_ordering::less,
+         std::strong_ordering::greater);
+    test(S("abcde"), S("abcdefghijklmnopqrst"), std::strong_ordering::less,
+         std::strong_ordering::greater);
+    test(S("abcdefghij"), S(""), std::strong_ordering::greater,
+         std::strong_ordering::less);
+    test(S("abcdefghij"), S("abcde"), std::strong_ordering::greater,
+         std::strong_ordering::less);
+    test(S("abcdefghij"), S("abcdefghij"), std::strong_ordering::equal,
+         std::strong_ordering::equal);
+    test(S("abcdefghij"), S("abcdefghijklmnopqrst"), std::strong_ordering::less,
+         std::strong_ordering::greater);
+    test(S("abcdefghijklmnopqrst"), S(""), std::strong_ordering::greater,
+         std::strong_ordering::less);
+    test(S("abcdefghijklmnopqrst"), S("abcde"), std::strong_ordering::greater,
+         std::strong_ordering::less);
+    test(S("abcdefghijklmnopqrst"), S("abcdefghij"),
+         std::strong_ordering::greater, std::strong_ordering::less);
+    test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"),
+         std::strong_ordering::equal, std::strong_ordering::equal);
+  }
+
+  {
+    typedef std::basic_string_view<char, constexpr_char_traits<char> > SV;
+    constexpr SV sv1;
+    constexpr SV sv2{"abcde", 5};
+
+    static_assert((sv1 <=> sv2) == std::weak_ordering::less);
+    static_assert((sv2 <=> sv1) == std::weak_ordering::greater);
+
+    static_assert((sv1 <=> sv1) == std::weak_ordering::equivalent);
+    static_assert((sv2 <=> sv2) == std::weak_ordering::equivalent);
+  }
+
+  return 0;
+}