[libc++][compare] Implement three_way_comparable[_with] concepts

[rarutyun]

Summary

Implementation of three_way_comparable and three_way_comparable_with concepts from <compare> header.

Please note that I have temporarily removed <compare> header from <utility> due to cyclic dependency that prevents using <concepts> header in <compare> one.

I tried to quickly resolve those issues including applying suggestions from @cjdb and dive deeper by myself but the problem seems more complicated that we thought initially.

I am in progress to prepare the patch with resolving this cyclic dependency between headers but for now I decided to put all that I have to the review to unblock people that depend on that functionality. At first glance the patch with resolving cyclic dependency is not so small (unless I find the way to make it smaller and cleaner) so I don't want to mix everything to one review.

[cjdb]

Thanks for working on this. To get an LGTM, please add test types for the following:

• A type where operator<=> isn't declared.
• A type where operator<=> is deleted.
• A type where operator<=> is declared and operator== isn't.
• A type where operator== is deleted.
• A type where all the inequality operators are defined.
• A type where all but one of the inequality operators are declared.
• A type where all but one of the inequality operators are declared, and the missing one is deleted.

PTAL at the totally_ordered and totally_ordered_with tests for inspiration.

libcxx/test/libcxx/inclusions/utility.inclusions.compile.pass.cpp

25–27

Please fix this before merging (same as above).

[• Quuxplusone]

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable.compile.pass.cpp

68

As usual, I don't think it's important to have hundreds of lines of similar/redundant test cases, and I do think it's important to have simple test cases for the corner cases:

• What if the type provides <=> but no viable ==? And vice versa?
• What if the type provides <=> with a non-comparison-category return type, such as int?
• What if the type provides == with a non-boolean return type, such as int? such as void?
• What if the type provides <=> but it works only on non-const objects?
• What if the type provides all six C++17 comparison operators but no C++20 <=>?

etc.

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp

77–80

Nit: Please avoid taking clang-format's advice in cases like this where it's clearly making the formatting worse.
Instead, try treating a clang-format diagnostic as a helpful hint that your lines may be too long. E.g. in this case you don't really need to test a const volatile noexcept abominable function type, right? This test clearly could be rewritten as static_assert(!check_three_way_comparable_with<int, int*>()) (or any similar pair of types; the only important thing here is that the expression a == b would be ill-formed).
Renaming check_three_way_comparable_with to simply check is another good way to improve the readability of this test file while also helping to make clang-format happy.

[cjdb]

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable.compile.pass.cpp

68

As usual, the number of tests here are to ensure that all the sharp objects C++ has to offer are checked. I'll say it once again: concepts are a very new feature, and are relatively untested. Our spaceship operator is a a very new feature, and is relatively untested. As far as I'm aware, LLVM has zero other tests that check these two features interact. These tests ensure that nothing has been accidentally overlooked, and are a cheap way for the whole LLVM project to ensure everything is working as intended.

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp

77–80

I'm sure @rarutyun's employer doesn't pay them to spend time overriding clang-format.

[Mordante]

Thanks for working on this.

libcxx/include/compare

487

We typically omit the 'exposition only' comment here.
Can you also update the synopsis with the newly added code. When copying please make sure to remove non-ASCII characters. (The invisible hyphens come to mind.)

494

Please use __ugly_names: a -> __a, b -> __b.

507

Also __ugly_names here.

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable.compile.pass.cpp

30

char8_t isn't available on all platforms, please guard with #ifnef _LIBCPP_HAS_NO_CHAR8_T.

32

Likewise for char16_t and char32_t using #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS

36

To be complete it would be nice to test __int128_t. This should be guarded with #ifndef _LIBCPP_HAS_NO_INT128. __uin128_t uses the same guard.

68

I also like the verbose testing in this case since it's a new feature. I would like to reduce the amount of redundancy, All types here have basically the same three tests

// with default ordering
static_assert(std::three_way_comparable<T>);

// with explicit ordering
static_assert(std::three_way_comparable<T, std::strong_ordering>);
static_assert(std::three_way_comparable<T, std::weak_ordering>);

Can we move this to a template helper function?

[zoecarver]

libcxx/include/compare

494

__make_const_lvalue_ref should take care of making this a reference type (i.e., you can remove the "&").

507

Same comment as above.

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable.compile.pass.cpp

78

