[libc++][spaceship] Implement std::tuple::operator<=>

[mumbleskates]

Summary

Implement parts of P1614, including three-way comparison for tuples, and expand testing.

[cjdb]

Thanks for writing this! Some comments, but it should get to LGTM stage pretty soon.

libcxx/CREDITS.TXT

27–29 ↗

(On Diff #367034)

Please defer all of the changes in this file to a dedicated non-functional-change patch.

libcxx/include/tuple

134–142

1314

1318

I really like what you're doing here and wish that we could keep it, but I don't think it meshes with the fact we can compare tuples of different lengths.

1324

As much as I like auto return types, I think it'd be good to match the standard here.

1327

There isn't a constraints or mandates paragraph mentioned in operator<=>, so we can't do this. The note at the bottom states:

Also, all comparison operator functions are short circuited; they do not perform element accesses beyond what is required to determine the result of the comparison.

This implies that tuple{0, 1, 2} <=> tuple{0, 2} is allowed. This will have a knock-on effect for your tests.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

27

Since this type has exactly one use-case, please define it close to its point-of-use.

29

You can delete this line.

31

This should return the opposite of the other overload.

[mumbleskates]

• changes from feedback
• testing fix for GCC constexpr shenanigans

libcxx/include/tuple

1318

As far as I am aware, we cannot compare tuples of different lengths.

1324

Yeah I just wrote it this way because it's less wordy. I can change auto to the full return type here, but it will be exactly duplicated by the declared type of __result, the only thing that is ever returned. Since these are different functions I'll just copy it here, that's fine.

1327

The standard does not require operator<=> between tuples of different lengths to exist. The return type as written in the standard, common_comparison_category_t<synth-three-way-result <TTypes, UTypes>...>, is ill-formed if the tuples have different sizes.

I spent some time looking into this and everything that I can find indicates that comparisons between tuples with mismatching sizes are not defined in the standard.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

27

I would define it locally but those operators apparently have to be friends, and it's much more compact to define it here (because the friend operators can only be defined non-locally).

31

It's the equivalent of lhs > rhs (not >=), and CustomResult is emulating equality here so both of those ought to be false.

[mumbleskates]

• make synopsis signature match in style

[mumbleskates]

• modularization fixes in non-review code

[cjdb]

libcxx/include/tuple

1323

Comment unnecessary.

1327

Right, I get it now.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

31

Please have the type's name reflect that this is emulating equality.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way_incompatible.fail.cpp

25–26 ↗

(On Diff #367089)

Please change this to a passing compile-time test and use a requires-expression. Similarly in other failure files.

[mumbleskates]

• updates from feedback

[mumbleskates]

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way_incompatible.fail.cpp

25–26 ↗

(On Diff #367089)

As discussed, this one is a compile-time pass test, and the others are now compile-time tests (but still fail tests, because in operator== and all previous iterations of other relational operators, incompatible sizes are eliminated by static_assert rather than by non-participation so we can't SFINAE or concept our way out of it.

[Mordante]

Thanks for working on this.

libcxx/include/__compare/synth_three_way.h

1 ↗

(On Diff #367935)

You can use the stack feature of Phabricator to make patch series. That makes reviewing the real changes easier.

libcxx/include/tuple

135–142

For clarity please s/until/removed in/

1318

Please use _VSTD::get.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

34

Please change the test to use our common idom to test these constexpr functions both runtime and compile time. See test/libcxx/ranges/range.adaptors/range.copy.wrap/arrow.pass.cpp for a simple example.

39

The empty string in the static_assert is not required in C++20, please remove it.

74

It would be nice to also mix signed and unsigned types.

[mumbleskates]

• updates from feedback

[mumbleskates]

libcxx/include/__compare/synth_three_way.h

1 ↗

(On Diff #367935)

Unfortunately not finding any clear descriptions of how to do this in any documentation and at this point I'm more afraid of making a huge mess in phabricator notifications, already bad enough with my personal rivalry with arcanist.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

39

TIL

[mumbleskates]

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

74

I threw in some indexes with matched unsigned types and unsigned <=> floating point. We probably can't do signed <=> unsigned integral types because <=> isn't defined, and the synth-three-way fallback generates promoted compile time errorwarnings about comparison with mixed signs. Not sure if we need to add any tests for this in synth-three-way, I think it's probably fine.

[mumbleskates]

• rebase onto std::pair differential

[mumbleskates]

libcxx/include/__compare/synth_three_way.h

1 ↗

(On Diff #367935)

oh cool, i got it to work

[mumbleskates]

• Probably discovered something useful about GCC NaN: only NaN <=> non-NaN is non-constexpr, not NaN <=> NaN

[mumbleskates]

• fix braces

[Mordante]

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

74

I think it's good to add some of these tests, especially since it's rather new feature, not only in the library but also in the compilers. The warnings can be disabled by adding // ADDITIONAL_COMPILE_FLAGS: -Wno-sign-compare at the beginning of the file.

[mumbleskates]

• add signed/unsigned comparison test (should synthesize)

[mumbleskates]

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

74

I've added that test since it's small, but I think it is more important and useful to add these tests to synth-three-way directly, where the behavior is implemented (D107721), rather than wracking our brains anew about all the corner cases each time we use the functionality. I've also added the test to the parent differential above as mentioned.

[Mordante]

LGTM!

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

74

I see you added more detailed tests in D107721, thanks.

[mumbleskates]

• rebase

[mumbleskates]

• nit: modern static_assert in three_way_incompatible.compile.pass
• rebase

[Mordante]

Still LGTM!

[• Quuxplusone]

libcxx/include/tuple

1328

ADL-proof: _VSTD::__tuple_compare_three_way. Admittedly I think ADL-proofing doesn't matter so much inside an operator that's already meant to be called via ADL. The only way I can see to trigger this ADL-bomb is something silly and probably-not-conforming like

struct Incomplete;
template<class T> struct Holder { T t; };
Holder<Incomplete> *a[2];
std::tuple<Holder<Incomplete>**> t0 = {a+0};
std::tuple<Holder<Incomplete>**> t1 = {a+1};
assert(std::operator<=>(t0, t1) < 0);  // silly, possibly non-conforming

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq_incompatible.compile.fail.cpp

21–24 ↗

(On Diff #370827)

These error messages are weird. It should be complaining about how you can't write static_cast<void>(x); at file scope.

I recommend rewriting this test as a compile-only SFINAE test, like [UNTESTED CODE]

template<class T, class U>
constexpr bool are_comparable(long, T, U) { return false; }

template<class T, class U>
constexpr auto are_comparable(int, T t, U u)
    -> decltype(t < u)
{ return true; }

static_assert(are_comparable(1, std::tuple<int>(1), std::tuple<int>(2)));
static_assert(are_comparable(1, std::tuple<int>(1), std::tuple<long>(2)));
static_assert(!are_comparable(1, std::tuple<int>(1), std::tuple<int, int>(2)));
static_assert(!are_comparable(1, std::tuple<int, int>(1), std::tuple<int>(2)));

I see you did something like this in three_way_incompatible.compile.pass.cpp already (but of course there you get to use C++20 whereas here you need C++11).

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

108

Throughout, please use constexpr double nan = std::numeric_limits<double>::quiet_NaN(); for readability.
This will eliminate many line-breaks.
In the tests where you use both float and double nan, I think it's fine to just have the one variable, because (float)nan is still going to be a float-typed NaN value.

173–174

This is somewhat counterintuitive, right? What is the behavior of T1() == T2() in this case — does it call tuple's operator==, or does it not exist? Should we test that?

[mumbleskates]

• gate gcc tests on TEST_COMPILER_GCC and is_constant_evaluated

[mumbleskates]

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq_incompatible.compile.fail.cpp

21–24 ↗

(On Diff #370827)

I can rewrite these as static_asserts or something instead of cast-to-void, but it is not possible to SFINAE test these cases because operator== (and, prior to c++20, all the other operators) are ruled out as ill-formed by static_assert, not by participation. cjdb had similar questions but it turns out none of the tests that are compile.fail can be written as compile.pass SFINAE (in the case of operator==, even in c++>=20).

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

173–174

operator== does not fallback to be rewritten in terms of operator<=>, so yeah tuple's operator== is expectedly undefined in this case.

It doesn't really hurt to test it, but I think this would belong in the eq.pass test instead.

[mumbleskates]

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

108

This is already done, to be clear.

[mumbleskates]

• don't cast-to-void at top-level scope
• adl-proofing
• address comments

[mumbleskates]

• move and standardize the test for synth-three-way

[mumbleskates]

libcxx/test/std/library/description/conventions/expos.only.func/synth_three_way.pass.cpp

2

Well, this file reproducibly causes g++-11 to segfault at compile time. fantastic

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

173–174

I just spent like 45 minutes trying to make this test work. it can be impossible to use == without error, as expected, but when a no-== type is part of a tuple i cannot get that to be detectable with sfinae or even with concepts and it's unclear to me why that is.

the operator is implemented as a call to a cascade of template functions in template classes, but the end result is still ill formed and (i would think) should be eliminated, and it's beyond my current ability to see why.

[mumbleskates]

libcxx/test/std/library/description/conventions/expos.only.func/synth_three_way.pass.cpp

2

The following minimal file causes g++-11 to segfault:

#include <tuple>

int main(int, char**) {
  auto t = std::tuple(1);
  return 0;
}

...basically it seems that g++-11 segfaults any time you try to do class template deduction with std::tuple at all.

[mumbleskates]

• work around a GCC segfault bug

[Mordante]

libcxx/test/std/library/description/conventions/expos.only.func/synth_three_way.pass.cpp

2

Alternatively you add a UNSUPPORTED: gcc-11. Then it would be nice if you file a bug report for GCC and add a comment with the bug number.

[mumbleskates]

libcxx/test/std/library/description/conventions/expos.only.func/synth_three_way.pass.cpp

2

I worked around it and kind of like the result a little better, rewriting it into a single implementation just called synth_three_way that does the tuple thing and then using that.

The CI failure is once again our windows-dll testing host with "No space left on device"; I managed to get and submit the to the GCC tracker as well.

[mumbleskates]

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp

173–174

Okay. operator== is not SFINAE-friendly, and does not eliminate itself from participation when the subsidiary types don't have the operator. std::pair doesn't do this either. It's probably possible for us to implement this but that seems entirely beyond the scope here, isn't especially standard, and would probably be a lot of work besides. Suffice to say that calling calling the operator== when any of the subsidiary types are missing that operator expectedly causes an error.

The main reason we can easily SFINAE-test operator<=> is because its return type is dependent on everything it's going to do, so all the steps it's going to take when it executes are in a way traced out ahead of time in the function's signature.

[mumbleskates]

• rebase

[ldionne]

Thanks a lot for working on this. Also, thanks for your patience with the review and for providing such a nice test coverage. I have a few comments but the patch otherwise looks good to me, so let's finish this up and ship it!

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq_incompatible.compile.fail.cpp

1 ↗

(On Diff #376098)

Please make those .compile.fail.cpp tests be .verify.cpp instead, since you are checking for diagnostics. Applies everywhere.

26–28 ↗

(On Diff #376098)

Just make those expected-error-re@*:*. Using the filenames here is brittle as it breaks when we move stuff around. Applies here and elsewhere.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/gt_incompatible.compile.fail.cpp

24 ↗

(On Diff #376098)

All those expected-errors with 0-N are not very strong assertions, since the test would pass even if there was no error (because 0 errors is okay).

The more I read those tests, the more I question their benefit. The Standard says that the program is ill-formed if the tuples don't have the same size, and we usually don't test the ill-formedness of programs (because there are so many programs that are ill-formed, and it's difficult to draw the line of where to stop).

At the same time, I love test coverage and I think there *is* value in testing that comparing two differently-sized tuples doesn't compile. If it did compile, I'd be worried that something is wrong in our implementation. Perhaps I would suggest the following approach in a single file:

#include <tuple>

void f(std::tuple<int> t1, std::tuple<int, long> t2) {
  static_cast<void>(t1 == t2); // expected-error@*:* {{}}
  static_cast<void>(t1 != t2); // expected-error@*:* {{}}
  static_cast<void>(t1 > t2); // expected-error@*:* {{}}
  static_cast<void>(t1 >= t2); // expected-error@*:* {{}}
  static_cast<void>(t1 < t2); // expected-error@*:* {{}}
  static_cast<void>(t1 <= t2); // expected-error@*:* {{}}
}

IMO this is the most concise way to test that comparing tuples with different sizes doesn't compile. It isn't strongly tied to the libc++ implementation, too, so it can live in libcxx/test/std. WDYT?

[• Quuxplusone]

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/gt_incompatible.compile.fail.cpp

24 ↗

(On Diff #376098)

IMHO, if we can't rewrite these tests to be SFINAE-friendly as in three_way_incompatible.compile.pass.cpp (and previous comments already indicate: no, we can't), then we just shouldn't bother with them.

I believe your suggestion's 6 instances of // expected-error@*:* {{}} are equivalent to just 1 instance, right? Because if you're saying @*:* then it doesn't really matter what line(s) you put the comment on. But I agree that splitting that test into 6 different test files seems like overkill.

[mumbleskates]

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/gt_incompatible.compile.fail.cpp

24 ↗

(On Diff #376098)

Okay, I've tried consolidating these tests into a single compilation failure verify test for all six small operators as ldionne showed, and retained the SFINAE compile.pass test for three-way comparison.

This raises a new problem: when you test both == and !=, they hit the same static_assert and are consumed by the same error expectation, so only 5 errors are emitted for the 6 operators.

I agree with the idea that these should have less specific error expectations, but I am recalling the reasons I originally split these into their own files. I don't know enough about llvm-lit to know the best way to make this work without doing that, or if I should indeed just give up and make it one file per operator again.

[mumbleskates]

• reduce the scope of incompatible-size tuple comparison tests

[mumbleskates]

• also test size-incompatible < in all versions

[ldionne]

LGTM with comments, let's ship this!

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/size_incompatible_comparison.verify.cpp

15

This is missing a mention of operator<.

22

Add a comment saying we rely on other operators being implemented in terms of those.

[mumbleskates]

• add missing comments

libcxx/docs/Status/SpaceshipProjects.csv

 Section,Description,Dependencies,Assignee,Complete
 | `[cmp.concept] <https://wg21.link/cmp.concept>`_,"| `three_way_comparable <https://reviews.llvm.org/D103478>`_
 | `three_way_comparable_with <https://reviews.llvm.org/D103478>`_",None,Ruslan Arutyunyan,|In Progress|
 | `[cmp.result] <https://wg21.link/cmp.result>`_,| `compare_three_way_result <https://reviews.llvm.org/D103581>`_,None,Arthur O'Dwyer,|Complete|
 | `[expos.only.func] <https://wg21.link/expos.only.func>`_,"| `synth-three-way <https://reviews.llvm.org/D107721>`_
 | `synth-three-way-result <https://reviews.llvm.org/D107721>`_",[cmp.concept],Kent Ross,|Complete|
 | `[comparisons.three.way] <https://wg21.link/comparisons.three.way>`_,| `compare_three_way <https://reviews.llvm.org/D80899>`_,[cmp.concept],Christopher Di Bella,|In Progress|
 | `[cmp.alg] <https://wg21.link/cmp.alg>`_,"| `strong_order <https://reviews.llvm.org/D107036>`_
 | `weak_order <https://reviews.llvm.org/D107036>`_
 | `partial_order <https://reviews.llvm.org/D107036>`_",None,Arthur O'Dwyer,|In Progress|
 | `[alg.three.way] <https://wg21.link/alg.three.way>`_,| `lexicographical_compare_three_way <https://reviews.llvm.org/D80902>`_,[comparisons.three.way],Christopher Di Bella,|In Progress|
 | `[coroutine.handle.compare] <https://wg21.link/coroutine.handle.compare>`_,| coroutine_handle,[comparisons.three.way],Unassigned,|Not Started|
 | `[pairs.spec] <https://wg21.link/pairs.spec>`_,| `pair <https://reviews.llvm.org/D107721>`_,[expos.only.func],Kent Ross,|Complete|
 | `[syserr.errcat.nonvirtuals] <https://wg21.link/syserr.errcat.nonvirtuals>`_,| error_category,[comparisons.three.way],Unassigned,|Not Started|
 | `[syserr.compare] <https://wg21.link/syserr.compare>`_,"| error_code
 | error_condition",None,Unassigned,|Not Started|
-| `[tuple.rel] <https://wg21.link/tuple.rel>`_,| `tuple <https://reviews.llvm.org/D108250>`_,[expos.only.func],Kent Ross,|In Progress|
+| `[tuple.rel] <https://wg21.link/tuple.rel>`_,| `tuple <https://reviews.llvm.org/D108250>`_,[expos.only.func],Kent Ross,|Complete|
 "| `[optional.relops] <https://wg21.link/optional.relops>`_
 | `[optional.nullops] <https://wg21.link/optional.nullops>`_
 | `[optional.comp.with.t] <https://wg21.link/optional.comp.with.t>`_","| optional
 | nullopt",None,Kent Ross,|In Progress|
 "| `[variant.relops] <https://wg21.link/variant.relops>`_
 | `[variant.monostate.relops] <https://wg21.link/variant.monostate.relops>`_","| monostate
 | variant",None,Kent Ross,|In Progress|
 | `[unique.ptr.special] <https://wg21.link/unique.ptr.special>`_,| unique_ptr,[comparisons.three.way],Unassigned,|Not Started|

libcxx/include/tuple

 template <class T1, class... T>
     constexpr const T1& get(const tuple<T...>&) noexcept;   // C++14
 template <class T1, class... T>
     constexpr T1&& get(tuple<T...>&&) noexcept;   // C++14
 template <class T1, class... T>
     constexpr const T1&& get(const tuple<T...>&&) noexcept;   // C++14
 
 // 20.4.1.6, relational operators:
 template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
-template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&);  // constexpr in C++14
-template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
-template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&);  // constexpr in C++14
-template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
-template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
+template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&);  // constexpr in C++14, removed in C++20
+template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
+template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&);  // constexpr in C++14, removed in C++20
+template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
+template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
+template<class... T, class... U>
+  constexpr common_comparison_category_t<synth-three-way-result<T, U>...>
+    operator<=>(const tuple<T...>&, const tuple<U...>&);                                  // since C++20
 
 template <class... Types, class Alloc>
   struct uses_allocator<tuple<Types...>, Alloc>;
 
 template <class... Types>
   void
   swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
 
 }  // std
 
 */
 
+#include <__compare/common_comparison_category.h>
+#include <__compare/synth_three_way.h>
 #include <__config>
 #include <__functional/unwrap_ref.h>
 #include <__functional_base>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <__tuple>
 #include <__utility/forward.h>
+#include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <compare>
 #include <cstddef>
 #include <type_traits>
 #include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
     static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
     return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
 }
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+// operator<=>
+
+template <class ..._Tp, class ..._Up, size_t ..._Is>
+_LIBCPP_HIDE_FROM_ABI constexpr
+auto
+__tuple_compare_three_way(const tuple<_Tp...>& __x, const tuple<_Up...>& __y, index_sequence<_Is...>) {
+    common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...> __result = strong_ordering::equal;
+    static_cast<void>(((__result = _VSTD::__synth_three_way(_VSTD::get<_Is>(__x), _VSTD::get<_Is>(__y)), __result != 0) || ...));
+    return __result;
+}
+
+template <class ..._Tp, class ..._Up>
+requires (sizeof...(_Tp) == sizeof...(_Up))
+_LIBCPP_HIDE_FROM_ABI constexpr
+common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...>
+operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
+{
+    return _VSTD::__tuple_compare_three_way(__x, __y, index_sequence_for<_Tp...>{});
+}
+
+#else // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
 template <class ..._Tp, class ..._Up>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
     return !(__x == __y);
 }
 

 template <class ..._Tp, class ..._Up>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
     return !(__y < __x);
 }
 
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
 // tuple_cat
 
 template <class _Tp, class _Up> struct __tuple_cat_type;
 
 template <class ..._Ttypes, class ..._Utypes>
 struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
 {
     typedef _LIBCPP_NODEBUG tuple<_Ttypes..., _Utypes...> type;

libcxx/test/libcxx/library/description/conventions/expos.only.func/synth_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, libcpp-no-concepts
-// ADDITIONAL_COMPILE_FLAGS: -Wno-sign-compare
-
-// constexpr auto __synth_three_way = ...;
-
-#include <cassert>
-#include <compare>
-#include <limits>
-#include <utility> // Includes synth-three-way via std::pair::operator<=>
-
-#include "test_macros.h"
-
-template <typename T> concept can_synth_three_way = requires(T t) { std::__synth_three_way(t, t); };
-
-// A custom three-way result type
-struct CustomEquality {
-  friend constexpr bool operator==(const CustomEquality&, int) noexcept { return true; }
-  friend constexpr bool operator<(const CustomEquality&, int) noexcept { return false; }
-  friend constexpr bool operator<(int, const CustomEquality&) noexcept { return false; }
-};
-
-constexpr bool test() {
-  {
-    assert(std::__synth_three_way(1, 1) == std::strong_ordering::equal);
-    assert(std::__synth_three_way(2, 1) == std::strong_ordering::greater);
-    assert(std::__synth_three_way(1, 2) == std::strong_ordering::less);
-    ASSERT_SAME_TYPE(std::strong_ordering, std::__synth_three_way_result<int, int>);
-    ASSERT_SAME_TYPE(std::strong_ordering, std::__synth_three_way_result<short, long long int>);
-  }
-  {
-    constexpr double nan = std::numeric_limits<double>::quiet_NaN();
-    assert(std::__synth_three_way(1.0, 1.0) == std::partial_ordering::equivalent);
-    assert(std::__synth_three_way(2.0, 1.0) == std::partial_ordering::greater);
-    assert(std::__synth_three_way(1.0, 2.0) == std::partial_ordering::less);
-    assert(std::__synth_three_way(nan, nan) == std::partial_ordering::unordered);
-    ASSERT_SAME_TYPE(std::partial_ordering, std::__synth_three_way_result<double, double>);
-    ASSERT_SAME_TYPE(std::partial_ordering, std::__synth_three_way_result<double, float>);
-    ASSERT_SAME_TYPE(std::partial_ordering, std::__synth_three_way_result<double, int>);
-    ASSERT_SAME_TYPE(std::partial_ordering, std::__synth_three_way_result<float, short>);
-  }
-  {
-    struct StrongSpaceship {
-      int value;
-      constexpr bool operator==(const StrongSpaceship&) const = default;
-      constexpr std::strong_ordering operator<=>(const StrongSpaceship& other) const { return value <=> other.value; }
-    };
-    assert(std::__synth_three_way(StrongSpaceship{1}, StrongSpaceship{1}) == std::strong_ordering::equal);
-    assert(std::__synth_three_way(StrongSpaceship{2}, StrongSpaceship{1}) == std::strong_ordering::greater);
-    assert(std::__synth_three_way(StrongSpaceship{1}, StrongSpaceship{2}) == std::strong_ordering::less);
-    ASSERT_SAME_TYPE(std::strong_ordering, std::__synth_three_way_result<StrongSpaceship, StrongSpaceship>);
-  }
-  {
-    struct WeakSpaceship {
-      int value;
-      constexpr bool operator==(const WeakSpaceship&) const = default;
-      constexpr std::weak_ordering operator<=>(const WeakSpaceship& other) const {
-        return value <=> other.value;
-      }
-    };
-    assert(std::__synth_three_way(WeakSpaceship{1}, WeakSpaceship{1}) == std::weak_ordering::equivalent);
-    assert(std::__synth_three_way(WeakSpaceship{2}, WeakSpaceship{1}) == std::weak_ordering::greater);
-    assert(std::__synth_three_way(WeakSpaceship{1}, WeakSpaceship{2}) == std::weak_ordering::less);
-    ASSERT_SAME_TYPE(std::weak_ordering, std::__synth_three_way_result<WeakSpaceship, WeakSpaceship>);
-  }
-  {
-    struct PartialSpaceship {
-      double value;
-      constexpr bool operator==(const PartialSpaceship&) const = default;
-      constexpr std::partial_ordering operator<=>(const PartialSpaceship& other) const {
-        return value <=> other.value;
-      }
-    };
-    constexpr double nan = std::numeric_limits<double>::quiet_NaN();
-    assert(std::__synth_three_way(PartialSpaceship{1.0}, PartialSpaceship{1.0}) == std::partial_ordering::equivalent);
-    assert(std::__synth_three_way(PartialSpaceship{2.0}, PartialSpaceship{1.0}) == std::partial_ordering::greater);
-    assert(std::__synth_three_way(PartialSpaceship{1.0}, PartialSpaceship{2.0}) == std::partial_ordering::less);
-    assert(std::__synth_three_way(PartialSpaceship{nan}, PartialSpaceship{nan}) == std::partial_ordering::unordered);
-    ASSERT_SAME_TYPE(std::partial_ordering, std::__synth_three_way_result<PartialSpaceship, PartialSpaceship>);
-  }
-  {
-    struct NoSpaceship {
-      int value;
-      constexpr bool operator==(const NoSpaceship&) const = default;
-      constexpr bool operator<(const NoSpaceship& other) const { return value < other.value; }
-    };
-    assert(std::__synth_three_way(NoSpaceship{1}, NoSpaceship{1}) == std::weak_ordering::equivalent);
-    assert(std::__synth_three_way(NoSpaceship{2}, NoSpaceship{1}) == std::weak_ordering::greater);
-    assert(std::__synth_three_way(NoSpaceship{1}, NoSpaceship{2}) == std::weak_ordering::less);
-    ASSERT_SAME_TYPE(std::weak_ordering, std::__synth_three_way_result<NoSpaceship, NoSpaceship>);
-  }
-  {
-    // Types with operator<=> but no operator== are not three_way_comparable and will fall back to operator< and
-    // compare as weakly ordered.
-    struct SpaceshipNoEquals {
-      constexpr std::strong_ordering operator<=>(const SpaceshipNoEquals&) const {
-        return std::strong_ordering::equivalent;
-      }
-    };
-    assert(std::__synth_three_way(SpaceshipNoEquals{}, SpaceshipNoEquals{}) == std::weak_ordering::equivalent);
-    ASSERT_SAME_TYPE(std::weak_ordering, std::__synth_three_way_result<SpaceshipNoEquals, SpaceshipNoEquals>);
-  }
-  {
-    // Custom three-way-comparison result types cannot satisfy standard concepts (and therefore synth-three-way)
-    // because they are not understood by std::common_comparison_category, but they can still be used in
-    // the same way as standard orderings to do comparisons, and thus can be used by synth-three-way to yield a
-    // weakly-ordered result.
-    struct CustomSpaceship {
-      constexpr CustomEquality operator<=>(const CustomSpaceship&) const { return CustomEquality(); }
-    };
-    assert((CustomSpaceship() <=> CustomSpaceship()) == 0);
-    assert(!(CustomSpaceship() < CustomSpaceship()));
-    assert(std::__synth_three_way(CustomSpaceship(), CustomSpaceship()) == std::weak_ordering::equivalent);
-    ASSERT_SAME_TYPE(std::weak_ordering, std::__synth_three_way_result<CustomSpaceship, CustomSpaceship>);
-  }
-  // SFINAE tests demonstrating synth-three-way needs three_way_comparable or operator<.
-  {
-    struct NoRelative {
-      constexpr bool operator==(const NoRelative&) const;
-    };
-    static_assert(!can_synth_three_way<NoRelative>);
-  }
-  {
-    struct NoLessThan {
-      constexpr bool operator==(const NoLessThan&) const;
-      constexpr bool operator>(const NoLessThan&) const;
-      constexpr bool operator>=(const NoLessThan&) const;
-      constexpr bool operator<=(const NoLessThan&) const;
-    };
-    static_assert(!can_synth_three_way<NoLessThan>);
-  }
-  {
-    assert(std::__synth_three_way(1, 1U) == std::weak_ordering::equivalent);
-    assert(std::__synth_three_way(-1, 0U) == std::weak_ordering::greater);
-    // Even with the warning suppressed (-Wno-sign-compare) there should still be no <=> operator
-    // between signed and unsigned types, so we should end up with a synthesized weak ordering.
-    ASSERT_SAME_TYPE(std::weak_ordering, std::__synth_three_way_result<int, unsigned int>);
-    // When an unsigned type can be narrowed to a larger signed type, <=> should be defined and we
-    // should get a strong ordering. (This probably does not raise a warning due to safe narrowing.)
-    assert((static_cast<long long int>(-1) <=> static_cast<unsigned char>(0)) == std::strong_ordering::less);
-    assert(std::__synth_three_way(static_cast<long long int>(-1),
-                                  static_cast<unsigned char>(0)) == std::strong_ordering::less);
-    ASSERT_SAME_TYPE(std::strong_ordering, std::__synth_three_way_result<long long int, unsigned char>);
-  }
-
-  return true;
-}
-
-int main(int, char**) {
-  test();
-  static_assert(test());
-
-  {
-    constexpr double nan = std::numeric_limits<double>::quiet_NaN();
-    assert(std::__synth_three_way(nan, 1.0) == std::partial_ordering::unordered);
-  }
-
-  return 0;
-}

libcxx/test/std/library/description/conventions/expos.only.func/synth_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, libcpp-no-concepts
+// ADDITIONAL_COMPILE_FLAGS: -Wno-sign-compare
+
+// constexpr auto synth-three-way = ...;
+//   via std::tuple<T>(t) <=> std::tuple<U>(u), which exposes its behavior most directly
+
+#include <cassert>
+#include <compare>
+#include <limits>  // quiet_NaN
+#include <tuple>
+#include <utility> // declval
+
+#include "test_macros.h"
+
+template <typename T, typename U = T>
+concept can_synth_three_way = requires(T t, U u) { std::tuple<T>(t) <=> std::tuple<U>(u); };
+
+template <typename T, typename U>
+constexpr auto synth_three_way(const T& t, const U& u) {
+  return std::tuple<T>(t) <=> std::tuple<U>(u);
+}
+
+template <typename T, typename U>
+using synth_three_way_result = decltype(std::declval<std::tuple<T>>() <=> std::declval<std::tuple<U>>());
+
+// A custom three-way result type
+struct CustomEquality {
+  friend constexpr bool operator==(const CustomEquality&, int) noexcept { return true; }
+  friend constexpr bool operator<(const CustomEquality&, int) noexcept { return false; }
+  friend constexpr bool operator<(int, const CustomEquality&) noexcept { return false; }
+};
+
+constexpr bool test() {
+  {
+    assert(synth_three_way(1, 1) == std::strong_ordering::equal);
+    assert(synth_three_way(2, 1) == std::strong_ordering::greater);
+    assert(synth_three_way(1, 2) == std::strong_ordering::less);
+    ASSERT_SAME_TYPE(std::strong_ordering, synth_three_way_result<int, int>);
+    ASSERT_SAME_TYPE(std::strong_ordering, synth_three_way_result<short, long long int>);
+  }
+  {
+    constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+    assert(synth_three_way(1.0, 1.0) == std::partial_ordering::equivalent);
+    assert(synth_three_way(2.0, 1.0) == std::partial_ordering::greater);
+    assert(synth_three_way(1.0, 2.0) == std::partial_ordering::less);
+    assert(synth_three_way(nan, nan) == std::partial_ordering::unordered);
+    ASSERT_SAME_TYPE(std::partial_ordering, synth_three_way_result<double, double>);
+    ASSERT_SAME_TYPE(std::partial_ordering, synth_three_way_result<double, float>);
+    ASSERT_SAME_TYPE(std::partial_ordering, synth_three_way_result<double, int>);
+    ASSERT_SAME_TYPE(std::partial_ordering, synth_three_way_result<float, short>);
+  }
+  {
+    struct StrongSpaceship {
+      int value;
+      constexpr bool operator==(const StrongSpaceship&) const = default;
+      constexpr std::strong_ordering operator<=>(const StrongSpaceship& other) const { return value <=> other.value; }
+    };
+    assert(synth_three_way(StrongSpaceship{1}, StrongSpaceship{1}) == std::strong_ordering::equal);
+    assert(synth_three_way(StrongSpaceship{2}, StrongSpaceship{1}) == std::strong_ordering::greater);
+    assert(synth_three_way(StrongSpaceship{1}, StrongSpaceship{2}) == std::strong_ordering::less);
+    ASSERT_SAME_TYPE(std::strong_ordering, synth_three_way_result<StrongSpaceship, StrongSpaceship>);
+  }
+  {
+    struct WeakSpaceship {
+      int value;
+      constexpr bool operator==(const WeakSpaceship&) const = default;
+      constexpr std::weak_ordering operator<=>(const WeakSpaceship& other) const {
+        return value <=> other.value;
+      }
+    };
+    assert(synth_three_way(WeakSpaceship{1}, WeakSpaceship{1}) == std::weak_ordering::equivalent);
+    assert(synth_three_way(WeakSpaceship{2}, WeakSpaceship{1}) == std::weak_ordering::greater);
+    assert(synth_three_way(WeakSpaceship{1}, WeakSpaceship{2}) == std::weak_ordering::less);
+    ASSERT_SAME_TYPE(std::weak_ordering, synth_three_way_result<WeakSpaceship, WeakSpaceship>);
+  }
+  {
+    struct PartialSpaceship {
+      double value;
+      constexpr bool operator==(const PartialSpaceship&) const = default;
+      constexpr std::partial_ordering operator<=>(const PartialSpaceship& other) const {
+        return value <=> other.value;
+      }
+    };
+    constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+    assert(synth_three_way(PartialSpaceship{1.0}, PartialSpaceship{1.0}) == std::partial_ordering::equivalent);
+    assert(synth_three_way(PartialSpaceship{2.0}, PartialSpaceship{1.0}) == std::partial_ordering::greater);
+    assert(synth_three_way(PartialSpaceship{1.0}, PartialSpaceship{2.0}) == std::partial_ordering::less);
+    assert(synth_three_way(PartialSpaceship{nan}, PartialSpaceship{nan}) == std::partial_ordering::unordered);
+    ASSERT_SAME_TYPE(std::partial_ordering, synth_three_way_result<PartialSpaceship, PartialSpaceship>);
+  }
+  {
+    struct NoSpaceship {
+      int value;
+      constexpr bool operator==(const NoSpaceship&) const = default;
+      constexpr bool operator<(const NoSpaceship& other) const { return value < other.value; }
+    };
+    assert(synth_three_way(NoSpaceship{1}, NoSpaceship{1}) == std::weak_ordering::equivalent);
+    assert(synth_three_way(NoSpaceship{2}, NoSpaceship{1}) == std::weak_ordering::greater);
+    assert(synth_three_way(NoSpaceship{1}, NoSpaceship{2}) == std::weak_ordering::less);
+    ASSERT_SAME_TYPE(std::weak_ordering, synth_three_way_result<NoSpaceship, NoSpaceship>);
+  }
+  {
+    // Types with operator<=> but no operator== are not three_way_comparable and will fall back to operator< and
+    // compare as weakly ordered.
+    struct SpaceshipNoEquals {
+      constexpr std::strong_ordering operator<=>(const SpaceshipNoEquals&) const {
+        return std::strong_ordering::equivalent;
+      }
+    };
+    assert(synth_three_way(SpaceshipNoEquals{}, SpaceshipNoEquals{}) == std::weak_ordering::equivalent);
+    ASSERT_SAME_TYPE(std::weak_ordering, synth_three_way_result<SpaceshipNoEquals, SpaceshipNoEquals>);
+  }
+  {
+    // Custom three-way-comparison result types cannot satisfy standard concepts (and therefore synth-three-way)
+    // because they are not understood by std::common_comparison_category, but they can still be used in
+    // the same way as standard orderings to do comparisons, and thus can be used by synth-three-way to yield a
+    // weakly-ordered result.
+    struct CustomSpaceship {
+      constexpr CustomEquality operator<=>(const CustomSpaceship&) const { return CustomEquality(); }
+    };
+    assert((CustomSpaceship{} <=> CustomSpaceship{}) == 0);
+    assert(!(CustomSpaceship{} < CustomSpaceship{}));
+    assert(synth_three_way(CustomSpaceship{}, CustomSpaceship{}) == std::weak_ordering::equivalent);
+    ASSERT_SAME_TYPE(std::weak_ordering, synth_three_way_result<CustomSpaceship, CustomSpaceship>);
+  }
+  // SFINAE tests demonstrating synth-three-way needs three_way_comparable or operator<.
+  {
+    struct NoRelative {
+      constexpr bool operator==(const NoRelative&) const;
+    };
+    static_assert(!can_synth_three_way<NoRelative>);
+  }
+  {
+    struct NoLessThan {
+      constexpr bool operator==(const NoLessThan&) const;
+      constexpr bool operator>(const NoLessThan&) const;
+      constexpr bool operator>=(const NoLessThan&) const;
+      constexpr bool operator<=(const NoLessThan&) const;
+    };
+    static_assert(!can_synth_three_way<NoLessThan>);
+  }
+  {
+    assert(synth_three_way(1, 1U) == std::weak_ordering::equivalent);
+    assert(synth_three_way(-1, 0U) == std::weak_ordering::greater);
+    // Even with the warning suppressed (-Wno-sign-compare) there should still be no <=> operator
+    // between signed and unsigned types, so we should end up with a synthesized weak ordering.
+    ASSERT_SAME_TYPE(std::weak_ordering, synth_three_way_result<int, unsigned int>);
+    // When an unsigned type can be narrowed to a larger signed type, <=> should be defined and we
+    // should get a strong ordering. (This probably does not raise a warning due to safe narrowing.)
+    assert(synth_three_way(static_cast<long long int>(-1), static_cast<unsigned char>(0)) == std::strong_ordering::less);
+    assert(synth_three_way(static_cast<long long int>(-1), static_cast<unsigned char>(0)) == std::strong_ordering::less);
+    ASSERT_SAME_TYPE(std::strong_ordering, synth_three_way_result<long long int, unsigned char>);
+  }
+#ifdef TEST_COMPILER_GCC
+  // GCC cannot evaluate NaN @ non-NaN constexpr, so test that runtime-only.
+  if (!std::is_constant_evaluated())
+#endif
+  {
+    constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+    assert(synth_three_way(nan, 1.0) == std::partial_ordering::unordered);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/size_incompatible_comparison.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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template<class... TTypes, class... UTypes>
+//   bool
+//   operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03
+
+#include <tuple>
+
+void f(std::tuple<int> t1, std::tuple<int, long> t2) {
+  static_cast<void>(t1 == t2); // expected-error@*:* {{}}
+  static_cast<void>(t1 < t2); // expected-error@*:* {{}}
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/size_incompatible_three_way.compile.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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template<class... TTypes, class... UTypes>
+//   auto
+//   operator<=>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, libcpp-no-concepts
+
+#include <tuple>
+
+template <class T, class U>
+concept can_compare = requires(T t, U u) { t <=> u; };
+
+typedef std::tuple<int> T1;
+typedef std::tuple<int, long> T2;
+
+static_assert(!can_compare<T1, T2>);
+static_assert(!can_compare<T2, T1>);

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template<class... TTypes, class... UTypes>
+//   auto
+//   operator<=>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, libcpp-no-concepts
+// ADDITIONAL_COMPILE_FLAGS: -Wno-sign-compare
+
+#include <cassert>
+#include <compare>
+#include <limits>
+#include <tuple>
+#include <type_traits> // std::is_constant_evaluated
+
+#include "test_macros.h"
+
+// A custom three-way result type
+struct CustomEquality {
+  friend constexpr bool operator==(const CustomEquality&, int) noexcept { return true; }
+  friend constexpr bool operator<(const CustomEquality&, int) noexcept { return false; }
+  friend constexpr bool operator<(int, const CustomEquality&) noexcept { return false; }
+};
+
+constexpr bool test() {
+  // Empty tuple
+  {
+    typedef std::tuple<> T0;
+    // No member types yields strong ordering (all are equal).
+    ASSERT_SAME_TYPE(decltype(T0() <=> T0()), std::strong_ordering);
+    assert((T0() <=> T0()) == std::strong_ordering::equal);
+  }
+  // Mixed types with integers, which compare strongly ordered
+  {
+    typedef std::tuple<long> T1;
+    typedef std::tuple<short> T2;
+    ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::strong_ordering);
+    assert((T1(1) <=> T2(1)) == std::strong_ordering::equal);
+    assert((T1(1) <=> T2(0)) == std::strong_ordering::greater);
+    assert((T1(1) <=> T2(2)) == std::strong_ordering::less);
+  }
+  {
+    typedef std::tuple<long, unsigned int> T1;
+    typedef std::tuple<short, unsigned long> T2;
+    ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::strong_ordering);
+    assert((T1(1, 2) <=> T2(1, 2)) == std::strong_ordering::equal);
+    assert((T1(1, 2) <=> T2(0, 2)) == std::strong_ordering::greater);
+    assert((T1(1, 2) <=> T2(2, 2)) == std::strong_ordering::less);
+    assert((T1(1, 2) <=> T2(1, 1)) == std::strong_ordering::greater);
+    assert((T1(1, 2) <=> T2(1, 3)) == std::strong_ordering::less);
+  }
+  {
+    typedef std::tuple<long, int, unsigned short> T1;
+    typedef std::tuple<short, long, unsigned int> T2;
+    ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::strong_ordering);
+    assert((T1(1, 2, 3) <=> T2(1, 2, 3)) == std::strong_ordering::equal);
+    assert((T1(1, 2, 3) <=> T2(0, 2, 3)) == std::strong_ordering::greater);
+    assert((T1(1, 2, 3) <=> T2(2, 2, 3)) == std::strong_ordering::less);
+    assert((T1(1, 2, 3) <=> T2(1, 1, 3)) == std::strong_ordering::greater);
+    assert((T1(1, 2, 3) <=> T2(1, 3, 3)) == std::strong_ordering::less);
+    assert((T1(1, 2, 3) <=> T2(1, 2, 2)) == std::strong_ordering::greater);
+    assert((T1(1, 2, 3) <=> T2(1, 2, 4)) == std::strong_ordering::less);
+  }
+  // Mixed types with floating point, which compare partially ordered
+  {
+    typedef std::tuple<long> T1;
+    typedef std::tuple<double> T2;
+    ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
+    assert((T1(1) <=> T2(1)) == std::partial_ordering::equivalent);
+    assert((T1(1) <=> T2(0.9)) == std::partial_ordering::greater);
+    assert((T1(1) <=> T2(1.1)) == std::partial_ordering::less);
+  }
+  {
+    typedef std::tuple<long, float> T1;
+    typedef std::tuple<double, unsigned int> T2;
+    ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
+    assert((T1(1, 2) <=> T2(1, 2)) == std::partial_ordering::equivalent);
+    assert((T1(1, 2) <=> T2(0.9, 2)) == std::partial_ordering::greater);
+    assert((T1(1, 2) <=> T2(1.1, 2)) == std::partial_ordering::less);
+    assert((T1(1, 2) <=> T2(1, 1)) == std::partial_ordering::greater);
+    assert((T1(1, 2) <=> T2(1, 3)) == std::partial_ordering::less);
+  }
+  {
+    typedef std::tuple<short, float, double> T1;
+    typedef std::tuple<double, long, unsigned int> T2;
+    ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
+    assert((T1(1, 2, 3) <=> T2(1, 2, 3)) == std::partial_ordering::equivalent);
+    assert((T1(1, 2, 3) <=> T2(0.9, 2, 3)) == std::partial_ordering::greater);
+    assert((T1(1, 2, 3) <=> T2(1.1, 2, 3)) == std::partial_ordering::less);
+    assert((T1(1, 2, 3) <=> T2(1, 1, 3)) == std::partial_ordering::greater);
+    assert((T1(1, 2, 3) <=> T2(1, 3, 3)) == std::partial_ordering::less);
+    assert((T1(1, 2, 3) <=> T2(1, 2, 2)) == std::partial_ordering::greater);
+    assert((T1(1, 2, 3) <=> T2(1, 2, 4)) == std::partial_ordering::less);
+  }
+  {
+    typedef std::tuple<float> T1;
+    typedef std::tuple<double> T2;
+    constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+    // Comparisons with NaN and non-NaN are non-constexpr in GCC, so both sides must be NaN
+    assert((T1(nan) <=> T2(nan)) == std::partial_ordering::unordered);
+  }
+  {
+    typedef std::tuple<double, double> T1;
+    typedef std::tuple<float, float> T2;
+    constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+    assert((T1(nan, 2) <=> T2(nan, 2)) == std::partial_ordering::unordered);
+    assert((T1(1, nan) <=> T2(1, nan)) == std::partial_ordering::unordered);
+  }
+  {
+    typedef std::tuple<double, float, float> T1;
+    typedef std::tuple<double, double, float> T2;
+    constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+    assert((T1(nan, 2, 3) <=> T2(nan, 2, 3)) == std::partial_ordering::unordered);
+    assert((T1(1, nan, 3) <=> T2(1, nan, 3)) == std::partial_ordering::unordered);
+    assert((T1(1, 2, nan) <=> T2(1, 2, nan)) == std::partial_ordering::unordered);
+  }
+  // Ordering classes and synthesized three way comparison
+  {
+    typedef std::tuple<long, int, unsigned int> T1;
+    typedef std::tuple<int, long, unsigned short> T2;
+    // All strongly ordered members yields strong ordering.
+    ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::strong_ordering);
+  }
+  {
+    struct WeakSpaceship {
+      constexpr bool operator==(const WeakSpaceship&) const { return true; }
+      constexpr std::weak_ordering operator<=>(const WeakSpaceship&) const { return std::weak_ordering::equivalent; }
+    };
+    {
+      typedef std::tuple<int, unsigned int, WeakSpaceship> T1;
+      typedef std::tuple<int, unsigned long, WeakSpaceship> T2;
+      // Strongly ordered members and a weakly ordered member yields weak ordering.
+      ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::weak_ordering);
+    }
+    {
+      typedef std::tuple<unsigned int, int, WeakSpaceship> T1;
+      typedef std::tuple<double, long, WeakSpaceship> T2;
+      // Doubles are partially ordered, so one partial, one strong, and one weak ordering
+      // yields partial ordering.
+      ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
+    }
+  }
+  {
+    struct NoSpaceship {
+      constexpr bool operator==(const NoSpaceship&) const { return true; }
+      constexpr bool operator<(const NoSpaceship&) const { return false; }
+    };
+    typedef std::tuple<int, unsigned int, NoSpaceship> T1;
+    typedef std::tuple<int, unsigned long, NoSpaceship> T2;
+    // Strongly ordered members and a weakly ordered member (synthesized) yields weak ordering.
+    ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::weak_ordering);
+  }
+  {
+    struct SpaceshipNoEquals {
+      constexpr std::strong_ordering operator<=>(const SpaceshipNoEquals&) const { return std::strong_ordering::equal; }
+      constexpr bool operator<(const SpaceshipNoEquals&) const { return false; }
+    };
+    typedef std::tuple<int, unsigned int, SpaceshipNoEquals> T1;
+    typedef std::tuple<int, unsigned long, SpaceshipNoEquals> T2;
+    // Spaceship operator with no == operator falls back on the < operator and weak ordering.
+    ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::weak_ordering);
+  }
+  {
+    struct CustomSpaceship {
+      constexpr CustomEquality operator<=>(const CustomSpaceship&) const { return CustomEquality(); }
+    };
+    typedef std::tuple<int, unsigned int, CustomSpaceship> T1;
+    typedef std::tuple<short, unsigned long, CustomSpaceship> T2;
+    typedef std::tuple<CustomSpaceship> T3;
+    // Custom three way return types cannot be used in synthesized three way comparison,
+    // but they can be used for (rewritten) operator< when synthesizing a weak ordering.
+    ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::weak_ordering);
+    ASSERT_SAME_TYPE(decltype(T3() <=> T3()), std::weak_ordering);
+  }
+  {
+    typedef std::tuple<long, int> T1;
+    typedef std::tuple<long, unsigned int> T2;
+    // Even with the warning suppressed (-Wno-sign-compare) there should still be no <=> operator
+    // between signed and unsigned types, so we should end up with a synthesized weak ordering.
+    ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::weak_ordering);
+  }
+
+#ifdef TEST_COMPILER_GCC
+  // GCC cannot evaluate NaN @ non-NaN constexpr, so test that runtime-only.
+  if (!std::is_constant_evaluated())
+#endif
+  {
+    {
+      typedef std::tuple<double> T1;
+      typedef std::tuple<int> T2;
+      constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+      ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
+      assert((T1(nan) <=> T2(1)) == std::partial_ordering::unordered);
+    }
+    {
+      typedef std::tuple<double, double> T1;
+      typedef std::tuple<int, int> T2;
+      constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+      ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
+      assert((T1(nan, 2) <=> T2(1, 2)) == std::partial_ordering::unordered);
+      assert((T1(1, nan) <=> T2(1, 2)) == std::partial_ordering::unordered);
+    }
+    {
+      typedef std::tuple<double, double, double> T1;
+      typedef std::tuple<int, int, int> T2;
+      constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+      ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
+      assert((T1(nan, 2, 3) <=> T2(1, 2, 3)) == std::partial_ordering::unordered);
+      assert((T1(1, nan, 3) <=> T2(1, 2, 3)) == std::partial_ordering::unordered);
+      assert((T1(1, 2, nan) <=> T2(1, 2, 3)) == std::partial_ordering::unordered);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}