[libc++][spaceship] Implement `operator<=>` for `vector`

[H-G-Hristov]

Summary

Implements part of P1614R2 "The Mothership has Landed"

Depends on D150188

[avogelsgesang]

update review link

[avogelsgesang]

rebase

[avogelsgesang]

improve test cases

[avogelsgesang]

needs to be adjusted to use the still-to-be-introduced test utilities from https://reviews.llvm.org/D132312 is done

[avogelsgesang]

add missing _LIBCPP_HIDE_FROM_ABI; use new test utility

[avogelsgesang]

Incorporate feedback received for similar review (list instead of vector; https://reviews.llvm.org/D132312)

[Mordante]

I had a quick look and no real comments. Can you fix the CI? I prefer to review the changes after a CI run.

[avogelsgesang]

Remove trailing whitespace (hopefully fixes CI)

[avogelsgesang]

Guard against ADL

[avogelsgesang]

still need to fix CI

[avogelsgesang]

@H-G-Hristov unfortunately, I don't know when I will find time to come back to this (and https://reviews.llvm.org/D132265). Feel free to take this over, if you are blocked by it

[H-G-Hristov]

In D132268#4275440, @avogelsgesang wrote:

@H-G-Hristov unfortunately, I don't know when I will find time to come back to this (and https://reviews.llvm.org/D132265). Feel free to take this over, if you are blocked by it

Thank you. I'll probably take them over then if you haven't finished them before I get the time.

[H-G-Hristov]

• [libc++][spaceship] Implement operator<=> for vector
• Fixes, incl. a change to lexicographical_compare_three_way to fix std::vector<bool> comparision operators support

[avogelsgesang]

libcxx/include/__algorithm/lexicographical_compare_three_way.h

106 ↗

(On Diff #516185)

I fear the actual issue is that `__three_way_comp_ref_type is currently buggy, and this change here only masks the issue.

I think the changes

   template <class _Tp, class _Up>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __x, _Up& __y) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(const _Tp& __x, const _Up& __y) {

and

 // Pass the comparator by lvalue reference. Or in debug mode, using a
 // debugging wrapper that stores a reference.
-#  ifndef _LIBCPP_ENABLE_DEBUG_MODE
+#  ifdef _LIBCPP_ENABLE_DEBUG_MODE

are required. Not sure if sufficient, though

[H-G-Hristov]

Addressed review comments

[H-G-Hristov]

Trigger CI

[H-G-Hristov]

Rebased

[H-G-Hristov]

libcxx/include/__algorithm/lexicographical_compare_three_way.h

106 ↗

(On Diff #516185)

I think it's good now. Thank you for the review/tip. I don't understand what's going on with the CI at the moment but build the local build of the latest revision is fine.

[Mordante]

libcxx/docs/Status/SpaceshipProjects.csv

38

Did you validate this output looks good?

libcxx/test/std/containers/sequences/vector.bool/compare.three_way.pass.cpp

55 ↗

(On Diff #518145)

lx and tx are identical.

[H-G-Hristov]

• Rebased and addressed comments

[H-G-Hristov]

@Mordante Thank you for the review.

libcxx/docs/Status/SpaceshipProjects.csv

38

I use a VSCode extension to preview the tables. It looks good. Text is ordered on two separate lines. I can remove myself. I don't care about credit. I was curious how it can be done.
Is there another easy/more correct way to validate?

[H-G-Hristov]

• Addressed review comment

[philnik]

Looks basically good, but I'd like to understand the __debug_three_way_comp change before approving.

libcxx/include/__algorithm/three_way_comp_ref_type.h

31 ↗

(On Diff #519221)

Why is this change needed?

libcxx/test/std/containers/sequences/vector.bool/compare.three_way.pass.cpp

59 ↗

(On Diff #519221)

Maybe also test one empty and one with {false}?

[H-G-Hristov]

• Addressed comments

[H-G-Hristov]

@philnik Thank you for the review!

In D132268#4320495, @philnik wrote:

Looks basically good, but I'd like to understand the __debug_three_way_comp change before approving.

This change was proposed by avogelsang above actually, as without it the tests of vector<bool> build fails with:

lexicographical_compare_three_way.h:103:12: error: no matching function for call to '__lexicographical_compare_three_way_fast_path'

return std::__lexicographical_compare_three_way_fast_path(
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

vector:3296:17: note: in instantiation of function template specialization 'std::lexicographical_compare_three_way<std::bit_iterator<std::vector<bool>, true, 0>, std::bit_iterator<std::vector<bool>, true, 0>, std::strong_ordering (*)(const bool &, const bool &)>' requested here

return std::lexicographical_compare_three_way(

libcxx/include/__algorithm/three_way_comp_ref_type.h

31 ↗

(On Diff #519221)

Without it the build fails.

[philnik]

In D132268#4321925, @H-G-Hristov wrote:

@philnik Thank you for the review!

In D132268#4320495, @philnik wrote:

Looks basically good, but I'd like to understand the __debug_three_way_comp change before approving.

This change was proposed by avogelsang above actually, as without it the tests of vector<bool> build fails with:

lexicographical_compare_three_way.h:103:12: error: no matching function for call to '__lexicographical_compare_three_way_fast_path'

return std::__lexicographical_compare_three_way_fast_path(
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

vector:3296:17: note: in instantiation of function template specialization 'std::lexicographical_compare_three_way<std::bit_iterator<std::vector<bool>, true, 0>, std::bit_iterator<std::vector<bool>, true, 0>, std::strong_ordering (*)(const bool &, const bool &)>' requested here

return std::lexicographical_compare_three_way(

Ah OK. It's for iterators not returning an lvalue reference. In this case I think it would be better to forward the arguments, since that will definitely be correct.

[H-G-Hristov]

In D132268#4322098, @philnik wrote:

In D132268#4321925, @H-G-Hristov wrote:

@philnik Thank you for the review!

In D132268#4320495, @philnik wrote:

Looks basically good, but I'd like to understand the __debug_three_way_comp change before approving.

This change was proposed by avogelsang above actually, as without it the tests of vector<bool> build fails with:

lexicographical_compare_three_way.h:103:12: error: no matching function for call to '__lexicographical_compare_three_way_fast_path'

return std::__lexicographical_compare_three_way_fast_path(
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

vector:3296:17: note: in instantiation of function template specialization 'std::lexicographical_compare_three_way<std::bit_iterator<std::vector<bool>, true, 0>, std::bit_iterator<std::vector<bool>, true, 0>, std::strong_ordering (*)(const bool &, const bool &)>' requested here

return std::lexicographical_compare_three_way(

Ah OK. It's for iterators not returning an lvalue reference. In this case I think it would be better to forward the arguments, since that will definitely be correct.

Sorry, I think I confused you. The actual problem is in the compare function, the last parameter of: :

note: candidate template ignored: substitution failure [with _InputIterator1 = std::__bit_iterator<std::vector<bool>, true, 0>, _InputIterator2 = std::__bit_iterator<std::vector<bool>, true, 0>, _Cmp = std::__debug_three_way_comp<std::strong_ordering (*)(const bool &, const bool &)>]: no matching function for call to object of type 'std::__debug_three_way_comp<std::strong_ordering (*)(const bool &, const bool &)>'
_LIBCPP_HIDE_FROM_ABI constexpr auto __lexicographical_compare_three_way_fast_path(

[philnik]

In D132268#4321925, @H-G-Hristov wrote:

@philnik Thank you for the review!

In D132268#4320495, @philnik wrote:

Looks basically good, but I'd like to understand the __debug_three_way_comp change before approving.

This change was proposed by avogelsang above actually, as without it the tests of vector<bool> build fails with:

lexicographical_compare_three_way.h:103:12: error: no matching function for call to '__lexicographical_compare_three_way_fast_path'

return std::__lexicographical_compare_three_way_fast_path(
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

vector:3296:17: note: in instantiation of function template specialization 'std::lexicographical_compare_three_way<std::bit_iterator<std::vector<bool>, true, 0>, std::bit_iterator<std::vector<bool>, true, 0>, std::strong_ordering (*)(const bool &, const bool &)>' requested here

return std::lexicographical_compare_three_way(

Ah OK. It's for iterators not returning an lvalue reference. In this case I think it would be better to forward the arguments, since that will definitely be correct.

In D132268#4322470, @H-G-Hristov wrote:

In D132268#4322098, @philnik wrote:

In D132268#4321925, @H-G-Hristov wrote:

@philnik Thank you for the review!

In D132268#4320495, @philnik wrote:

Looks basically good, but I'd like to understand the __debug_three_way_comp change before approving.

This change was proposed by avogelsang above actually, as without it the tests of vector<bool> build fails with:

lexicographical_compare_three_way.h:103:12: error: no matching function for call to '__lexicographical_compare_three_way_fast_path'

return std::__lexicographical_compare_three_way_fast_path(
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

vector:3296:17: note: in instantiation of function template specialization 'std::lexicographical_compare_three_way<std::bit_iterator<std::vector<bool>, true, 0>, std::bit_iterator<std::vector<bool>, true, 0>, std::strong_ordering (*)(const bool &, const bool &)>' requested here

return std::lexicographical_compare_three_way(

Ah OK. It's for iterators not returning an lvalue reference. In this case I think it would be better to forward the arguments, since that will definitely be correct.

Sorry, I think I confused you. The actual problem is in the compare function, the last parameter of: :

note: candidate template ignored: substitution failure [with _InputIterator1 = std::__bit_iterator<std::vector<bool>, true, 0>, _InputIterator2 = std::__bit_iterator<std::vector<bool>, true, 0>, _Cmp = std::__debug_three_way_comp<std::strong_ordering (*)(const bool &, const bool &)>]: no matching function for call to object of type 'std::__debug_three_way_comp<std::strong_ordering (*)(const bool &, const bool &)>'
_LIBCPP_HIDE_FROM_ABI constexpr auto __lexicographical_compare_three_way_fast_path(

In D132268#4322470, @H-G-Hristov wrote:

In D132268#4322098, @philnik wrote:

In D132268#4321925, @H-G-Hristov wrote:

@philnik Thank you for the review!

In D132268#4320495, @philnik wrote:

Looks basically good, but I'd like to understand the __debug_three_way_comp change before approving.

This change was proposed by avogelsang above actually, as without it the tests of vector<bool> build fails with:

lexicographical_compare_three_way.h:103:12: error: no matching function for call to '__lexicographical_compare_three_way_fast_path'

return std::__lexicographical_compare_three_way_fast_path(
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

vector:3296:17: note: in instantiation of function template specialization 'std::lexicographical_compare_three_way<std::bit_iterator<std::vector<bool>, true, 0>, std::bit_iterator<std::vector<bool>, true, 0>, std::strong_ordering (*)(const bool &, const bool &)>' requested here

return std::lexicographical_compare_three_way(

Ah OK. It's for iterators not returning an lvalue reference. In this case I think it would be better to forward the arguments, since that will definitely be correct.

Sorry, I think I confused you. The actual problem is in the compare function, the last parameter of: :

note: candidate template ignored: substitution failure [with _InputIterator1 = std::__bit_iterator<std::vector<bool>, true, 0>, _InputIterator2 = std::__bit_iterator<std::vector<bool>, true, 0>, _Cmp = std::__debug_three_way_comp<std::strong_ordering (*)(const bool &, const bool &)>]: no matching function for call to object of type 'std::__debug_three_way_comp<std::strong_ordering (*)(const bool &, const bool &)>'
_LIBCPP_HIDE_FROM_ABI constexpr auto __lexicographical_compare_three_way_fast_path(

IIUC the problem is that __bit_iterator::operator* returns an object instead of a reference, which can't bind to an lvalue reference. If we use perfect forwarding that should fix the problem?

[H-G-Hristov]

• Use std::forward instead of move.
• Everything &&

[H-G-Hristov]

In D132268#4322525, @philnik wrote:

IIUC the problem is that __bit_iterator::operator* returns an object instead of a reference, which can't bind to an lvalue reference. If we use perfect forwarding that should fix the problem?

Could you please confirm if I understand correctly: I am supposed to perfectly forward the arguments to std::__lexicographical_compare_three_way_fast_path something like that:

return std::__lexicographical_compare_three_way_fast_path(
    std::forward<_InputIterator1>(__first1),
    std::forward<_InputIterator1>(__last1),
    std::forward<_InputIterator2>(__first2),
    std::forward<_InputIterator2>(__last2),
    __wrapped_comp_ref);

No, that still wasn't enough. The compilation fails without changes to LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __x, _Up& __y)'s signature. There was ways an issue with the 5th parameter (for the record I tried forward, move).
In the current revision I changed all references to rvalue references and applied forward to the iterators . I admit that I am not quite sure if that's the correct approach.

[philnik]

In D132268#4324117, @H-G-Hristov wrote:

In D132268#4322525, @philnik wrote:

IIUC the problem is that __bit_iterator::operator* returns an object instead of a reference, which can't bind to an lvalue reference. If we use perfect forwarding that should fix the problem?

Could you please confirm if I understand correctly: I am supposed to perfectly forward the arguments to std::__lexicographical_compare_three_way_fast_path something like that:

return std::__lexicographical_compare_three_way_fast_path(
    std::forward<_InputIterator1>(__first1),
    std::forward<_InputIterator1>(__last1),
    std::forward<_InputIterator2>(__first2),
    std::forward<_InputIterator2>(__last2),
    __wrapped_comp_ref);

No, that still wasn't enough. The compilation fails without changes to LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __x, _Up& __y)'s signature. There was ways an issue with the 5th parameter (for the record I tried forward, move).
In the current revision I changed all references to rvalue references and applied forward to the iterators . I admit that I am not quite sure if that's the correct approach.

I meant that you should perfect-forward the arguments in __debug_three_way_comp::operator(). i.e. std::forward the arguments to __comp_. The std::forwards you are currently doing in the calls are essentially just std::moves, since the arguments are prvalue types.

[Mordante]

A few more comments. I want to have a short look at the final version especially the answers to some of @philnik's remarks.

libcxx/include/__algorithm/lexicographical_compare_three_way.h

37 ↗

(On Diff #520053)

I think it would be better to have the changes to this file and the changes directly related to it in a separate commit.

If you feel strongly about not doing that, then mention these changes in the commit message.

libcxx/test/std/containers/sequences/vector.bool/compare.three_way.pass.cpp

12 ↗

(On Diff #520053)

The synopsis should use the synopsis for the vector<bool> specialization.

libcxx/test/support/test_container_comparisons.h

65 ↗

(On Diff #520053)

All changes in this file are just NFC cleanups right? If so I prefer to remove them from this patch and commit them separately.
(That commit doesn't need a review.)

[H-G-Hristov]

• Addressed comments

[H-G-Hristov]

@Mordante Thank you for the suggestions!

libcxx/include/__algorithm/lexicographical_compare_three_way.h

37 ↗

(On Diff #520053)

I agree. I'll do that.

libcxx/test/std/containers/sequences/vector.bool/compare.three_way.pass.cpp

12 ↗

(On Diff #520053)

To my understanding there isn't a synopsis specific to vector<bool> for operator<=>. I added // class vector<bool>. I hope that's what you mean.

[H-G-Hristov]

• Addressed comments

[H-G-Hristov]

Try to fix CI

[H-G-Hristov]

Rebased

[Mordante]

LGTM when the CI passes.

[H-G-Hristov]

Rebased

[H-G-Hristov]

Rebased

[H-G-Hristov]

In D132268#4361459, @Mordante wrote:

LGTM when the CI passes.

Thank you for the review. This one now passes but it still needs the stacked change to be completed/approved.

libcxx/docs/Status/SpaceshipProjects.csv

 | `[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 <https://reviews.llvm.org/D131357>`_,None,Adrian Vogelsgesang,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| `to_chars_result <https://reviews.llvm.org/D112366>`_,None,Mark de Wever,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| `from_chars_result <https://reviews.llvm.org/D112366>`_,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/D131421>`_,None,Mark de Wever,|Complete|
 | `[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.opt.reqmts>`_),| array,[expos.only.func],Unassigned,|Not Started|
 | `[deque.syn] <https://wg21.link/deque.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| deque,[expos.only.func],Unassigned,|Not Started|
 | `[forward.list.syn] <https://wg21.link/forward.list.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| forward_list,[expos.only.func],Unassigned,|Not Started|
 | `[list.syn] <https://wg21.link/list.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| list,[expos.only.func],Unassigned,|Not Started|
-| `[vector.syn] <https://wg21.link/vector.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| vector,[expos.only.func],Unassigned,|Not Started|
+| `[vector.syn] <https://wg21.link/vector.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| `vector <https://reviews.llvm.org/DXXXXXX>`_,[expos.only.func],Adrian Vogelsgesang,|Complete|
 | `[associative.map.syn] <https://wg21.link/associative.map.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),"| map
 | multimap",[expos.only.func],Unassigned,|Not Started|
 | `[associative.set.syn] <https://wg21.link/associative.set.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),"| multiset
 | set",[expos.only.func],Unassigned,|Not Started|
 | `[queue.ops] <https://wg21.link/queue.ops>`_,| queue,None,Unassigned,|Not Started|
 | `[stack.ops] <https://wg21.link/stack.ops>`_,| stack,None,Unassigned,|Not Started|
 | `[reverse.iter.cmp] <https://wg21.link/reverse.iter.cmp>`_,| `reverse_iterator <https://reviews.llvm.org/D113695>`_,None,Mikhail Maltsev,|Complete|
 | `[move.iter.op.comp] <https://wg21.link/move.iter.op.comp>`_,| move_iterator,None,Unassigned,|Not Started|

libcxx/include/vector

 };
 
 template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
    vector(InputIterator, InputIterator, Allocator = Allocator())
    -> vector<typename iterator_traits<InputIterator>::value_type, Allocator>; // C++17
 
 template <class Allocator> struct hash<std::vector<bool, Allocator>>;
 
-template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
+template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y);   // constexpr since C++20
+template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);   // removed in C++20
+template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y);   // removed in C++20
+template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y);   // removed in C++20
+template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);   // removed in C++20
+template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);   // removed in C++20
+template <class T, class Allocator> constexpr
+    synth-three-way-result<T> operator<=>(const vector<T, Allocator>& x, const vector<T, Allocator>& y);           // since C++20
 
 template <class T, class Allocator>
 void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 
 template <class T, class Allocator, class U>
 typename vector<T, Allocator>::size_type
