[libcxx] adds spaceship for vector

[cjdb]

Summary

[libcxx] adds spaceship for vector

• adds C++20 operator== for vector
• adds operator<=> for vector

Note: This is currently WIP due to being unable to find tests for vector's comparison operations.

[miscco]

libcxx/include/compare

679

This is usually spelled as ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR

686

I have to look it up but what about string orderings here?

libcxx/include/vector

3339

Same here #ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR

[cjdb]

libcxx/include/compare

686

See http://eel.is/c++draft/expos.only.func#2.

[miscco]

libcxx/include/compare

686

Thanks a lot, I thought I read it in some blog, but that is way better

libcxx/include/compare

 // [cmp.alg], comparison algorithms
 // TODO: unimplemented
 template<class _Tp> constexpr strong_ordering strong_order(const _Tp& __lhs, const _Tp& __rhs);
 template<class _Tp> constexpr weak_ordering weak_order(const _Tp& __lhs, const _Tp& __rhs);
 template<class _Tp> constexpr partial_ordering partial_order(const _Tp& __lhs, const _Tp& __rhs);
 template<class _Tp> constexpr strong_equality strong_equal(const _Tp& __lhs, const _Tp& __rhs);
 template<class _Tp> constexpr weak_equality weak_equal(const _Tp& __lhs, const _Tp& __rhs);
 
+#if !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+inline constexpr auto __synth_three_way = []<class T, class U>(const T& t, const U& u)
+{
+    // TODO(cjdb): add requirements once boolean-testable is committed
+    if constexpr (requires { t <=> u; }) {
+      return t <=> u;
+    } else {
+        if (t < u) return weak_ordering::less;
+        if (u < t) return weak_ordering::greater;
+        return weak_ordering::equivalent;
+    }
+};
+
+template<class T, class U=T>
+using __synth_three_way_result = decltype(__synth_three_way(declval<T&>(), declval<U&>()));
+#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_COMPARE

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>;
 
 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);
+template <class T, class Allocator> bool operator<=>(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
 
 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

 inline _LIBCPP_INLINE_VISIBILITY
 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() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
 }
 
+#if !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+template <class _Tp, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
+__synth_three_way_result<_Tp>
+operator<=>(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
+{
+    return _VSTD::lexicographical_compare_three_way(__x.begin(), __x.end(), __y.begin(), __y.end(), __synth_three_way);
+}
+#else
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     return !(__x == __y);
 }
 

 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     return !(__y < __x);
 }
+#endif // _
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);