Do we really need to assert that all these types are not three way comparable? That seems a bit excessive to me (it would be one thing if they were three way comparable, but they're not-- if we use this philosophy for testing, we can have tests of infinite size).

111

Can we get a type where this operator is only available on rvalue references? I think that would currently pass, but should not.

[cjdb]

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable.compile.pass.cpp

78

Please see my comment above.

[Wmbat]

I would like to bring forward a potential change.

I was looking at how to implement compare_three_way and found out that it needs to be present in both <compare> and <functional> according to the standard draft ( <function> synopsis, <compare> synopsis ). It would mean that compare_three_way would need to be implemented in a different header and then included in both <compare> & <functional>, @cjdb recommends the use of a __compare/compare_three_way.h header

Since compare_three_way depends on the three_way_comparable_with concept ( see here ), we might also need to move three_way_comparable to __compare/compare_three_way.h as well. Doing so now might save us the refactor later down the line.

Any thoughts on this?

[• Quuxplusone]

I was looking at how to implement compare_three_way and found out that it needs to be present in both <compare> and <functional> according to the standard draft ( <function> synopsis, <compare> synopsis).

Sounds like someone should file an LWG issue. I'm not aware of any other library facilities that are listed multiple times in different places in the Standard. This might be a cut-and-paste error.

[tcanens]

In D103478#2794869, @Quuxplusone wrote:

I was looking at how to implement compare_three_way and found out that it needs to be present in both <compare> and <functional> according to the standard draft ( <function> synopsis, <compare> synopsis).

Sounds like someone should file an LWG issue. I'm not aware of any other library facilities that are listed multiple times in different places in the Standard. This might be a cut-and-paste error.

This is the new way to say "this thing is provided if you include either header": https://github.com/cplusplus/draft/issues/3683

It's very much intentional that compare_three_way is available if you include either <functional> or <compare>.

[Wmbat]

In D103478#2797854, @tcanens wrote:

In D103478#2794869, @Quuxplusone wrote:

I was looking at how to implement compare_three_way and found out that it needs to be present in both <compare> and <functional> according to the standard draft ( <function> synopsis, <compare> synopsis).

Sounds like someone should file an LWG issue. I'm not aware of any other library facilities that are listed multiple times in different places in the Standard. This might be a cut-and-paste error.

This is the new way to say "this thing is provided if you include either header": https://github.com/cplusplus/draft/issues/3683

It's very much intentional that compare_three_way is available if you include either <functional> or <compare>.

Then, my proposition stands. We would have to either make <functional> include all of <compare> or make a separate header that contains everything that compare_three_way needs and have it be included by both <compare> and <functional>

[cjdb]

Ping. @rarutyun this is blocking other work now; will you have time to work on this next week, or would you prefer I take over?

[rarutyun]

In D103478#2813673, @cjdb wrote:

Ping. @rarutyun this is blocking other work now; will you have time to work on this next week, or would you prefer I take over?

Hi,

Yes, next week is exactly my plan. For this week I have so many deadlines for internal work. But now they are all passed and I can get back to this patch and another one.

[rarutyun]

Partially apply comments. Others are in progress.

Will do my best to apply everything before next work week

[cjdb]

In D103478#2794860, @Wmbat wrote:

I would like to bring forward a potential change.

I was looking at how to implement compare_three_way and found out that it needs to be present in both <compare> and <functional> according to the standard draft ( <function> synopsis, <compare> synopsis ). It would mean that compare_three_way would need to be implemented in a different header and then included in both <compare> & <functional>, @cjdb recommends the use of a __compare/compare_three_way.h header

Since compare_three_way depends on the three_way_comparable_with concept ( see here ), we might also need to move three_way_comparable to __compare/compare_three_way.h as well. Doing so now might save us the refactor later down the line.

Any thoughts on this?

Please move the concepts into their own header and include it in <compare>. You might need to break some other stuff out into their own self-contained headers too.

[cjdb]

Ping @rarutyun, do you need assistance?

[rarutyun]

In D103478#2848944, @cjdb wrote:

Ping @rarutyun, do you need assistance?

I am sorry for the delay. I was on vacation. I don't think I need assistance so far. I am working hard on that patch this week. If I face some troubles I will definitely let you know.

Thanks for proposing the help.

[rarutyun]

In D103478#2834101, @cjdb wrote:

In D103478#2794860, @Wmbat wrote:

I would like to bring forward a potential change.

I was looking at how to implement compare_three_way and found out that it needs to be present in both <compare> and <functional> according to the standard draft ( <function> synopsis, <compare> synopsis ). It would mean that compare_three_way would need to be implemented in a different header and then included in both <compare> & <functional>, @cjdb recommends the use of a __compare/compare_three_way.h header

Since compare_three_way depends on the three_way_comparable_with concept ( see here ), we might also need to move three_way_comparable to __compare/compare_three_way.h as well. Doing so now might save us the refactor later down the line.

Any thoughts on this?

Please move the concepts into their own header and include it in <compare>. You might need to break some other stuff out into their own self-contained headers too.

Do you want me to make those APIs available from <functional> in this review?

libcxx/include/utility

216

Still struggling with cyclic dependencies.

[cjdb]

Please move your header split into a standalone NFC patch. I'll review it promptly over there.

[rarutyun]

In D103478#2872748, @cjdb wrote:

Please move your header split into a standalone NFC patch. I'll review it promptly over there.

Done. https://reviews.llvm.org/D106107

[mumbleskates]

This is probably unblocked now that D107584 has landed!

[rarutyun]

In D103478#2938752, @mumbleskates wrote:

This is probably unblocked now that D107584 has landed!

Thanks, will check today

[• Quuxplusone]

In D103478#2939873, @rarutyun wrote:

In D103478#2938752, @mumbleskates wrote:

This is probably unblocked now that D107584 has landed!

Thanks, will check today

Btw, @rarutyun, if you'd like me to commandeer and replace this PR with the relevant portion of D107036, I'd be happy to do that.

[rarutyun]

In D103478#2939873, @rarutyun wrote:

In D103478#2938752, @mumbleskates wrote:

This is probably unblocked now that D107584 has landed!

Thanks, will check today

Checked. Locally it works. Review has been updated.

[rarutyun]

In D103478#2940587, @Quuxplusone wrote:

In D103478#2939873, @rarutyun wrote:

In D103478#2938752, @mumbleskates wrote:

This is probably unblocked now that D107584 has landed!

Thanks, will check today

Btw, @rarutyun, if you'd like me to commandeer and replace this PR with the relevant portion of D107036, I'd be happy to do that.

Whatever works for you. You may say to me what should be applied.

[rarutyun]

Clang-format suggests incorrect modifications that fail to compile if applied. Could you please suggest the file to look at for the best practice how to turn it off? I could you dedicated comment for that but I am not sure that's how you guys are doing that.

[cjdb]

In D103478#2941860, @rarutyun wrote:

Clang-format suggests incorrect modifications that fail to compile if applied. Could you please suggest the file to look at for the best practice how to turn it off? I could you dedicated comment for that but I am not sure that's how you guys are doing that.

Run arc diff --nolint instead of arc diff.

[• Quuxplusone]

@rarutyun: I've marked the places where this is lacking bits you can take from D107036.
Re the testing issue, let's see what @ldionne wants.

libcxx/include/CMakeLists.txt

102 ↗

(On Diff #366037)

You'll also need to update module.modulemap and run the various Python generator scripts (which you can now do via ninja libcxx-generate-files or make libcxx-generate-files). Make sure to commit the changed and added new files.

libcxx/include/__compare/three_way_comparable.h

12–16 ↗

(On Diff #366037)

You're missing some IWYU here, e.g. same_as.h. You need to include these directly, for the benefit of the Modules build; it's not Modules-kosher to rely on the fact that totally_ordered.h happens to include same_as.h.
Check D107036 for the complete listing.

libcxx/include/compare

30–36

Right about here, please update the synopsis comment.
Check D107036 for the right thing.

124

a-z

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp

77–80

@rarutyun, you wrote:

Clang-format suggests incorrect modifications that fail to compile if applied.

For generating the diff to upload, I use git show -U999 > x.diff and then "Upload file" into the Phab review. I don't use arc at all in my personal workflow. I don't know if this will help you, but at least I personally spend zero time wrestling with arc; some amount of time wrestling with git instead; and zero time wrestling with clang-format because clang-format is completely unused in my git workflow.

Re Chris's snipe: Don't worry about clang-format. Just write the code the way you'd write it naturally, and then act on Phab feedback (if any) from human libc++ maintainers. clang-format isn't the boss here. :)

Also, note that a massive number of these 230+242 lines can disappear entirely. I tentatively recommend just taking my 101+147 lines of more targeted testing from D107036 (although let's see if @ldionne has a strong preference for these, or wants both, or what). Either way, please delete or fix the misformatting throughout this file.

[cjdb]

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp

77–80

Also, note that a massive number of these 230+242 lines can disappear entirely. I tentatively recommend just taking my 101+147 lines of more targeted testing from D107036 (although let's see if @ldionne has a strong preference for these, or wants both, or what). Either way, please delete or fix the misformatting throughout this file.

See https://reviews.llvm.org/D103478#inline-980152.

[• Quuxplusone]

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp

50

This specific line is failing on AArch64 and Arm. I suspect that those platforms have a 32-bit unsigned wchar_t, and so this line would be failing for the same reason that

static_assert(std::three_way_comparable<int, unsigned int>);

would fail. Therefore, the correct action is to remove this platform-dependent line (and lines 55 and 59 too). However, consider adding

static_assert(!std::three_way_comparable<int, unsigned int>);

as a sanity check; I think you're missing anything along those lines at the moment.

[• Quuxplusone]

libcxx/include/__compare/three_way_comparable.h

34–35 ↗

(On Diff #366037)

requires(__make_const_lvalue_ref<_Tp> __t) {
    { __t <=> __t } -> __compares_as<_Cat>;

Let's keep it simple (and close to the reference implementation).

44 ↗

(On Diff #366037)

Let's eliminate this linebreak.

[cjdb]

libcxx/include/__compare/three_way_comparable.h

27 ↗

(On Diff #366037)

This comment is unnecessary.

34–35 ↗

(On Diff #366037)

We shouldn't deviate from what's in the standard. The concept is defined the way it is way for a reason.

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp

50

Interesting. I'd prefer to section this test off using an include guard, if it's possible.

[rarutyun]

libcxx/include/CMakeLists.txt

102 ↗

(On Diff #366037)

Yep, I figured it out from CI results. Done

libcxx/include/__compare/three_way_comparable.h

34–35 ↗

(On Diff #366037)

Agree with Christopher

[• Quuxplusone]

LGTM % comments at this point.
I'm still unhappy with the testing story — >200 lines of "this kind of member function pointer isn't comparable, that kind of member function pointer isn't comparable..." — but since the code is correct, I'd rather land this as-is than continue with review.

libcxx/include/__compare/three_way_comparable.h

34–35 ↗

(On Diff #366037)

Ah, I see the reference implementation actually does use a and b; I must have simplified it on my end when I did D107036. Okay then.
(I do disagree that "the concept is defined the way it is for a reason"; it could have been done simpler without b, and had exactly the same semantics. But that's moot until someone files an editorial issue.)

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable.compile.pass.cpp

111

remove linebreak plz

229

} // namespace user_defined

231

Please remove the main function. For .compile.pass.cpp tests, which aren't intended to be run (just compiled), we've settled on making sure they don't have a main.

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp

50

Nah, just delete the bogus line.

122

} // namespace fundamentals
(and please fix the linebreaks throughout the above; thanks for taking care of the other file already)

241

} // namespace user_defined

243

and remove main

[• Quuxplusone]

@rarutyun anything blocking this? Do you need help landing it?

[rarutyun]

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp

77–80

Avoiding clang-format. Now everything is written in one line and I agree that it looks better. I would not want to rename check_three_way_comparable_with to just check because I believe that decreases readability but if you insist I may do that.

I am not sure about reducing tests. Seems like different people have different opinions on that. I would prefer to leave it as is unless you have strong objections.

[rarutyun]

In D103478#2951267, @Quuxplusone wrote:

@rarutyun anything blocking this? Do you need help landing it?

Review has been updated. Just was busy with other work.

[rarutyun]

Hi @cjdb @Quuxplusone. Any progress on this review?

I think I've addressed all important comments and the CI is green (except the clang format, which is not a boss here:) ).

[• Quuxplusone]

@rarutyun: Ship it!

[cjdb]

Also LGTM, but since I'm not a co-approver, we'll need to wait for either @ldionne's approval or a second co-approver.

libcxx/include/__compare/three_way_comparable.h

12–16 ↗

(On Diff #366037)

For future reference: running bin/llvm-lit -sv /path/to/llvm-project/libcxx/test/ --param enable_modules=True will catch this for you.

[rarutyun]

In D103478#2960589, @cjdb wrote:

Also LGTM, but since I'm not a co-approver, we'll need to wait for either @ldionne's approval or a second co-approver.

Ok, Waiting for another required approval.

By the way as you might remember I don't have direct access to merge the code directly.

I am putting my data here:

name: Ruslan Arutyunyan
email: [e-mail]

Please let me know if you want me to get the write access directly into the repository.

[ldionne]

I'll commit this. Thanks a lot for the patch.

[ldionne]

@rarutyun Can you please rebase this onto main, it doesn't apply cleanly?

[ldionne]

In D103478#2961333, @rarutyun wrote:

Please let me know if you want me to get the write access directly into the repository.

Yes, that would be useful!

[rarutyun]

In D103478#2965197, @ldionne wrote:

@rarutyun Can you please rebase this onto main, it doesn't apply cleanly?

@ldionne,

Sure, done.

[rarutyun]

Rebased one more time.

@cjdb, @Quuxplusone @ldionne, could somebody merge it please?

My data:
name: Ruslan Arutyunyan
email: [e-mail]

I will request the permissions for direct merge for the next commit if you don't mind.

[ldionne]

In D103478#2972085, @rarutyun wrote:

Rebased one more time.

@cjdb, @Quuxplusone @ldionne, could somebody merge it please?

My data:
name: Ruslan Arutyunyan
email: [e-mail]

I will request the permissions for direct merge for the next commit if you don't mind.

Yes, please do so. Thanks @mumbleskates for merging.

libcxx/include/compare

namespace std {
   // named comparison functions
   constexpr bool is_eq  (partial_ordering cmp) noexcept    { return cmp == 0; }
   constexpr bool is_neq (partial_ordering cmp) noexcept    { return cmp != 0; }
   constexpr bool is_lt  (partial_ordering cmp) noexcept { return cmp < 0; }
   constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp <= 0; }
   constexpr bool is_gt  (partial_ordering cmp) noexcept { return cmp > 0; }
   constexpr bool is_gteq(partial_ordering cmp) noexcept { return cmp >= 0; }
 
   // [cmp.common], common comparison category type
   template<class... Ts>
   struct common_comparison_category {
     using type = see below;
   };
   template<class... Ts>
     using common_comparison_category_t = typename common_comparison_category<Ts...>::type;
 
   // [cmp.alg], comparison algorithms
   template<class T> constexpr strong_ordering strong_order(const T& a, const T& b);
   template<class T> constexpr weak_ordering weak_order(const T& a, const T& b);
   template<class T> constexpr partial_ordering partial_order(const T& a, const T& b);
 
   // [cmp.partialord], Class partial_ordering
   class partial_ordering {
public:
     friend constexpr bool operator>=(unspecified, strong_ordering v) noexcept;
     friend constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept;
     friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
   };
 }
 */
 
 #include <__config>
+#include <concepts>
 #include <type_traits>
 
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

 using common_comparison_category_t = typename common_comparison_category<_Ts...>::type;
 
 // [cmp.alg], comparison algorithms
 // TODO: unimplemented
 template<class _Tp> constexpr strong_ordering strong_order(const _Tp& __lhs, const _Tp& __rhs);
 template<class _Tp> constexpr weak_ordering weak_order(const _Tp& __lhs, const _Tp& __rhs);
 template<class _Tp> constexpr partial_ordering partial_order(const _Tp& __lhs, const _Tp& __rhs);
 
+template<class _Tp, class _Cat>
+concept __compares_as =                 // exposition only
+  same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
+
+template<class _Tp, class _Cat = partial_ordering>
+concept three_way_comparable =
+  __weakly_equality_comparable_with<_Tp, _Tp> &&
+  __partially_ordered_with<_Tp, _Tp> &&
+  requires(__make_const_lvalue_ref<_Tp> __a, __make_const_lvalue_ref<_Tp> __b) {
+    { __a <=> __b } -> __compares_as<_Cat>;
+  };
+
+template<class _Tp, class _Up, class _Cat = partial_ordering>
+concept three_way_comparable_with =
+  three_way_comparable<_Tp, _Cat> &&
+  three_way_comparable<_Up, _Cat> &&
+  common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
+  three_way_comparable<
+    common_reference_t<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>, _Cat> &&
+  __weakly_equality_comparable_with<_Tp, _Up> &&
+  __partially_ordered_with<_Tp, _Up> &&
+  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
+    { __t <=> __u } -> __compares_as<_Cat>;
+    { __u <=> __t } -> __compares_as<_Cat>;
+  };
+
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_COMPARE

libcxx/include/utility

 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__tuple>
 #include <__utility/to_underlying.h>
-#include <compare>
+// FIXME (rarutyun): return back <compare> include when
+//                   cyclic dependency for this header is resolved
+// #include <compare>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <initializer_list>
 #include <limits>
 #include <type_traits>
 #include <version>
 

libcxx/test/libcxx/inclusions/utility.inclusions.compile.pass.cpp

 
 #include <utility>
 #include "test_macros.h"
 
 #if !defined(_LIBCPP_UTILITY)
  #   error "<utility> was expected to define _LIBCPP_UTILITY"
 #endif
 #if TEST_STD_VER > 17 && !defined(_LIBCPP_COMPARE)
- #   error "<utility> should include <compare> in C++20 and later"
+// FIXME (rarutyun): enable this test part when cyclic dependency for
+// <compare> header is resolved
+//  #   error "<utility> should include <compare> in C++20 and later"
 #endif
 #if TEST_STD_VER > 03 && !defined(_LIBCPP_INITIALIZER_LIST)
  #   error "<utility> should include <initializer_list> in C++11 and later"
 #endif

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T, class Cat = partial_ordering>
+// concept three_way_comparable = // see below
+
+#include <compare>
+
+#include "compare_types.h"
+
+namespace fundamentals {
+// with default ordering
+static_assert(std::three_way_comparable<int>);
+static_assert(std::three_way_comparable<double>);
+static_assert(std::three_way_comparable<void*>);
+static_assert(std::three_way_comparable<char*>);
+static_assert(std::three_way_comparable<char const*>);
+static_assert(std::three_way_comparable<char volatile*>);
+static_assert(std::three_way_comparable<char const volatile*>);
+static_assert(std::three_way_comparable<wchar_t&>);
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+static_assert(std::three_way_comparable<char8_t const&>);
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+static_assert(std::three_way_comparable<char16_t volatile&>);
+static_assert(std::three_way_comparable<char32_t const volatile&>);
+#endif
+#ifndef _LIBCPP_HAS_NO_INT128
+static_assert(std::three_way_comparable<__int128_t const&>);
+static_assert(std::three_way_comparable<__uint128_t const&>);
+#endif
+static_assert(std::three_way_comparable<unsigned char&&>);
+static_assert(std::three_way_comparable<unsigned short const&&>);
+static_assert(std::three_way_comparable<unsigned int volatile&&>);
+static_assert(std::three_way_comparable<unsigned long const volatile&&>);
+
+// with explicit ordering
+static_assert(std::three_way_comparable<int, std::strong_ordering>);
+static_assert(std::three_way_comparable<int, std::weak_ordering>);
+static_assert(std::three_way_comparable<double, std::partial_ordering>);
+static_assert(!std::three_way_comparable<double, std::weak_ordering>);
+static_assert(std::three_way_comparable<void*, std::strong_ordering>);
+static_assert(std::three_way_comparable<void*, std::weak_ordering>);
+static_assert(std::three_way_comparable<char*, std::strong_ordering>);
+static_assert(std::three_way_comparable<char*, std::weak_ordering>);
+static_assert(std::three_way_comparable<char const*, std::strong_ordering>);
+static_assert(std::three_way_comparable<char const*, std::weak_ordering>);
+static_assert(std::three_way_comparable<char volatile*, std::strong_ordering>);
+static_assert(std::three_way_comparable<char volatile*, std::weak_ordering>);
+static_assert(std::three_way_comparable<char const volatile*, std::strong_ordering>);
+static_assert(std::three_way_comparable<char const volatile*, std::weak_ordering>);
+static_assert(std::three_way_comparable<wchar_t&, std::strong_ordering>);
+static_assert(std::three_way_comparable<wchar_t&, std::weak_ordering>);
+static_assert(std::three_way_comparable<char8_t const&, std::strong_ordering>);
+static_assert(std::three_way_comparable<char8_t const&, std::weak_ordering>);
+static_assert(std::three_way_comparable<char16_t volatile&, std::strong_ordering>);
+static_assert(std::three_way_comparable<char16_t volatile&, std::weak_ordering>);
+static_assert(std::three_way_comparable<char32_t const volatile&, std::strong_ordering>);
+static_assert(std::three_way_comparable<char32_t const volatile&, std::weak_ordering>);
+static_assert(std::three_way_comparable<unsigned char&&, std::strong_ordering>);
+static_assert(std::three_way_comparable<unsigned char&&, std::weak_ordering>);
+static_assert(std::three_way_comparable<unsigned short const&&, std::strong_ordering>);
+static_assert(std::three_way_comparable<unsigned short const&&, std::weak_ordering>);
+static_assert(std::three_way_comparable<unsigned int volatile&&, std::strong_ordering>);
+static_assert(std::three_way_comparable<unsigned int volatile&&, std::weak_ordering>);
+static_assert(std::three_way_comparable<unsigned long const volatile&&, std::strong_ordering>);
+static_assert(std::three_way_comparable<unsigned long const volatile&&, std::weak_ordering>);
+
+static_assert(!std::three_way_comparable<int[5]>);
+static_assert(!std::three_way_comparable<int (*)(int)>);
+static_assert(!std::three_way_comparable<int (&)(int)>);
+static_assert(!std::three_way_comparable<int (*)(int) noexcept>);
+static_assert(!std::three_way_comparable<int (&)(int) noexcept>);
+static_assert(!std::three_way_comparable<std::nullptr_t>);
+
+struct S {};
+static_assert(!std::three_way_comparable<int S::*>);
+static_assert(!std::three_way_comparable<int (S::*)()>);
+static_assert(!std::three_way_comparable<int (S::*)() noexcept>);
+static_assert(!std::three_way_comparable<int (S::*)() &>);
+static_assert(!std::three_way_comparable<int (S::*)() & noexcept>);
+static_assert(!std::three_way_comparable<int (S::*)() &&>);
+static_assert(!std::three_way_comparable<int (S::*)() && noexcept>);
+static_assert(!std::three_way_comparable<int (S::*)() const>);
+static_assert(!std::three_way_comparable<int (S::*)() const noexcept>);
+static_assert(!std::three_way_comparable<int (S::*)() const&>);
+static_assert(!std::three_way_comparable<int (S::*)() const & noexcept>);
+static_assert(!std::three_way_comparable<int (S::*)() const&&>);
+static_assert(!std::three_way_comparable<int (S::*)() const && noexcept>);
+static_assert(!std::three_way_comparable<int (S::*)() volatile>);
+static_assert(!std::three_way_comparable<int (S::*)() volatile noexcept>);
+static_assert(!std::three_way_comparable<int (S::*)() volatile&>);
+static_assert(!std::three_way_comparable<int (S::*)() volatile & noexcept>);
+static_assert(!std::three_way_comparable<int (S::*)() volatile&&>);
+static_assert(!std::three_way_comparable<int (S::*)() volatile && noexcept>);
+static_assert(!std::three_way_comparable<int (S::*)() const volatile>);
+static_assert(!std::three_way_comparable<int (S::*)() const volatile noexcept>);
+static_assert(!std::three_way_comparable<int (S::*)() const volatile&>);
+static_assert(!std::three_way_comparable<int (S::*)() const volatile & noexcept>);
+static_assert(!std::three_way_comparable<int (S::*)() const volatile&&>);
+static_assert(
+    !std::three_way_comparable<int (S::*)() const volatile && noexcept>);
+
+static_assert(!std::three_way_comparable<void>);
+} // namespace fundamentals
+
+namespace user_defined {
+
+struct S {
+    auto operator<=>(const S&) const = default;
+};
+
+static_assert(std::three_way_comparable<S>);
+static_assert(std::three_way_comparable<S, std::strong_ordering>);
+static_assert(std::three_way_comparable<S, std::partial_ordering>);
+
+struct SpaceshipNotDeclared {
+};
+
+static_assert(!std::three_way_comparable<SpaceshipNotDeclared>);
+
+struct SpaceshipDeleted {
+    auto operator<=>(const SpaceshipDeleted&) const = delete;
+};
+
+static_assert(!std::three_way_comparable<SpaceshipDeleted>);
+
+struct SpaceshipWithoutEqualityOperator {
+    auto operator<=>(const SpaceshipWithoutEqualityOperator&) const;
+};
+
+static_assert(!std::three_way_comparable<SpaceshipWithoutEqualityOperator>);
+
+struct EqualityOperatorDeleted {
+    bool operator==(const EqualityOperatorDeleted&) const = delete;
+};
+
+static_assert(!std::three_way_comparable<EqualityOperatorDeleted>);
+
+struct EqualityOperatorOnly {
+    bool operator==(const EqualityOperatorOnly&) const = default;
+};
+
+static_assert(!std::three_way_comparable<EqualityOperatorOnly>);
+
+struct SpaceshipDeclaredEqualityOperatorDeleted {
+    bool operator==(const SpaceshipDeclaredEqualityOperatorDeleted&) const = delete;
+    auto operator<=>(const SpaceshipDeclaredEqualityOperatorDeleted&) const = default;
+};
+
+static_assert(!std::three_way_comparable<SpaceshipDeclaredEqualityOperatorDeleted>);
+
+struct AllInequalityOperators {
+    bool operator<(const AllInequalityOperators&) const;
+    bool operator<=(const AllInequalityOperators&) const;
+    bool operator>(const AllInequalityOperators&) const;
+    bool operator>=(const AllInequalityOperators&) const;
+    bool operator!=(const AllInequalityOperators&) const;
+};
+
+static_assert(!std::three_way_comparable<AllInequalityOperators>);
+
+struct AllComparisonOperators {
+    bool operator<(const AllComparisonOperators&) const;
+    bool operator<=(const AllComparisonOperators&) const;
+    bool operator>(const AllComparisonOperators&) const;
+    bool operator>=(const AllComparisonOperators&) const;
+    bool operator!=(const AllComparisonOperators&) const;
+    bool operator==(const AllComparisonOperators&) const;
+};
+
+static_assert(!std::three_way_comparable<AllComparisonOperators>);
+
+struct AllButOneInequalityOperators {
+    bool operator<(const AllButOneInequalityOperators&) const;
+    bool operator<=(const AllButOneInequalityOperators&) const;
+    bool operator>(const AllButOneInequalityOperators&) const;
+    bool operator!=(const AllButOneInequalityOperators&) const;
+};
+
+static_assert(!std::three_way_comparable<AllButOneInequalityOperators>);
+
+struct AllInequalityOperatorsOneDeleted {
+    bool operator<(const AllInequalityOperatorsOneDeleted&) const;
+    bool operator<=(const AllInequalityOperatorsOneDeleted&) const;
+    bool operator>(const AllInequalityOperatorsOneDeleted&) const;
+    bool operator>=(const AllInequalityOperatorsOneDeleted&) const = delete;
+    bool operator!=(const AllInequalityOperatorsOneDeleted&) const;
+};
+
+static_assert(!std::three_way_comparable<AllInequalityOperatorsOneDeleted>);
+
+struct EqualityOperatorWrongReturnType {
+    int operator==(const EqualityOperatorWrongReturnType&);
+    auto operator<=>(const EqualityOperatorWrongReturnType&) const = default;
+};
+
+static_assert(!std::three_way_comparable<EqualityOperatorWrongReturnType>);
+
+struct SpaceshipWrongReturnType {
+    bool operator==(const SpaceshipWrongReturnType&) const = default;
+    int operator<=>(const SpaceshipWrongReturnType&);
+};
+
+static_assert(!std::three_way_comparable<SpaceshipWrongReturnType>);
+
+struct EqualityOperatorNonConstArgument {
+    bool operator==(EqualityOperatorNonConstArgument&);
+    auto operator<=>(const EqualityOperatorNonConstArgument&) const = default;
+};
+
+static_assert(!std::three_way_comparable<EqualityOperatorNonConstArgument>);
+
+struct SpaceshipNonConstArgument {
+    bool operator==(const SpaceshipNonConstArgument&) const = default;
+    auto operator<=>(SpaceshipNonConstArgument&);
+};
+
+static_assert(!std::three_way_comparable<SpaceshipNonConstArgument>);
+}
+
+int main(int, char**) { return 0; }

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T, class U, class Cat = partial_ordering>
+// concept three_way_comparable_with = // see below
+
+#include <compare>
+
+#include "compare_types.h"
+
+template <class T, class U = T, typename Cat = std::partial_ordering>
+constexpr bool check_three_way_comparable_with() {
+  constexpr bool result = std::three_way_comparable_with<T, U, Cat>;
+  static_assert(std::three_way_comparable_with<U, T, Cat> == result);
+  static_assert(std::three_way_comparable_with<T, U const, Cat> == result);
+  static_assert(std::three_way_comparable_with<T const, U const, Cat> == result);
+  static_assert(std::three_way_comparable_with<T, U const&, Cat> == result);
+  static_assert(std::three_way_comparable_with<T const, U const&, Cat> == result);
+  static_assert(std::three_way_comparable_with<T, U const&&, Cat> == result);
+  static_assert(std::three_way_comparable_with<T const, U const&&, Cat> == result);
+  if constexpr (!std::is_void_v<T>) {
+    static_assert(std::three_way_comparable_with<T&, U const, Cat> == result);
+    static_assert(std::three_way_comparable_with<T const&, U const, Cat> == result);
+    static_assert(std::three_way_comparable_with<T&, U const&, Cat> == result);
+    static_assert(std::three_way_comparable_with<T const&, U const&, Cat> == result);
+    static_assert(std::three_way_comparable_with<T&, U const&&, Cat> == result);
+    static_assert(std::three_way_comparable_with<T const&, U const&&, Cat> == result);
+    static_assert(std::three_way_comparable_with<T&&, U const, Cat> == result);
+    static_assert(std::three_way_comparable_with<T const&&, U const, Cat> == result);
+    static_assert(std::three_way_comparable_with<T&&, U const&, Cat> == result);
+    static_assert(std::three_way_comparable_with<T const&&, U const&, Cat> == result);
+    static_assert(std::three_way_comparable_with<T&&, U const&&, Cat> == result);
+    static_assert(std::three_way_comparable_with<T const&&, U const&&, Cat> == result);
+  }
+  return result;
+}
+
+namespace fundamentals {
+static_assert(check_three_way_comparable_with<int, int>());
+static_assert(check_three_way_comparable_with<int, char>());
+static_assert(check_three_way_comparable_with<int, wchar_t>());
+static_assert(check_three_way_comparable_with<int, double>());
+static_assert(check_three_way_comparable_with<int*, int*>());
+
+static_assert(check_three_way_comparable_with<int, int, std::strong_ordering>());
+static_assert(check_three_way_comparable_with<int, char, std::strong_ordering>());
+static_assert(check_three_way_comparable_with<int, wchar_t, std::strong_ordering>());
+
+static_assert(check_three_way_comparable_with<int, int, std::weak_ordering>());
+static_assert(check_three_way_comparable_with<int, char, std::weak_ordering>());
+static_assert(check_three_way_comparable_with<int, wchar_t, std::weak_ordering>());
+
+static_assert(!check_three_way_comparable_with<int, bool>());
+static_assert(!check_three_way_comparable_with<int, int*>());
+static_assert(!check_three_way_comparable_with<int, int[5]>());
+static_assert(!check_three_way_comparable_with<int, int (*)()>());
+static_assert(!check_three_way_comparable_with<int, int (&)()>());
+struct S {};
+static_assert(!check_three_way_comparable_with<int, int S::*>());
+static_assert(!check_three_way_comparable_with<int, int (S::*)()>());
+static_assert(!check_three_way_comparable_with<int, int (S::*)() noexcept>());
+static_assert(!check_three_way_comparable_with<int, int (S::*)() const>());
+static_assert(
+    !check_three_way_comparable_with<int, int (S::*)() const noexcept>());
+static_assert(!check_three_way_comparable_with<int, int (S::*)() volatile>());
+static_assert(
+    !check_three_way_comparable_with<int, int (S::*)() volatile noexcept>());
+static_assert(
+    !check_three_way_comparable_with<int, int (S::*)() const volatile>());
+static_assert(!check_three_way_comparable_with<
+              int, int (S::*)() const volatile noexcept>());
+static_assert(!check_three_way_comparable_with<int, int (S::*)() &>());
+static_assert(!check_three_way_comparable_with<int, int (S::*)() & noexcept>());
+static_assert(!check_three_way_comparable_with<int, int (S::*)() const&>());
+static_assert(
+    !check_three_way_comparable_with<int, int (S::*)() const & noexcept>());
+static_assert(!check_three_way_comparable_with<int, int (S::*)() volatile&>());
+static_assert(
+    !check_three_way_comparable_with<int, int (S::*)() volatile & noexcept>());
+static_assert(
+    !check_three_way_comparable_with<int, int (S::*)() const volatile&>());
+static_assert(!check_three_way_comparable_with<int, int (S::*)() const volatile &
+                                                       noexcept>());
+static_assert(!check_three_way_comparable_with<int, int (S::*)() &&>());
+static_assert(!check_three_way_comparable_with < int,
+              int (S::*)() && noexcept > ());
+static_assert(!check_three_way_comparable_with<int, int (S::*)() const&&>());
+static_assert(!check_three_way_comparable_with < int,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_three_way_comparable_with<int, int (S::*)() volatile&&>());
+static_assert(!check_three_way_comparable_with < int,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_three_way_comparable_with<int, int (S::*)() const volatile&&>());
+static_assert(!check_three_way_comparable_with < int,
+              int (S::*)() const volatile&& noexcept > ());
+static_assert(!check_three_way_comparable_with<int*, int[5]>());
+static_assert(!check_three_way_comparable_with<int[5], int[5]>());
+static_assert(!check_three_way_comparable_with<std::nullptr_t, int>());
+static_assert(!check_three_way_comparable_with<std::nullptr_t, int*>());
+static_assert(!check_three_way_comparable_with<std::nullptr_t, int[5]>());
+static_assert(!check_three_way_comparable_with<std::nullptr_t, int (*)()>());
+static_assert(!check_three_way_comparable_with<std::nullptr_t, int (&)()>());
+static_assert(!check_three_way_comparable_with<std::nullptr_t, int (S::*)()>());
+static_assert(!check_three_way_comparable_with<void, int>());
+static_assert(!check_three_way_comparable_with<void, int*>());
+static_assert(!check_three_way_comparable_with<void, std::nullptr_t>());
+static_assert(!check_three_way_comparable_with<void, int[5]>());
+static_assert(!check_three_way_comparable_with<void, int (*)()>());
+static_assert(!check_three_way_comparable_with<void, int (&)()>());
+static_assert(!check_three_way_comparable_with<void, int S::*>());
+static_assert(!check_three_way_comparable_with<void, int (S::*)()>());
+}
+
+namespace user_defined {
+struct S {
+    bool operator==(int) const;
+    std::strong_ordering operator<=>(int) const;
+    operator int() const;
+
+    bool operator==(const S&) const = default;
+    auto operator<=>(const S&) const = default;
+};
+
+static_assert(check_three_way_comparable_with<S, int>());
+static_assert(check_three_way_comparable_with<S, int, std::strong_ordering>());
+static_assert(check_three_way_comparable_with<S, int, std::weak_ordering>());
+
+struct SpaceshipNotDeclared {
+};
+
+static_assert(!check_three_way_comparable_with<SpaceshipNotDeclared>());
+
+struct SpaceshipDeleted {
+    auto operator<=>(const SpaceshipDeleted&) const = delete;
+};
+
+static_assert(!check_three_way_comparable_with<SpaceshipDeleted>());
+
+struct SpaceshipWithoutEqualityOperator {
+    auto operator<=>(const SpaceshipWithoutEqualityOperator&) const;
+};
+
+static_assert(!check_three_way_comparable_with<SpaceshipWithoutEqualityOperator>());
+
+struct EqualityOperatorDeleted {
+    bool operator==(const EqualityOperatorDeleted&) const = delete;
+};
+
+static_assert(!check_three_way_comparable_with<EqualityOperatorDeleted>());
+
+struct EqualityOperatorOnly {
+    bool operator==(const EqualityOperatorOnly&) const = default;
+};
+
+static_assert(!check_three_way_comparable_with<EqualityOperatorOnly>());
+
+struct SpaceshipDeclaredEqualityOperatorDeleted {
+    bool operator==(const SpaceshipDeclaredEqualityOperatorDeleted&) const = delete;
+    auto operator<=>(const SpaceshipDeclaredEqualityOperatorDeleted&) const = default;
+};
+
+static_assert(!check_three_way_comparable_with<SpaceshipDeclaredEqualityOperatorDeleted>());
+
+struct AllInequalityOperators {
+    bool operator<(const AllInequalityOperators&) const;
+    bool operator<=(const AllInequalityOperators&) const;
+    bool operator>(const AllInequalityOperators&) const;
+    bool operator>=(const AllInequalityOperators&) const;
+    bool operator!=(const AllInequalityOperators&) const;
+};
+
+static_assert(!check_three_way_comparable_with<AllInequalityOperators>());
+
+struct AllComparisonOperators {
+    bool operator<(const AllComparisonOperators&) const;
+    bool operator<=(const AllComparisonOperators&) const;
+    bool operator>(const AllComparisonOperators&) const;
+    bool operator>=(const AllComparisonOperators&) const;
+    bool operator!=(const AllComparisonOperators&) const;
+    bool operator==(const AllComparisonOperators&) const;
+};
+
+static_assert(!check_three_way_comparable_with<AllComparisonOperators>());
+
+struct AllButOneInequalityOperators {
+    bool operator<(const AllButOneInequalityOperators&) const;
+    bool operator<=(const AllButOneInequalityOperators&) const;
+    bool operator>(const AllButOneInequalityOperators&) const;
+    bool operator!=(const AllButOneInequalityOperators&) const;
+};
+
+static_assert(!check_three_way_comparable_with<AllButOneInequalityOperators>());
+
+struct AllInequalityOperatorsOneDeleted {
+    bool operator<(const AllInequalityOperatorsOneDeleted&) const;
+    bool operator<=(const AllInequalityOperatorsOneDeleted&) const;
+    bool operator>(const AllInequalityOperatorsOneDeleted&) const;
+    bool operator>=(const AllInequalityOperatorsOneDeleted&) const = delete;
+    bool operator!=(const AllInequalityOperatorsOneDeleted&) const;
+};
+
+static_assert(!check_three_way_comparable_with<AllInequalityOperatorsOneDeleted>());
+
+struct EqualityOperatorWrongReturnType {
+    int operator==(const EqualityOperatorWrongReturnType&);
+    auto operator<=>(const EqualityOperatorWrongReturnType&) const = default;
+};
+
+static_assert(!check_three_way_comparable_with<EqualityOperatorWrongReturnType>());
+
+struct SpaceshipWrongReturnType {
+    bool operator==(const SpaceshipWrongReturnType&) const = default;
+    int operator<=>(const SpaceshipWrongReturnType&);
+};
+
+static_assert(!check_three_way_comparable_with<SpaceshipWrongReturnType>());
+
+struct EqualityOperatorNonConstArgument {
+    bool operator==(EqualityOperatorNonConstArgument&);
+    auto operator<=>(const EqualityOperatorNonConstArgument&) const = default;
+};
+
+static_assert(!check_three_way_comparable_with<EqualityOperatorNonConstArgument>());
+
+struct SpaceshipNonConstArgument {
+    bool operator==(const SpaceshipNonConstArgument&) const = default;
+    auto operator<=>(SpaceshipNonConstArgument&);
+};
+
+static_assert(!check_three_way_comparable_with<SpaceshipNonConstArgument>());
+}
+
+int main(int, char**) { return 0; }