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

[mumbleskates]

Summary

Implements parts of P1614, including synth-three-way and three way comparison for std::pair.

[mumbleskates]

Add tests for std::pair::operator<=> and synth-three-way

[mumbleskates]

Update to include the whole diff

[• Quuxplusone]

Thanks for working on this! I hope to get D107584 landed later today or tomorrow so that you can rebase on it.

libcxx/include/__compare/__synthesized.h

9–10 ↗

(On Diff #365069)

This header should be named __compare/synth_three_way.h (name after the component, and drop the leading underscores on the filename).

24 ↗

(On Diff #365069)

Add a comment: // [expos.only.func]

26 ↗

(On Diff #365069)

T, U => _Tp, _Up
Also, I'd like to see some discussion (here, and then in the commit message) about why __synth_three_way does not need to be a lambda object the way it's shown in the Standard. I suspect that since it's used for partly-program-defined types like std::pair<int, Holder<Incomplete>*>, the reason may have to do with suppressing ADL... although, no, that doesn't make sense, because we're doing ADL on __t < __u on lines 28 and 35 already.

42 ↗

(On Diff #365069)

_VSTD::__synth_three_way (unless you change it back to a lambda)
also T, U => _Tp, _Up

libcxx/include/__utility/pair.h

15–16

(Once the underscores are removed, these will need to be re-alphabetized.)
Also, __com < __con.

332–333

ADL-proof: _VSTD::__synth_three_way, if __synth_three_way doesn't become a lambda.

Also, really evil user code could probably detect that you're calling __result == 0 instead of __result != 0 (since __synth_three_way_result<_T1> could be Widget); how about just using the exact implementation from the Standard, two-part if and all?

Before addressing this comment, please make the change I suggested in comparison.pass.cpp, and re-run your tests. Does my third NaN test case actually blow up this implementation?

libcxx/test/libcxx/compare/synthesized.pass.cpp

11 ↗

(On Diff #365069)

Rename the file to synth_three_way.pass.cpp. Also I'd recommend putting it under something like
libcxx/test/libcxx/library/description/conventions/expos.only.func/synth_three_way.pass.cpp.
(We'd put it next to the tests for __decay_copy if we had any, but we don't.)

21 ↗

(On Diff #365069)

This #if is true by definition, since the test is unsupported in earlier versions.

34 ↗

(On Diff #365069)

Add:

static_assert(std::__synth_three_way(NoSpaceship{1}, NoSpaceship{1}) == std::weak_ordering::equivalent);
static_assert(std::__synth_three_way(NoSpaceship{2}, NoSpaceship{1}) == std::weak_ordering::greater);
ASSERT_SAME_TYPE(std::__synth_three_way_result<NoSpaceship, NoSpaceship>, std::weak_ordering);

Similarly for the other cases tested below.
Finally, unless someone proves that this is IFNDR, please also test

struct CustomSpaceship {
    struct Result { operator std::weak_ordering() const { return std::weak_ordering::equivalent; } };
    Result operator<=>(const CustomSpaceship&) const { return Result(); }
};
ASSERT_SAME_TYPE(decltype(std::__synth_three_way(CustomSpaceship{}, CustomSpaceship{})), CustomSpaceship::Result);
ASSERT_SAME_TYPE(std::__synth_three_way_result<CustomSpaceship, CustomSpaceship>, CustomSpaceship::Result);

and make sure you have a test along these lines for std::pair as well.

(You might find that CustomSpaceship doesn't synth-three-way as written, because it lacks an operator==. If so, well, I recommend adding a test for that too.)

libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/comparison.pass.cpp

41 ↗

(On Diff #365069)

Could you use double as your type with partial ordering?
Let's also add a test where the unordered result is expected, e.g.

std::make_pair(1, 1.0) <=> std::make_pair(2, std::numeric_limits<double>::quiet_NaN())  // expect ::less
std::make_pair(1, 1.0) <=> std::make_pair(1, std::numeric_limits<double>::quiet_NaN())  // expect ::unordered
std::make_pair(1.0, 1) <=> std::make_pair(std::numeric_limits<double>::quiet_NaN(), 2)  // expect ::unordered

[cjdb]

libcxx/include/__compare/__synthesized.h

26 ↗

(On Diff #365069)

There at least two advantages to it being a lambda:

• no ADL issues
• noexcept is correct by default (you're missing a noexcept specifier on this)

libcxx/include/__utility/pair.h

332–333

Also, really evil user code could probably detect that you're calling __result == 0 instead of __result != 0 (since __synth_three_way_result<_T1> could be Widget);

In which situation is this possible? If three_way_comparable is false, then it's weak_ordering. If the concept is true, then it's only allowed to be one of partial_ordering, weak_ordering, or strong_ordering.

334

Please replace the if-statement with a conditional operator or match the standard's if-statement.

[• Quuxplusone]

libcxx/include/__compare/__synthesized.h

26 ↗

(On Diff #365069)

noexcept is correct by default

If you mean "lambdas are noexcept(auto) by default," no, that's not true. They're constexpr by default, but not noexcept. If the Standard requires noexcept(auto) / expression-equivalency here, then we need to write code to implement it.
However, https://eel.is/c++draft/expos.only.func gives a reference implementation which is noexcept(false). Therefore, at least arguably (and maybe more than arguably), it would be detectably non-conforming to add noexcept(~~~) here.

libcxx/include/__utility/pair.h

332–333

Does my third NaN test case actually blow up this implementation?

No, because __result != 0 is equivalent to !(__result == 0), even in cases like that where !(__result < 0 || __result > 0).

In which situation is [Widget __result] possible?

Ah, right, it's not. OK.

Still, +1 to @cjdb's comment below: please match the Standard's reference implementation here anyway.

[mumbleskates]

Updates re feedback

libcxx/include/__compare/__synthesized.h

26 ↗

(On Diff #365069)

Also, I'd like to see some discussion (here, and then in the commit message) about why __synth_three_way does not need to be a lambda object the way it's shown in the Standard. I suspect that since it's used for partly-program-defined types like std::pair<int, Holder<Incomplete>*>, the reason may have to do with suppressing ADL... although, no, that doesn't make sense, because we're doing ADL on __t < __u on lines 28 and 35 already.

Okay, I'm not 100% sure what the mechanical corner cases are here. However, since it is a "fake" function that I am only defining a common implementation of here so that it can be re-used in {tuple, list, array, vector, set, map, deque, ...}, I feel that the closer we can get to direct usage of the exact definition we have written here the better. Any observable way in which its lookup is a real process that can be observed is a negative. I felt that perhaps regular functions provide a more familiar way to do this, but I am less sure now and at this pass am more confident than I was the first time that templated lambdas are definitely available.

In the first version I have a suspicion that it is guaranteed to work despite ADL shenanigans because it first speaks of __synth_three_way_result, which refers to __synth_three_way in its same block. For now I'll both prepend _VSTD:: in pair.h and revert it to a lambda which I feel more confident about.

26 ↗

(On Diff #365069)

...
However, https://eel.is/c++draft/expos.only.func gives a reference implementation which is noexcept(false). Therefore, at least arguably (and maybe more than arguably), it would be detectably non-conforming to add noexcept(~~~) here.

Yes, I'm unable to locate any place where synth-three-way needs to be noexcept; as far as I'm aware, every standard function that uses this mechanism is noexcept(false), and the expository definition of synth-three-way is also noexcept(false).

[mumbleskates]

libcxx/include/__utility/pair.h

332–333

It's true that the NaN tests do not cause the old code to fail, but I have rewritten it to match the standard anyway as requested.

libcxx/test/libcxx/compare/synthesized.pass.cpp

21 ↗

(On Diff #365069)

Are the UNSUPPORTED comment annotations programmatically processed? It's not completely clear to me if the comment has effect or is conventional. I'll delete these guards assuming you mean that it has effect.

34 ↗

(On Diff #365069)

Having a cast operator to std::weak_ordering is totally insufficient for an ordering; you also have to totally satisfy that comparison against the comparison-unspecified-zero argument type is boolean-testable for all comparison operators, otherwise it fails to satisfy the concept.

Not only that, the concept requires that the above is satisfied, and that the result type of the three way comparison is understood by std::common_comparison_category, which only knows about std::partial_ordering, std::weak_ordering, and std::strong_ordering. The most rigorous attempt I have made to produce a new comparison category either fails to be recognized due to the above and falls back to rewritten comparisons using the custom three way return type (which works! the type is, so to speak, on the council but not granted the rank of master) or is IFNDR.

I've added a test for types that define a valid operator<=> but are lacking operator==.

[mumbleskates]

Always gate synth-three-way on concepts

[mumbleskates]

Include __compare/ordering.h in non-review code and include __compare/synth_three_way.h in <compare> to solve module errors

[mumbleskates]

Actually don't include synth_three_way in <compare>; instead include the functionality for testing from where it is officially exposed

[mumbleskates]

rebase

[mumbleskates]

• modularization fixes in non-review code

[mumbleskates]

• misc. updates from feedback
• rebase

[cjdb]

I've just noticed the commit rename: [P1614] only holds meaning to folks who know what the proposal number corresponds to, and it also means that we can only search history for patches related to P1614, rather than the effort. What we do for ranges is this:

[libcxx][ranges] commit summary

Long commit message

Implements part of P1614 '<paper title>'.

Would you mind doing the same here please? I think a good tag would be [comparison] or [spaceship].

[mumbleskates]

• add signed/unsigned comparison tests for synth-three-way

[mumbleskates]

• rebase

[mumbleskates]

• rebase

[• Quuxplusone]

LGTM modulo testing comments, which I think are easy to address.

libcxx/include/__utility/pair.h

315

Before this line, I'd appreciate the addition of a comment line just for ease of comparing against the Standard:

// [pairs.spec], specialized algorithms

libcxx/include/utility

107

Nit: I think // C++20 is indented by 4 too many spaces.
I'd also cuddle the angle-brackets >> on line 106.

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

13

This isn't particularly close to the actual declaration of synth-three-way. Personally I'd just write

// constexpr auto __synth_three_way = ...;

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

48–56

How about:

using P = std::pair<int, double>;
using nan = std::numeric_limits<double>::quiet_NaN();
ASSERT_SAME_TYPE(decltype(P() <=> P()), std::partial_ordering);
assert((P(1, 1.0) <=> P(1, 2.0)) == std::partial_ordering::less);
assert((P(1, 1.0) <=> P(1, 1.0)) == std::partial_ordering::equivalent);
assert((P(1, -0.0) <=> P(1, 0.0)) == std::partial_ordering::equivalent);
assert((P(1, 2.0) <=> P(1, 1.0)) == std::partial_ordering::greater);
assert((P(1, nan) <=> P(2, nan)) == std::partial_ordering::less);  // because 1 < 2
assert((P(2, nan) <=> P(1, nan)) == std::partial_ordering::greater);  // because 2 > 1
assert((P(1, nan) <=> P(1, nan)) == std::partial_ordering::unordered);
assert((P(1, nan) <=> P(1, 1.0)) == std::partial_ordering::unordered);

And then finally I think we should have a SFINAE test, basically like this (IIUC):

template<class T> concept HasEqual = requires(T t) { t == t; };
template<class T> concept HasLess = requires(T t) { t < t; };
template<class T> concept HasSpaceship = requires(T t) { t <=> t; };

struct NoCompare {};
static_assert(HasEqual<std::pair<int, NoCompare>>);
static_assert(!HasLess<std::pair<int, NoCompare>>);
static_assert(!HasSpaceship<std::pair<int, NoCompare>>);

This SFINAE behavior is a bit bizarre, but it's Standard-conforming IIUC: (p == p) is well-formed, it's just going to hard-error if you actually evaluate it.

[mumbleskates]

• refactor three way comparison test for pair
• comment nits

libcxx/include/utility

107

Nit: I think // C++20 is indented by 4 too many spaces.

It's aligned perfectly with the other comparison operators above it for me. There are no tabs in this file, and dedenting it by 4 doesn't line it up with anything so I'm not sure what you're seeing.

I'd also cuddle the angle-brackets >> on line 106.

Done.

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

48–56

assert((P(1, nan) <=> P(1, 1.0)) == std::partial_ordering::unordered);

This cannot be evaluated constexpr by GCC, and needs its own non-constexpr-only function. As this is annoying and doesn't particularly add any information that we don't already get by comparing NaN <=> NaN to get unordered, I've been leaving these cases out. (GCC rules that A @ B can't be evaluated constexpr if only one of the operands is NaN; there are similar rules for inf.)

This SFINAE behavior is a bit bizarre, but it's Standard-conforming IIUC: (p == p) is well-formed, it's just going to hard-error if you actually evaluate it.

Would it be better to define operator== in NoCompare to make this less strange? How about this, which achieves the same end but is less weird:

struct NoRelative {
  constexpr bool operator==(const NoRelative&) const = default;
};
static_assert(HasEqual<std::pair<int, NoRelative>>);
static_assert(!HasLess<std::pair<int, NoRelative>>);
static_assert(!HasSpaceship<std::pair<int, NoRelative>>);

[mumbleskates]

There's a CI failure but it looks like an unrelated flake.

[• Quuxplusone]

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

48–56

This cannot be evaluated constexpr by GCC, and needs its own non-constexpr-only function. As this is annoying and doesn't particularly add any information that we don't already get by comparing NaN <=> NaN to get unordered, I've been leaving these cases out. (GCC rules that A @ B can't be evaluated constexpr if only one of the operands is NaN; there are similar rules for inf.)

Well, that's weird of GCC. I'm still weakly in favor of including these test cases — hiding the GCC-failing ones under #ifdef __clang__ or if (!std::is_constant_evaluated()) or XFAIL: gcc or whatever — but I don't think it's blocking.
I do ask that you adopt my spelling of nan in the tests, even if you delete some of the nan-related lines. The current PR's lines 58-63 are pretty hard to read. (Also, )<=> should be ) <=>; but that'll be more obvious once the numeric_limits cruft is reduced.)

I've just realized that I missed an important test case:

assert((P(nan, 1) <=> P(nan, 2)) == std::partial_ordering::unordered);

This shows that when the .first comparison is unordered, we do not go on to tiebreak using the .second.

How about this, which achieves the same end but is less weird

Sounds good to me. Just, you don't need a definition of the function in order to test the concepts. A declaration will suffice:

struct NoRelative {
  bool operator==(const NoRelative&) const;
};
static_assert(HasEqual<std::pair<int, NoRelative>>);
static_assert(!HasLess<std::pair<int, NoRelative>>);
static_assert(!HasSpaceship<std::pair<int, NoRelative>>);

Perhaps even add >:

struct NoRelative {
  bool operator==(const NoRelative&) const;
  bool operator>(const NoRelative&) const;
};
static_assert(HasEqual<std::pair<int, NoRelative>>);
static_assert(!HasLess<std::pair<int, NoRelative>>);
static_assert(!HasSpaceship<std::pair<int, NoRelative>>);

[mumbleskates]

• more test updates

[mumbleskates]

Also revised the synth_three_way.pass test with similar improvements.

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

48–56

I do ask that you adopt my spelling of nan in the tests, even if you delete some of the nan-related lines.

Your spelling with using does not work at all because quiet_NaN is a function, not a type; it seems it works just fine with constexpr double nan = ...; though.

Perhaps even add >

I added a second test for that one as well, which seems fine to me.

[Mordante]

LGTM, modulo two small formatting issues. Also a suggestion to improve the tests on non GCC platforms.

libcxx/include/__utility/pair.h

334

Please place return __c; on a new line. Not sure whether this contradicts @cjdb's comment, but in libc++ we normally don't put an if and a return on one line.

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

16

We normally start with this line, can you move it above // <utility>?

97

How do you feel about this work-around and move these two tests back in test()?
When you do that make sure to start a CI run before committing.

[mumbleskates]

• gate gcc tests on TEST_COMPILER_GCC and is_constant_evaluated

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

16

That hasn't been my observation, all the adjacent tests (for tuple, for example) already have this line at the end where it is here. I put it where it is to match surrounding code. Grepping around the rest of the project shows no consistency at all in its placement so I'd like to prefer just matching the adjacent files.

97

Yeah that looks good, I'll make the change.

[mumbleskates]

libcxx/include/__utility/pair.h

334

Yes this was written to be spelled exactly as it appears in the standard, so that does contradict.

[mumbleskates]

libcxx/include/__utility/pair.h

334

Reference: https://eel.is/c++draft/pairs.spec#2

[ldionne]

libcxx/include/__compare/synth_three_way.h

29

I believe this needs to be _LIBCPP_HIDE_FROM_ABI inline. The inline is to avoid ODR violations (we're defining a global in a header!) and the _LIBCPP_HIDE_FROM_ABI is to avoid the symbol leaking into the ABI of clients (inline variables result in weak defs being exported from programs that use them, which is pretty bad).

I don't have enough time to investigate the details right now but I could do that tomorrow.

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

2

If we remove libcxx/test/libcxx/library/description/conventions/expos.only.func/synth_three_way.pass.cpp, do we lose any coverage? (I assume the answer is yes). If so, is it possible to add that test coverage in libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp without mentioning implementation details of libc++ instead?

In libc++, we've historically written tests using only what the Standard mentions, and libcxx/test/libcxx is typically for testing libc++ specific behavior, but not for testing libc++ implementation details (we don't generally test those, or if we do, we still aim for 100% test coverage of the standard facility).

[mumbleskates]

libcxx/include/__compare/synth_three_way.h

29

It appears to work just fine if the lambda is defined as _LIBCPP_HIDE_FROM_ABI inline constexpr auto __synth_three_way = []<... but it's not completely clear to me what effect this has.

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

2

I think synth-three-way is pretty well "mentioned" in the spec, and its behavior pretty thoroughly described there; I would argue that the only "implementation detail" we are depending on here is what the functor is actually named.

I can see an argument for moving the synth-three-way test out of test/libcxx/library and into test/std somewhere, that would be fine. It's my personal preference to test the minutiae of how synth-three-way actually behaves in that file, and to test that usages of the functor in the publicly exposed standards fall back on it correctly without worrying about every possible corner case.

Is there a good way to determine coverage as you mentioned? Does this include conditions in templates and SFINAE testing? The concept of "coverage" here is pretty complex.

[• Quuxplusone]

libcxx/include/__compare/synth_three_way.h

29

constexpr globals, like const globals, are "implicitly static by default." So inline is observable for public STL globals like std::nullopt, because you can say things like

void print_address() { printf("%p\n", (void*)&std::nullopt); }

and it needs to come out to the same address in every translation unit.
For internal implementation details like __synth_three_way, I cannot think of any way that the difference between (implicitly static) and (explicitly inline) could be observed by the user... but, if the library itself were to use __synth_three_way inside another inline function like

inline void some_other_library_thing() { ~~~ __synth_three_way(...) ~~~ }

then that would technically be an ODR violation, because the two different definitions of inline void some_other_library_thing() would end up referring to different internal-linkage __synth_three_ways, and that's an ODR violation. So yes, inline constexpr SGTM.

I don't really understand _LIBCPP_HIDE_FROM_ABI either, but we put it on everything, so, it's a good idea. ;)

libcxx/include/__utility/pair.h

315

You added the comment line on 323, but I think it should be moved upward to ~line 312. operator== is also part of [pairs.spec].

334

FWIW, I would also prefer to see the return on its own line. I don't think "spell it exactly as in the standard" means "all the way down to the whitespace."

[• Quuxplusone]

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

112–113

Here and throughout: for consistency with elsewhere in the test suite,

test();
static_assert(test());

[mumbleskates]

• address comments

libcxx/include/__compare/synth_three_way.h

29

Cool that makes sense. I wasn't really thinking about it in terms of a value but I guess it technically could have an address in an unoptimized build and it's better to just avoid that.

libcxx/include/__utility/pair.h

315

Oh good call, I forgot about that.

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

2

I do want to clean this up and address this better if we want to figure out a consistent ground rule to base the tests on, including a full list of what behaviors need to be tested where and making sure they all get covered somewhere. There are at least 8 more places other than pair where synth-three-way is used so I want to make sure we're testing the right surface without introducing too much fragility if we find new cases that need fixing in the future. However this might be best suited for a follow-up diff.

[Mordante]

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

16

Guess I've been looking at other files, but if this matches the local style it's fine by me.

[ldionne]

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

16

We are (unfortunately) pretty inconsistent about how we do this in the library right now -- that's been my observation since I started working on it.

[Mordante]

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

16

IMO unless we have tooling to aid us it's very hard to get consistency. (Not that should stop us from trying to be consistent.)

[mumbleskates]

libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp

16

agreed

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,|In Progress|
+| `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,|In Progress|
+| `[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|
 "| `[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|

libcxx/include/CMakeLists.txt

set(files
   __bsd_locale_defaults.h
   __bsd_locale_fallbacks.h
   __charconv/chars_format.h
   __charconv/from_chars_result.h
   __charconv/to_chars_result.h
   __compare/common_comparison_category.h
   __compare/compare_three_way_result.h
   __compare/ordering.h
+  __compare/synth_three_way.h
   __compare/three_way_comparable.h
   __concepts/arithmetic.h
   __concepts/assignable.h
   __concepts/boolean_testable.h
   __concepts/class_or_enum.h
   __concepts/common_reference_with.h
   __concepts/common_with.h
   __concepts/constructible.h

libcxx/include/__compare/synth_three_way.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___COMPARE_SYNTH_THREE_WAY_H
+#define _LIBCPP___COMPARE_SYNTH_THREE_WAY_H
+
+#include <__config>
+#include <__compare/ordering.h>
+#include <__compare/three_way_comparable.h>
+#include <__concepts/boolean_testable.h>
+#include <__utility/declval.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+// [expos.only.func]
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr auto __synth_three_way =
+  []<class _Tp, class _Up>(const _Tp& __t, const _Up& __u)
+    requires requires {
+      { __t < __u } -> __boolean_testable;
+      { __u < __t } -> __boolean_testable;
+    }
+  {
+    if constexpr (three_way_comparable_with<_Tp, _Up>) {
+      return __t <=> __u;
+    } else {
+      if (__t < __u) return weak_ordering::less;
+      if (__u < __t) return weak_ordering::greater;
+      return weak_ordering::equivalent;
+    }
+  };
+
+template <class _Tp, class _Up = _Tp>
+using __synth_three_way_result = decltype(__synth_three_way(declval<_Tp&>(), declval<_Up&>()));
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___COMPARE_SYNTH_THREE_WAY_H

libcxx/include/__utility/pair.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___UTILITY_PAIR_H
 #define _LIBCPP___UTILITY_PAIR_H
 
+#include <__compare/common_comparison_category.h>
+#include <__compare/synth_three_way.h>
 #include <__config>
 #include <__functional/unwrap_ref.h>
 #include <__tuple>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/piecewise_construct.h>
 #include <cstddef>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

 #endif
 };
 
 #if _LIBCPP_STD_VER >= 17
 template<class _T1, class _T2>
 pair(_T1, _T2) -> pair<_T1, _T2>;
 #endif
 
+// [pairs.spec], specialized algorithms
+
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
 {
     return __x.first == __y.first && __x.second == __y.second;
 }
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+template <class _T1, class _T2>
+_LIBCPP_HIDE_FROM_ABI constexpr
+common_comparison_category_t<
+        __synth_three_way_result<_T1>,
+        __synth_three_way_result<_T2> >
+operator<=>(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
+{
+    if (auto __c = _VSTD::__synth_three_way(__x.first, __y.first); __c != 0) {
+      return __c;
+    }
+    return _VSTD::__synth_three_way(__x.second, __y.second);
+}
+
+#else // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
 {
     return !(__x == __y);
 }
 

 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
 {
     return !(__y < __x);
 }
 
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     __is_swappable<_T1>::value &&
     __is_swappable<_T2>::value,
     void
 >::type

libcxx/include/module.modulemap

module std [system] {
   module compare {
     header "compare"
     export *
 
     module __compare {
       module common_comparison_category { private header "__compare/common_comparison_category.h" }
       module compare_three_way_result   { private header "__compare/compare_three_way_result.h"   }
       module ordering                   { private header "__compare/ordering.h"                   }
+      module synth_three_way            { private header "__compare/synth_three_way.h"            }
       module three_way_comparable       { private header "__compare/three_way_comparable.h"       }
     }
   }
   module complex {
     header "complex"
     export *
   }
   module concepts {

libcxx/include/utility

pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value &&
                                        is_nothrow_move_assignable<T2>::value);   // constexpr in C++20
     template <class U, class V> pair& operator=(pair<U, V>&& p);                 // constexpr in C++20
 
     void swap(pair& p) noexcept(is_nothrow_swappable_v<T1> &&
                                 is_nothrow_swappable_v<T2>);                     // constexpr in C++20
 };
 
 template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
-template <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
-template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
-template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
-template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
-template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
+template <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
+template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
+template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
+template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
+template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
+template <class T1, class T2>
+  constexpr common_comparison_type_t<synth-three-way-result<T1>,
+                                     synth-three-way-result<T2>>
+    operator<=>(const pair<T1,T2>&, const pair<T1,T2>&);                               // C++20
 
 template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&);                // constexpr in C++14
 template <class T1, class T2>
 void
 swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));            // constexpr in C++20
 
 struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
 inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();

libcxx/test/libcxx/diagnostics/detail.headers/compare/synth_three_way.module.verify.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__compare/synth_three_way.h'}}
+#include <__compare/synth_three_way.h>

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/utilities/utility/pairs/pairs.spec/three_way_comparison.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
+//
+//===----------------------------------------------------------------------===//
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+
+// template <class T1, class T2> bool operator<=>(const pair<T1,T2>&, const pair<T1,T2>&);
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, libcpp-no-concepts
+
+#include <cassert>
+#include <compare>
+#include <limits>
+#include <type_traits> // std::is_constant_evaluated
+#include <utility>
+
+#include "test_macros.h"
+
+template<class T> concept HasEqual = requires(T t) { t == t; };
+template<class T> concept HasLess = requires(T t) { t < t; };
+template<class T> concept HasSpaceship = requires(T t) { t <=> t; };
+
+constexpr bool test() {
+  {
+    // Pairs of types that both have strong ordering should compare with strong ordering.
+    using P = std::pair<int, int>;
+    ASSERT_SAME_TYPE(decltype(P() <=> P()), std::strong_ordering);
+    assert((P(1, 1) <=> P(1, 2)) == std::strong_ordering::less);
+    assert((P(2, 1) <=> P(1, 2)) == std::strong_ordering::greater);
+    assert((P(0, 0) <=> P(0, 0)) == std::strong_ordering::equal);
+  }
+  {
+    // Pairs of int and a type with no spaceship operator should compare with weak ordering.
+    struct NoSpaceship {
+      int value;
+      constexpr bool operator==(const NoSpaceship&) const = default;
+      constexpr bool operator<(const NoSpaceship& other) const { return value < other.value; }
+    };
+    using P = std::pair<int, NoSpaceship>;
+    ASSERT_SAME_TYPE(decltype(P() <=> P()), std::weak_ordering);
+    assert((P(1, {1}) <=> P(1, {2})) == std::weak_ordering::less);
+    assert((P(2, {1}) <=> P(1, {2})) == std::weak_ordering::greater);
+    assert((P(0, {0}) <=> P(0, {0})) == std::weak_ordering::equivalent);
+  }
+  {
+    // Pairs of int (strongly ordered) and double (partially ordered) should compare with partial ordering.
+    using P = std::pair<int, double>;
+    constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+    ASSERT_SAME_TYPE(decltype(P() <=> P()), std::partial_ordering);
+    assert((P(1, 1.0) <=> P(1, 2.0)) == std::partial_ordering::less);
+    assert((P(1, 1.0) <=> P(1, 1.0)) == std::partial_ordering::equivalent);
+    assert((P(1, -0.0) <=> P(1, 0.0)) == std::partial_ordering::equivalent);
+    assert((P(1, 2.0) <=> P(1, 1.0)) == std::partial_ordering::greater);
+    assert((P(1, nan) <=> P(2, nan)) == std::partial_ordering::less);
+    assert((P(2, nan) <=> P(1, nan)) == std::partial_ordering::greater);
+    assert((P(1, nan) <=> P(1, nan)) == std::partial_ordering::unordered);
+  }
+  {
+    using P = std::pair<double, int>;
+    constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+    ASSERT_SAME_TYPE(decltype(P() <=> P()), std::partial_ordering);
+    assert((P(2.0, 1) <=> P(1.0, 2)) == std::partial_ordering::greater);
+    assert((P(1.0, 1) <=> P(1.0, 2)) == std::partial_ordering::less);
+    assert((P(nan, 1) <=> P(nan, 2)) == std::partial_ordering::unordered);
+  }
+  {
+    struct NoRelative {
+      constexpr bool operator==(const NoRelative&) const;
+    };
+    static_assert(HasEqual<std::pair<int, NoRelative>>);
+    static_assert(!HasLess<std::pair<int, NoRelative>>);
+    static_assert(!HasSpaceship<std::pair<int, NoRelative>>);
+  }
+  {
+    struct NoLessThan {
+      constexpr bool operator==(const NoLessThan&) const;
+      constexpr bool operator>(const NoLessThan&) const;
+    };
+    static_assert(HasEqual<std::pair<int, NoLessThan>>);
+    static_assert(!HasLess<std::pair<int, NoLessThan>>);
+    static_assert(!HasSpaceship<std::pair<int, NoLessThan>>);
+  }
+
+#ifdef TEST_COMPILER_GCC
+  // GCC cannot evaluate NaN @ non-NaN constexpr, so test that runtime-only.
+  if (!std::is_constant_evaluated())
+#endif
+  {
+    {
+      using P = std::pair<int, double>;
+      constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+      assert((P(1, 2.0) <=> P(1, nan)) == std::partial_ordering::unordered);
+    }
+    {
+      using P = std::pair<double, int>;
+      constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+      assert((P(1.0, 1) <=> P(nan, 2)) == std::partial_ordering::unordered);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}