-erase(vector<T, Allocator>& c, const U& value);       // C++20
+erase(vector<T, Allocator>& c, const U& value);       // since C++20
 template <class T, class Allocator, class Predicate>
 typename vector<T, Allocator>::size_type
-erase_if(vector<T, Allocator>& c, Predicate pred);    // C++20
+erase_if(vector<T, Allocator>& c, Predicate pred);    // since C++20
 
 }  // std
 
 */
 
 #include <__algorithm/copy.h>
 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
+#include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__bit_reference>
 #include <__config>
 #include <__debug>

 inline _LIBCPP_HIDE_FROM_ABI
 bool
 operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     const typename vector<_Tp, _Allocator>::size_type __sz = __x.size();
     return __sz == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin());
 }
 
+#if _LIBCPP_STD_VER <= 17
+
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
 inline _LIBCPP_HIDE_FROM_ABI
 bool
 operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     return !(__x == __y);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
 inline _LIBCPP_HIDE_FROM_ABI
 bool
 operator< (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
 inline _LIBCPP_HIDE_FROM_ABI
 bool
 operator> (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     return __y < __x;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
 inline _LIBCPP_HIDE_FROM_ABI
 bool
 operator>=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     return !(__x < __y);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
 inline _LIBCPP_HIDE_FROM_ABI
 bool
 operator<=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     return !(__y < __x);
 }
 
+#else // _LIBCPP_STD_VER <= 17
+
+template<class _Tp, class _Allocator>
+constexpr __synth_three_way_result<_Tp>
+operator<=>(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
+{
+    return lexicographical_compare_three_way(__x.begin(), __x.end(), __y.begin(), __y.end(), __synth_three_way);
+}
+
+#endif // _LIBCPP_STD_VER <= 17
+
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 inline _LIBCPP_HIDE_FROM_ABI
 void
 swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);

libcxx/test/std/containers/sequences/vector.bool/compare.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // bool operator==( const vector& lhs, const vector& rhs );
 // bool operator!=( const vector& lhs, const vector& rhs );
 // bool operator< ( const vector& lhs, const vector& rhs );
 // bool operator<=( const vector& lhs, const vector& rhs );
 // bool operator> ( const vector& lhs, const vector& rhs );
 // bool operator>=( const vector& lhs, const vector& rhs );
+// template <class T, class Allocator> constexpr
+//     synth-three-way-result<T> operator<=>(const vector<T, Allocator>& x, const vector<T, Allocator>& y)
 
 #include <vector>
 #include <cassert>
 
 #include "test_comparisons.h"
 
 TEST_CONSTEXPR_CXX20 bool test() {
     typedef std::vector<bool> VB;
     {
         const VB v1, v2;
         assert(testComparisons(v1, v2, true, false));
+#if TEST_STD_VER >= 20
+        assert(testOrder(v1, v2, std::strong_ordering::equal));
+#endif
     }
     {
         const VB v1(1, true);
         const VB v2(1, true);
         assert(testComparisons(v1, v2, true, false));
+#if TEST_STD_VER >= 20
+        assert(testOrder(v1, v2, std::strong_ordering::equal));
+#endif
     }
     {
         const VB v1(1, false);
         const VB v2(1, true);
         assert(testComparisons(v1, v2, false, true));
+#if TEST_STD_VER >= 20
+        assert(testOrder(v1, v2, std::strong_ordering::less));
+#endif
     }
     {
-        const VB v1, v2(1, true);
+        const VB v1;
+        const VB v2(1, true);
         assert(testComparisons(v1, v2, false, true));
+#if TEST_STD_VER >= 20
+        assert(testOrder(v1, v2, std::strong_ordering::less));
+#endif
     }
     {
         bool items1[3] = {false, true, false};
         bool items2[3] = {false, true, true};
         const VB v1(items1, items1 + 3);
         const VB v2(items2, items2 + 3);
         assert(testComparisons(v1, v2, false, true));
+#if TEST_STD_VER >= 20
+        assert(testOrder(v1, v2, std::strong_ordering::less));
+#endif
     }
     {
         bool items1[3] = {false, false, false};
         bool items2[3] = {false, true, false};
         const VB v1(items1, items1 + 3);
         const VB v2(items2, items2 + 3);
         assert(testComparisons(v1, v2, false, true));
+#if TEST_STD_VER >= 20
+        assert(testOrder(v1, v2, std::strong_ordering::less));
+#endif
     }
     {
         bool items1[2] = {false, true};
         bool items2[3] = {false, true, false};
         const VB v1(items1, items1 + 2);
         const VB v2(items2, items2 + 3);
         assert(testComparisons(v1, v2, false, true));
+#if TEST_STD_VER >= 20
+        assert(testOrder(v1, v2, std::strong_ordering::less));
+#endif
     }
     {
         bool items[3] = {false, true, false};
         const VB v1(items, items + 3);
         const VB v2(1, true);
         assert(testComparisons(v1, v2, false, true));
+#if TEST_STD_VER >= 20
+        assert(testOrder(v1, v2, std::strong_ordering::less));
+#endif
     }
     {
         assert( (std::vector<bool>() == std::vector<bool>()));
         assert(!(std::vector<bool>() != std::vector<bool>()));
         assert(!(std::vector<bool>() < std::vector<bool>()));
         assert( (std::vector<bool>() <= std::vector<bool>()));
         assert(!(std::vector<bool>() > std::vector<bool>()));
         assert( (std::vector<bool>() >= std::vector<bool>()));
+#if TEST_STD_VER >= 20
+        assert((std::vector<bool>() <=> std::vector<bool>()) == std::strong_ordering::equal);
+#endif
     }
 
     return true;
 }
 
 int main(int, char**) {
     test();
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
     return 0;
 }

libcxx/test/std/containers/sequences/vector/compare.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // bool operator==(const vector& lhs, const vector& rhs);
 // bool operator!=(const vector& lhs, const vector& rhs);
 // bool operator< (const vector& lhs, const vector& rhs);
 // bool operator<=(const vector& lhs, const vector& rhs);
 // bool operator> (const vector& lhs, const vector& rhs);
 // bool operator>=(const vector& lhs, const vector& rhs);
+// template <class T, class Allocator> constexpr
+//     synth-three-way-result<T> operator<=>(const vector<T, Allocator>& x, const vector<T, Allocator>& y)
 
 #include <vector>
 #include <cassert>
 
 #include "test_comparisons.h"
 
-TEST_CONSTEXPR_CXX20 bool test() {
-    {
-        const std::vector<int> c1, c2;
-        assert(testComparisons(c1, c2, true, false));
-    }
-    {
-        const std::vector<int> c1(1, 1), c2(1, 2);
-        assert(testComparisons(c1, c2, false, true));
-    }
-    {
-        const std::vector<int> c1, c2(1, 2);
-        assert(testComparisons(c1, c2, false, true));
-    }
-    {
-        int items1[3] = {1, 2, 1};
-        int items2[3] = {1, 2, 2};
-        const std::vector<int> c1(items1, items1 + 3);
-        const std::vector<int> c2(items2, items2 + 3);
-        assert(testComparisons(c1, c2, false, true));
-    }
-    {
-        int items1[3] = {3, 2, 3};
-        int items2[3] = {3, 1, 3};
-        const std::vector<int> c1(items1, items1 + 3);
-        const std::vector<int> c2(items2, items2 + 3);
-
-        assert(testComparisons(c1, c2, false, false));
-    }
-    {
-        int items1[2] = {1, 2};
-        int items2[3] = {1, 2, 0};
-        const std::vector<int> c1(items1, items1 + 2);
-        const std::vector<int> c2(items2, items2 + 3);
-        assert(testComparisons(c1, c2, false, true));
-    }
-    {
-        int items1[3] = {1, 2, 0};
-        const std::vector<int> c1(items1, items1 + 3);
-        const std::vector<int> c2(1, 3);
-        assert(testComparisons(c1, c2, false, true));
-    }
-    {
-        const std::vector<LessAndEqComp> c1, c2;
-        assert(testComparisons(c1, c2, true, false));
-    }
-    {
-        const std::vector<LessAndEqComp> c1(1, LessAndEqComp(1));
-        const std::vector<LessAndEqComp> c2(1, LessAndEqComp(1));
-        assert(testComparisons(c1, c2, true, false));
-    }
-    {
-        const std::vector<LessAndEqComp> c1(1, LessAndEqComp(1));
-        const std::vector<LessAndEqComp> c2(1, LessAndEqComp(2));
-        assert(testComparisons(c1, c2, false, true));
-    }
-    {
-        const std::vector<LessAndEqComp> c1;
-        const std::vector<LessAndEqComp> c2(1, LessAndEqComp(2));
-        assert(testComparisons(c1, c2, false, true));
-    }
-    {
-        LessAndEqComp items1[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(2)};
-        LessAndEqComp items2[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(1)};
-        const std::vector<LessAndEqComp> c1(items1, items1 + 3);
-        const std::vector<LessAndEqComp> c2(items2, items2 + 3);
-        assert(testComparisons(c1, c2, false, false));
-    }
-    {
-        LessAndEqComp items1[3] = {LessAndEqComp(3), LessAndEqComp(3), LessAndEqComp(3)};
-        LessAndEqComp items2[3] = {LessAndEqComp(3), LessAndEqComp(2), LessAndEqComp(3)};
-        const std::vector<LessAndEqComp> c1(items1, items1 + 3);
-        const std::vector<LessAndEqComp> c2(items2, items2 + 3);
-        assert(testComparisons(c1, c2, false, false));
-    }
-    {
-        LessAndEqComp items1[2] = {LessAndEqComp(1), LessAndEqComp(2)};
-        LessAndEqComp items2[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(0)};
-        const std::vector<LessAndEqComp> c1(items1, items1 + 2);
-        const std::vector<LessAndEqComp> c2(items2, items2 + 3);
-        assert(testComparisons(c1, c2, false, true));
-    }
-    {
-        LessAndEqComp items1[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(0)};
-        const std::vector<LessAndEqComp> c1(items1, items1 + 3);
-        const std::vector<LessAndEqComp> c2(1, LessAndEqComp(3));
-        assert(testComparisons(c1, c2, false, true));
-    }
-    {
-        assert((std::vector<int>() == std::vector<int>()));
-        assert(!(std::vector<int>() != std::vector<int>()));
-        assert(!(std::vector<int>() < std::vector<int>()));
-        assert((std::vector<int>() <= std::vector<int>()));
-        assert(!(std::vector<int>() > std::vector<int>()));
-        assert((std::vector<int>() >= std::vector<int>()));
-    }
+template <typename ElemT, typename Order>
+TEST_CONSTEXPR_CXX20 void test_with_type() {
+  AssertComparisonsReturnBool<std::vector<ElemT> >();
+#if TEST_STD_VER >= 20
+  AssertOrderReturn<Order, std::vector<ElemT>>();
+#endif
+    const std::vector<ElemT> c1, c2;
+#if TEST_STD_VER >= 20
+    assert(testOrder(c1, c2, std::strong_ordering::equal));
+#endif
+    const std::vector<ElemT> c1(1, 1), c2(1, 2);
+#if TEST_STD_VER >= 20
+    assert(testOrder(c1, c2, std::strong_ordering::less));
+#endif
+    const std::vector<ElemT> c1;
+    const std::vector<ElemT> c2(1, 2);
+#if TEST_STD_VER >= 20
+    assert(testOrder(c1, c2, std::strong_ordering::less));
+#endif
+    const std::vector<ElemT> c1(items1, items1 + 3);
+    const std::vector<ElemT> c2(items2, items2 + 3);
+#if TEST_STD_VER >= 20
+    assert(testOrder(c1, c2, std::strong_ordering::less));
+#endif
+    const std::vector<ElemT> c1(items1, items1 + 3);
+    const std::vector<ElemT> c2(items2, items2 + 3);
+#if TEST_STD_VER >= 20
+    assert(testOrder(c1, c2, std::strong_ordering::greater));
+#endif
+    const std::vector<ElemT> c1(items1, items1 + 2);
+    const std::vector<ElemT> c2(items2, items2 + 3);
+#if TEST_STD_VER >= 20
+    assert(testOrder(c1, c2, std::strong_ordering::less));
+#endif
+    const std::vector<ElemT> c1(items1, items1 + 3);
+    const std::vector<ElemT> c2(1, 3);
+#if TEST_STD_VER >= 20
+    assert(testOrder(c1, c2, std::strong_ordering::less));
+#endif
+
+TEST_CONSTEXPR_CXX20 bool test() {
+#if TEST_STD_VER >= 20
+  using strong_ordering_since_cxx20 = std::strong_ordering;
+  using weak_ordering_since_cxx20   = std::weak_ordering;
+#else
+  typedef void strong_ordering_since_cxx20;
+  typedef void weak_ordering_since_cxx20;
+#endif
+  test_with_type<int, strong_ordering_since_cxx20>();
+  test_with_type<LessAndEqComp, weak_ordering_since_cxx20>();
+#if TEST_STD_VER >= 20
+  test_with_type<WeakComp, std::weak_ordering>();
+  test_with_type<PartialComp, std::partial_ordering>();
+#endif
 
-    return true;
 }
 
 int main(int, char**) {
     test();
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
     return 0;
 }