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

[H-G-Hristov]

Summary

Implements part of P1614R2 "The Mothership has Landed"

[avogelsgesang]

update review link

[avogelsgesang]

add AssertComparisonsReturnBool/AssertOrderReturn to test cases

[avogelsgesang]

Add whitespace in templates

[Mordante]

I have some issues regarding the difference of the paper and the Standard, can you look for an LWG-issue. I couldn't find one quickly. I glossed over the rest of the patch but didn't do a real review since it's uncertain what should be implemented.

libcxx/include/array

91

Did you look for any LWG issues in this header?

P1614 states

[ Editor's note: array’s comparisons move to be hidden friends to allow for use as non-type template parameters. All the other containers drop != and, if they have relational operators, those get replaced with a <=>. ]

Change 22.3.2 [array.syn]:
The operator== has been removed from the header and operator<=> isn't added/

Change 22.3.7.1 [array.overview]:

+   friend constexpr bool operator==(const array&, const array&) = default;
+   friend constexpr synth-three-way-result<value_type>
+     operator<=>(const array&, const array&);

But this doesn't match the WP. No friends and no defaulted operator==.

438

442

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

76

nice!

[avogelsgesang]

libcxx/include/array

91

https://cplusplus.github.io/LWG/issue3347 removed the friends again and reintroduced the free-standing comparisons again

[avogelsgesang]

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

[H-G-Hristov]

• [libc++][spaceship] Implement operator<=> for array

[H-G-Hristov]

• Try to fix GCC -Werror=maybe-uninitialized

[H-G-Hristov]

• Rebased to rerun CI

[H-G-Hristov]

Rebased

[Mordante]

The CI failure is not related to your changes.

Is this patch ready for review or do you have more changes planned?

libcxx/include/array

438

This change is not applied.

[H-G-Hristov]

• Addressed review comments

[H-G-Hristov]

In D132265#4310036, @Mordante wrote:

The CI failure is not related to your changes.

Is this patch ready for review or do you have more changes planned?

Yes, this patch and also the patches for vector and optionalare ready for a review.

[philnik]

libcxx/docs/Status/Cxx20.rst

65 ↗

(On Diff #519227)

Would you be interested in implementing the rest of this issue? It doesn't look too complicated.

libcxx/include/array

410–413

Let's try to not reintroduce wrong formatting.

libcxx/test/std/containers/sequences/array/compare.fail.cpp

0

0

Could you make this a .verify.cpp while you're at it?

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

1

Thanks for improving this test!

libcxx/test/std/containers/sequences/array/compare.three_way.compile.fail.cpp

1 ↗

(On Diff #519227)

Please use .verify.cpp instead.

libcxx/test/std/containers/sequences/array/compare.three_way.pass.cpp

63

72

75–77

Let's move the SFINAE test to the top of the file.

[H-G-Hristov]

• Addressed review comments

[H-G-Hristov]

@philnik Thank you for the review!

NOTE: Changes to compare.pass.cpp were too large so git failed to match it to compare.verify.cpp.

libcxx/docs/Status/Cxx20.rst

65 ↗

(On Diff #519227)

Yes, let me do it in a follow up patch.

libcxx/include/array

410–413

I replaced _LIBCPP_INLINE_VISIBILITY and applied format to the whole section.

libcxx/test/std/containers/sequences/array/compare.three_way.pass.cpp

75–77

Moved it. My original motivation was to keep the same stricture of the test as tests in:
libcxx/test/support/test_container_comparisons.h
where they use templates.

[H-G-Hristov]

• Marked LWG3347 as complete

It was even marked as Nothing to Do: https://libcxx.llvm.org/Status/Spaceship.html

[H-G-Hristov]

libcxx/docs/Status/Cxx20.rst

65 ↗

(On Diff #519227)

Let me correct myself, the std::pair's part is already implemented. Marked the issue as completed.

[Mordante]

All my comments have been addressed. I leave the final approval to @philnik.

libcxx/docs/Status/Cxx20Issues.csv

 "`3330 <https://wg21.link/LWG3330>`__","Include ``<compare>``\  from most library headers","Prague","|Complete|","13.0","|spaceship|"
 "`3331 <https://wg21.link/LWG3331>`__","Define ``totally_ordered/_with``\  in terms of ``partially-ordered-with``\ ","Prague","|Complete|","13.0"
 "`3332 <https://wg21.link/LWG3332>`__","Issue in |sect|\ [time.format]","Prague","|Complete|","16.0","|chrono| |format|"
 "`3334 <https://wg21.link/LWG3334>`__","``basic_osyncstream``\  move assignment and destruction calls ``basic_syncbuf::emit()``\  twice","Prague","",""
 "`3335 <https://wg21.link/LWG3335>`__","Resolve C++20 NB comments US 273 and GB 274","Prague","|Complete|","15.0","|ranges|"
 "`3338 <https://wg21.link/LWG3338>`__","Rename ``default_constructible``\  to ``default_initializable``\ ","Prague","|Complete|","13.0"
 "`3340 <https://wg21.link/LWG3340>`__","Formatting functions should throw on argument/format string mismatch in |sect|\ [format.functions]","Prague","|Complete|","14.0","|format|"
 "`3346 <https://wg21.link/LWG3346>`__","``pair``\  and ``tuple``\  copy and move constructor have backwards specification","Prague","",""
-"`3347 <https://wg21.link/LWG3347>`__","``std::pair<T, U>``\  now requires ``T``\  and ``U``\  to be less-than-comparable","Prague","",""
+"`3347 <https://wg21.link/LWG3347>`__","``std::pair<T, U>``\  now requires ``T``\  and ``U``\  to be less-than-comparable","Prague","|Complete|","17.0"
 "`3348 <https://wg21.link/LWG3348>`__","``__cpp_lib_unwrap_ref``\  in wrong header","Prague","|Complete|","12.0"
 "`3349 <https://wg21.link/LWG3349>`__","Missing ``__cpp_lib_constexpr_complex``\  for P0415R1","Prague","|Complete|","16.0"
 "`3350 <https://wg21.link/LWG3350>`__","Simplify return type of ``lexicographical_compare_three_way``\ ","Prague","|Complete|","17.0","|spaceship|"
 "`3351 <https://wg21.link/LWG3351>`__","``ranges::enable_safe_range``\  should not be constrained","Prague","|Complete|","15.0","|ranges|"
 "`3352 <https://wg21.link/LWG3352>`__","``strong_equality``\  isn't a thing","Prague","|Nothing To Do|","","|spaceship|"
 "`3354 <https://wg21.link/LWG3354>`__","``has_strong_structural_equality``\  has a meaningless definition","Prague","|Nothing To Do|","","|spaceship|"
 "`3355 <https://wg21.link/LWG3355>`__","The memory algorithms should support move-only input iterators introduced by P1207","Prague","|Complete|","15.0","|ranges|"
 "`3356 <https://wg21.link/LWG3356>`__","``__cpp_lib_nothrow_convertible``\  should be ``__cpp_lib_is_nothrow_convertible``\ ","Prague","|Complete|","12.0"

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 <https://reviews.llvm.org/D123228>`_,None,Nikolas Klauser,|In Progress|
 | `[stacktrace.basic.cmp] <https://wg21.link/stacktrace.basic.cmp>`_,| `basic_stacktrace <https://reviews.llvm.org/D123228>`_,[alg.three.way],Nikolas Klauser,|In Progress|
 | `[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 <https://reviews.llvm.org/D132265>`_,[expos.only.func],Adrian Vogelsgesang,|In Progress|
+| `[array.syn] <https://wg21.link/array.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| `array <https://reviews.llvm.org/D132265>`_,[expos.only.func],"| Adrian Vogelsgesang
+| Hristo Hristov",|Complete|
 | `[deque.syn] <https://wg21.link/deque.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| `deque <https://reviews.llvm.org/D144821>`_,[expos.only.func],Hristo Hristov,|Complete|
 | `[forward.list.syn] <https://wg21.link/forward.list.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| `forward_list <https://reviews.llvm.org/D145172>`_,[expos.only.func],Hristo Hristov,|Complete|
 | `[list.syn] <https://wg21.link/list.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| `list <https://reviews.llvm.org/D132312>`_,[expos.only.func],Adrian Vogelsgesang,|Complete|
 | `[vector.syn] <https://wg21.link/vector.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),| `vector <https://reviews.llvm.org/D132268>`_,[expos.only.func],Adrian Vogelsgesang,|In Progress|
 | `[associative.map.syn] <https://wg21.link/associative.map.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),"| `map <https://reviews.llvm.org/D145976>`_
 | `multimap <https://reviews.llvm.org/D145976>`_",[expos.only.func],Hristo Hristov,|Complete|
 | `[associative.set.syn] <https://wg21.link/associative.set.syn>`_ (`general <https://wg21.link/container.opt.reqmts>`_),"| multiset
 | set",[expos.only.func],Hristo Hristov,|In Progress|

libcxx/include/array

 };
 
 template <class T, class... U>
   array(T, U...) -> array<T, 1 + sizeof...(U)>;                 // C++17
 
 template <class T, size_t N>
   bool operator==(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
 template <class T, size_t N>
-  bool operator!=(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
+  bool operator!=(const array<T,N>& x, const array<T,N>& y);    // removed in C++20
 template <class T, size_t N>
-  bool operator<(const array<T,N>& x, const array<T,N>& y);     // constexpr in C++20
+  bool operator<(const array<T,N>& x, const array<T,N>& y);     // removed in C++20
 template <class T, size_t N>
-  bool operator>(const array<T,N>& x, const array<T,N>& y);     // constexpr in C++20
+  bool operator>(const array<T,N>& x, const array<T,N>& y);     // removed in C++20
 template <class T, size_t N>
-  bool operator<=(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
+  bool operator<=(const array<T,N>& x, const array<T,N>& y);    // removed in C++20
 template <class T, size_t N>
-  bool operator>=(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
+  bool operator>=(const array<T,N>& x, const array<T,N>& y);    // removed in C++20
+template<class T, size_t N>
+  constexpr synth-three-way-result<T>
+    operator<=>(const array<T, N>& x, const array<T, N>& y);    // since C++20
 
 template <class T, size_t N >
   void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y))); // constexpr in C++20
 
 template <class T, size_t N>
   constexpr array<remove_cv_t<T>, N> to_array(T (&a)[N]);  // C++20
 template <class T, size_t N>
   constexpr array<remove_cv_t<T>, N> to_array(T (&&a)[N]); // C++20

 
 }  // std
 
 */
 
 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
+#include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/swap_ranges.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/reverse_iterator.h>
 #include <__tuple/sfinae_helpers.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_const.h>

 template <class _Tp, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 {
     return _VSTD::equal(__x.begin(), __x.end(), __y.begin());
 }
 
+#if _LIBCPP_STD_VER <= 17
+
 template <class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
-{
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
     return !(__x == __y);
 }
 
 template <class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
-{
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(),
-                                          __y.begin(), __y.end());
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
+    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
-{
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
     return __y < __x;
 }
 
 template <class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
-{
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
     return !(__y < __x);
 }
 
 template <class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
-{
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
     return !(__x < __y);
 }
 
+#else // _LIBCPP_STD_VER <= 17
+
+template <class _Tp, size_t _Size>
+_LIBCPP_HIDE_FROM_ABI constexpr __synth_three_way_result<_Tp>
+operator<=>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
+    return std::lexicographical_compare_three_way(
+        __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way<_Tp, _Tp>);
+}
+
+#endif // _LIBCPP_STD_VER <= 17
+
 template <class _Tp, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 __enable_if_t<_Size == 0 || __is_swappable<_Tp>::value, void>
 swap(array<_Tp, _Size>& __x, array<_Tp, _Size>& __y)
                                   _NOEXCEPT_(noexcept(__x.swap(__y)))
 {
     __x.swap(__y);
 }

libcxx/test/std/containers/sequences/array/compare.fail.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
-//
-//===----------------------------------------------------------------------===//
-
-// <array>
-
-// bool operator==(array<T, N> const&, array<T, N> const&);
-// bool operator!=(array<T, N> const&, array<T, N> const&);
-// bool operator<(array<T, N> const&, array<T, N> const&);
-// bool operator<=(array<T, N> const&, array<T, N> const&);
-// bool operator>(array<T, N> const&, array<T, N> const&);
-// bool operator>=(array<T, N> const&, array<T, N> const&);
-
-
-#include <array>
-#include <vector>
-#include <cassert>
-
-#include "test_macros.h"
-
-template <class Array>
-void test_compare(const Array& LHS, const Array& RHS) {
-  typedef std::vector<typename Array::value_type> Vector;
-  const Vector LHSV(LHS.begin(), LHS.end());
-  const Vector RHSV(RHS.begin(), RHS.end());
-  assert((LHS == RHS) == (LHSV == RHSV));
-  assert((LHS != RHS) == (LHSV != RHSV));
-  assert((LHS < RHS) == (LHSV < RHSV));
-  assert((LHS <= RHS) == (LHSV <= RHSV));
-  assert((LHS > RHS) == (LHSV > RHSV));
-  assert((LHS >= RHS) == (LHSV >= RHSV));
-}
-
-template <int Dummy> struct NoCompare {};
-
-int main(int, char**)
-{
-  {
-    typedef NoCompare<0> T;
-    typedef std::array<T, 3> C;
-    C c1 = {{}};
-    // expected-error@*:* 2 {{invalid operands to binary expression}}
-    TEST_IGNORE_NODISCARD (c1 == c1);
-    TEST_IGNORE_NODISCARD (c1 < c1);
-  }
-  {
-    typedef NoCompare<1> T;
-    typedef std::array<T, 3> C;
-    C c1 = {{}};
-    // expected-error@*:* 2 {{invalid operands to binary expression}}
-    TEST_IGNORE_NODISCARD (c1 != c1);
-    TEST_IGNORE_NODISCARD (c1 > c1);
-  }
-  {
-    typedef NoCompare<2> T;
-    typedef std::array<T, 0> C;
-    C c1 = {{}};
-    // expected-error@*:* 2 {{invalid operands to binary expression}}
-    TEST_IGNORE_NODISCARD (c1 == c1);
-    TEST_IGNORE_NODISCARD (c1 < c1);
-  }
-
-  return 0;
-}

libcxx/test/std/containers/sequences/array/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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
-// bool operator==(array<T, N> const&, array<T, N> const&);   // constexpr in C++20
-// bool operator!=(array<T, N> const&, array<T, N> const&);   // constexpr in C++20
-// bool operator<(array<T, N> const&, array<T, N> const&);    // constexpr in C++20
-// bool operator<=(array<T, N> const&, array<T, N> const&);   // constexpr in C++20
-// bool operator>(array<T, N> const&, array<T, N> const&);    // constexpr in C++20
-// bool operator>=(array<T, N> const&, array<T, N> const&);   // constexpr in C++20
-
+// template <class T, size_t N>
+//   bool operator==(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
+// template <class T, size_t N>
+//   bool operator!=(const array<T,N>& x, const array<T,N>& y);    // removed in C++20
+// template <class T, size_t N>
+//   bool operator<(const array<T,N>& x, const array<T,N>& y);     // removed in C++20
+// template <class T, size_t N>
+//   bool operator>(const array<T,N>& x, const array<T,N>& y);     // removed in C++20
+// template <class T, size_t N>
+//   bool operator<=(const array<T,N>& x, const array<T,N>& y);    // removed in C++20
+// template <class T, size_t N>
+//   bool operator>=(const array<T,N>& x, const array<T,N>& y);    // removed in C++20
 
 #include <array>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-TEST_CONSTEXPR_CXX20 bool tests()
-{
-    {
-        typedef std::array<int, 3> C;
-        const C c1 = {1, 2, 3};
-        const C c2 = {1, 2, 3};
-        const C c3 = {3, 2, 1};
-        const C c4 = {1, 2, 1};
-        assert(testComparisons(c1, c2, true, false));
-        assert(testComparisons(c1, c3, false, true));
-        assert(testComparisons(c1, c4, false, false));
-    }
-    {
-        typedef std::array<int, 0> C;
-        const C c1 = {};
-        const C c2 = {};
-        assert(testComparisons(c1, c2, true, false));
-    }
-    {
-        typedef std::array<LessAndEqComp, 3> C;
-        const C c1 = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(3)};
-        const C c2 = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(3)};
-        const C c3 = {LessAndEqComp(3), LessAndEqComp(2), LessAndEqComp(1)};
-        const C c4 = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(1)};
-        assert(testComparisons(c1, c2, true, false));
-        assert(testComparisons(c1, c3, false, true));
-        assert(testComparisons(c1, c4, false, false));
-    }
-    {
-        typedef std::array<LessAndEqComp, 0> C;
-        const C c1 = {};
-        const C c2 = {};
-        assert(testComparisons(c1, c2, true, false));
-    }
+TEST_CONSTEXPR_CXX20 bool tests() {
+  // Arrays where the elements support all comparison operators
+  AssertComparisonsReturnBool<std::array<int, 3> >();
+  // Empty array
+  // Arrays where the elements support only less and equality comparisons
+  AssertComparisonsReturnBool<std::array<LessAndEqComp, 3> >();
+  // Empty array where the elements support only less and equality comparisons
 
-    return true;
 }
 
-int main(int, char**)
-{
-    tests();
+int main(int, char**) {
 #if TEST_STD_VER >= 20
-    static_assert(tests(), "");
+  static_assert(tests());
 #endif
-    return 0;
 }

libcxx/test/std/containers/sequences/array/compare.three_way.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++03, c++11, c++14, c++17
+
+// <array>
+
+// template<class T, size_t N>
+//   constexpr synth-three-way-result<T>
+//     operator<=>(const array<T, N>& x, const array<T, N>& y);
+
+#include <array>
+#include <cassert>
+
+#include "test_comparisons.h"
+
+// SFINAE
+
+constexpr std::size_t N{1};
+
+// The container should fulfill `std::three_way_comparable`
+static_assert(std::three_way_comparable<std::array<int, N>>);
+
+// Thanks to SFINAE, the following is not a compiler error but returns `false`
+struct NonComparable {};
+static_assert(!std::three_way_comparable<std::array<NonComparable, N>>);
+
+// Implementation detail of `test_sequence_container_array_spaceship`
+template <typename Elem, typename Order>
+constexpr void test_sequence_container_array_spaceship_with_type() {
+  // Empty containers
+  {
+    std::array<Elem, 0> l1 = {};
+    std::array<Elem, 0> l2 = {};
+    assert(testOrder(l1, l2, Order::equivalent));
+  }
+  // Identical contents
+  {
+    std::array l1{Elem{1}, Elem{1}};
+    std::array l2{Elem{1}, Elem{1}};
+    assert(testOrder(l1, l2, Order::equivalent));
+  }
+  // Less, due to contained values
+  {
+    std::array l1{Elem{1}, Elem{1}};
+    std::array l2{Elem{1}, Elem{2}};
+    assert(testOrder(l1, l2, Order::less));
+  }
+  // Greater, due to contained values
+  {
+    std::array l1{Elem{1}, Elem{3}};
+    std::array l2{Elem{1}, Elem{2}};
+    assert(testOrder(l1, l2, Order::greater));
+  }
+  // Shorter list - unsupported - containers must be of equal lengths
+  // Longer list - unsupported - containers must be of equal lengths
+  // Unordered
+  if constexpr (std::is_same_v<Elem, PartialOrder>) {
+    std::array l1{Elem{1}, Elem{std::numeric_limits<int>::min()}};
+    std::array l2{Elem{1}, Elem{2}};
+    assert(testOrder(l1, l2, Order::unordered));
+  }
+}
+
+// Tests the `operator<=>` on sequence containers `array`
+constexpr bool test_sequence_container_array_spaceship() {
+  // Test different comparison categories
+  test_sequence_container_array_spaceship_with_type<int, std::strong_ordering>();
+  test_sequence_container_array_spaceship_with_type<StrongOrder, std::strong_ordering>();
+  test_sequence_container_array_spaceship_with_type<WeakOrder, std::weak_ordering>();
+  test_sequence_container_array_spaceship_with_type<PartialOrder, std::partial_ordering>();
+
+  // `LessAndEqComp` does not have `operator<=>`. Ordering is synthesized based on `operator<`
+  test_sequence_container_array_spaceship_with_type<LessAndEqComp, std::weak_ordering>();
+
+  return true;
+}
+
+int main(int, char**) {
+  assert(test_sequence_container_array_spaceship());
+  static_assert(test_sequence_container_array_spaceship());
+  return 0;
+}

libcxx/test/std/containers/sequences/array/compare.three_way.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <array>
+
+// template<class T, size_t N>
+//   constexpr synth-three-way-result<T>
+//     operator<=>(const array<T, N>& x, const array<T, N>& y);
+
+// arrays with different sizes should not compare
+
+#include <array>
+
+int main(int, char**) {
+  {
+    std::array a1{1};
+    std::array a2{1, 2};
+
+    // expected-error@*:* {{invalid operands to binary expression}}
+    a1 <=> a2;
+  }
+  {
+    std::array a1{1, 2};
+    std::array a2{1};
+
+    // expected-error@*:* {{invalid operands to binary expression}}
+    a1 <=> a2;
+  }
+
+  return 0;
+}

libcxx/test/std/containers/sequences/array/compare.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <array>
+
+// template <class T, size_t N>
+//   bool operator==(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
+// template <class T, size_t N>
+//   bool operator!=(const array<T,N>& x, const array<T,N>& y);    // removed in C++20
+// template <class T, size_t N>
+//   bool operator<(const array<T,N>& x, const array<T,N>& y);     // removed in C++20
+// template <class T, size_t N>
+//   bool operator>(const array<T,N>& x, const array<T,N>& y);     // removed in C++20
+// template <class T, size_t N>
+//   bool operator<=(const array<T,N>& x, const array<T,N>& y);    // removed in C++20
+// template <class T, size_t N>
+//   bool operator>=(const array<T,N>& x, const array<T,N>& y);    // removed in C++20
+
+#include <array>
+
+#include "test_macros.h"
+
+template <int>
+struct NoCompare {};
+
+int main(int, char**) {
+  {
+    typedef NoCompare<0> T;
+    typedef std::array<T, 3> C;
+    C c1 = {{}};
+    // expected-error@*:* 2 {{invalid operands to binary expression}}
+    TEST_IGNORE_NODISCARD(c1 == c1);
+    TEST_IGNORE_NODISCARD(c1 < c1);
+  }
+  {
+    typedef NoCompare<1> T;
+    typedef std::array<T, 3> C;
+    C c1 = {{}};
+    // expected-error@*:* 2 {{invalid operands to binary expression}}
+    TEST_IGNORE_NODISCARD(c1 != c1);
+    TEST_IGNORE_NODISCARD(c1 > c1);
+  }
+  {
+    typedef NoCompare<2> T;
+    typedef std::array<T, 0> C;
+    C c1 = {{}};
+    // expected-error@*:* 2 {{invalid operands to binary expression}}
+    TEST_IGNORE_NODISCARD(c1 == c1);
+    TEST_IGNORE_NODISCARD(c1 < c1);
+  }
+
+  return 0;
+}

libcxx/test/support/test_container_comparisons.h

if constexpr (std::is_same_v<Elem, PartialOrder>) {
     Container<Elem> l2{1, 2};
     assert(testOrder(l1, l2, Order::unordered));
   }
 }
 
 // Tests the `operator<=>` on sequence containers
 template <template <typename...> typename Container>
 constexpr bool test_sequence_container_spaceship() {
-  // The container should fulfil `std::three_way_comparable`
+  // The container should fulfill `std::three_way_comparable`
   static_assert(std::three_way_comparable<Container<int>>);
 
   // Test different comparison categories
   test_sequence_container_spaceship_with_type<Container, int, std::strong_ordering>();
   test_sequence_container_spaceship_with_type<Container, StrongOrder, std::strong_ordering>();
   test_sequence_container_spaceship_with_type<Container, WeakOrder, std::weak_ordering>();
   test_sequence_container_spaceship_with_type<Container, PartialOrder, std::partial_ordering>();
 
-  // `LessAndEqComp` does not have `operator<=>`. ordering is sythesized based on `operator<`
+  // `LessAndEqComp` does not have `operator<=>`. Ordering is synthesized based on `operator<`
   test_sequence_container_spaceship_with_type<Container, LessAndEqComp, std::weak_ordering>();
 
   // Thanks to SFINAE, the following is not a compiler error but returns `false`
   struct NonComparable {};
   static_assert(!std::three_way_comparable<Container<NonComparable>>);
 
   return true;
 }
if constexpr (std::is_same_v<Val, PartialOrder>) {
     Container<Key, Val> l4{{2, 3}, {2, 2}, {1, 1}};
     assert(testOrder(l3, l4, Order::unordered));
   }
 }
 
 // Tests the `operator<=>` on ordered containers
 template <template <typename...> typename Container>
 constexpr bool test_ordered_map_container_spaceship() {
-  // The container should fulfil `std::three_way_comparable`
+  // The container should fulfill `std::three_way_comparable`
   static_assert(std::three_way_comparable<Container<int, int>>);
 
   // Test different comparison categories
   test_ordered_map_container_spaceship_with_type<Container, int, int, std::strong_ordering>();
   test_ordered_map_container_spaceship_with_type<Container, int, StrongOrder, std::strong_ordering>();
   test_ordered_map_container_spaceship_with_type<Container, int, WeakOrder, std::weak_ordering>();
   test_ordered_map_container_spaceship_with_type<Container, int, PartialOrder, std::partial_ordering>();
 
-  // `LessAndEqComp` does not have `operator<=>`. ordering is sythesized based on `operator<`
+  // `LessAndEqComp` does not have `operator<=>`. Ordering is synthesized based on `operator<`
   test_ordered_map_container_spaceship_with_type<Container, int, LessAndEqComp, std::weak_ordering>();
 
   // Thanks to SFINAE, the following is not a compiler error but returns `false`
   struct NonComparable {};
   static_assert(!std::three_way_comparable<Container<int, NonComparable>>);
 
   return true;
 }
 
 #endif