[WIP] [libc++] [P1614] Various unimplemented parts of <compare>. [WIP]

[• Quuxplusone]

Summary

I have this locally as five commits, and plan to upload several PRs when it's actually ready to land.

Duplicates/supersedes the following similar PRs by others:

• D80899 compare_three_way, blocked by lack of three_way_comparable

But does not supersede this one:

• D80902 lexicographical_compare_three_way, blocked by lack of compare_three_way

[• Quuxplusone]

Has tests now.
std::strong_order still doesn't compare NaNs correctly; we may need a domain expert for this.
Everything up to strong_order is probably ready to upload separately for review:

• [libc++][modularisation] Split up <concepts> into granular headers.
• [libc++] [p1614] Implement std::compare_three_way_result.
• [libc++] [p1614] Implement std::three_way_comparable.
• [libc++] [p1614] Implement std::compare_three_way.

@ldionne: Do you want the above as four PRs, one PR, or something in between?

[• Quuxplusone]

Rebase (expecting CI to pass this time)

[cjdb]

In D107036#2914445, @Quuxplusone wrote:

Has tests now.
std::strong_order still doesn't compare NaNs correctly; we may need a domain expert for this.
Everything up to strong_order is probably ready to upload separately for review:

• [libc++][modularisation] Split up <concepts> into granular headers.
• [libc++] [p1614] Implement std::compare_three_way_result.
• [libc++] [p1614] Implement std::three_way_comparable.
• [libc++] [p1614] Implement std::compare_three_way.

@ldionne: Do you want the above as four PRs, one PR, or something in between?

I'd appreciate it if you could make these dependent PRs to make it easier to review.

libcxx/include/__concepts/__boolean_testable.h

2

Please rename this file to boolean_testable.h. We decided a while back to not prefix detail headers with underscores.

libcxx/include/concepts

155–159

If you're going to split up <concepts>, please entirely split it up. Having some content in <concepts> and other stuff in __concepts is going to be difficult to track.

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

1 ↗

(On Diff #363160)

There are a lot of missing tests for this file. Please reintroduce them.

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

1 ↗

(On Diff #363160)

There are a lot of missing tests for this file. Please reintroduce them.

[cjdb]

In addition to my feedback above, please drop the <concepts> changes from this patch (no longer necessary), as well as the changes in common with D80899 and D80902 (I'll return to these once three_way_comparable lands).

Please also ensure that what's left properly credits the original patch authors in the commit, preferably by making them the person that's named in git blame.

[mumbleskates]

libcxx/include/__compare/cmp_alg.h

67

I would hope that we can order them by union view of the data in memory if such a thing is allowed (or memcpy, if that's better) once we know that the sign and signaling bits are the same, because the specifics of the payload ordering are unspecified by totalOrder. Any way that we can look at the raw data in memory without UB should be sufficient.

[mumbleskates]

libcxx/include/__compare/cmp_alg.h

67

Ah I see, there are literally no standard implementation for the isSignaling predicate for iec559 types in C++. However, it does look like ISO C has an issignaling macro as part of the Floating-point extensions part 1, which I gather was accepted into the C23 standard in 2019 (ISO/IEC TS 60559-1, of interest section 7.12.3.7). Complete implementation of C++ strong_order for iec559 floating point types might be considered to be blocked on the implementation of this part of the standard as that seems like the best place to get it.

Implementing this just for strong_order is messy, very complex, and generally inadvisable. (Even for binary floating point values, ignoring the existence of decimal floating point types, some platforms -- notably PA-RISC -- use the opposite interpretation for the signaling bit in IEC559 floating point types, even though it's in the same location.) Unless we can strongly declare that we don't support any platforms other than say ARM and x86 this seems like a no-go, and it just seems better to take the platform support directly from the llvm C standard implementation.

[• Quuxplusone]

libcxx/include/__compare/cmp_alg.h

67

@mumbleskates: I doubt I understand your two comments. In case it's not already obvious: the IEEE 754 "total order" predicate is well-defined and we must implement std::strong_order consistently with it, on IEEE 754 platforms, because the Standard says so. (On other platforms, C++ doesn't care so much, because those platforms are dumb. :)) std::strong_order(x,y) is the way that C++20 exposes the "total order" predicate to end-users; there is no isolable floating-point-total-order library function for us to delegate to (because WG21 doesn't do software engineering).

Is there an isolable "llvm C standard implementation" we could be exploiting here — some kind of __builtin_totalorder we could use when it's available? That would be really cool.
I do think that this will eventually need to use either constexpr-friendly __builtin_memcpy, or else std::bit_cast; I just haven't gotten around to revisiting it.

A bit of googling turned up this solution which maybe just needs to be tweaked a tiny bit: https://stackoverflow.com/a/20154751/1424877

[mumbleskates]

libcxx/include/__compare/cmp_alg.h

67

That general solution in the stackoverflow link works, but may only be correct for x86/ARM binary representation floating point types. (I don't know enough about the decimal types to know if they would also sort this way, but they are unsupported by by x86/ARM silicon.)

What it boils down to is that the *only* predicate we are missing, for any given iec559 type, is isSignaling: detecting whether a NaN is signaling or not. If we have that we can use it to complete the implementation here. Such a predicate does exist in standard C, but I believe it is not yet implemented in llvm's libc.

I know exactly how to do this on x86 and ARM with bit twiddling for pretty much any floating point type in the standard, but there are platforms with iec559 implementations where the signaling bit has the opposite meaning, and I think there might exist platforms where it is in a different place. Because signaling/non-signaling NaN implementation details are a property of the platform this immediately becomes a question of platform support; it's probably best to centralize this implementation knowledge as much as possible, but I don't know much about our approach to that in the llvm project.

[• Quuxplusone]

Rebased on main, to show what's left to do.
Tried a new bit-twiddling version of IEC559 totalOrder. Unfortunately I still don't know how to test it or how to make it constexpr. Fortunately, C++20 requires that it not be constexpr, AFAICT? See https://eel.is/c++draft/cmp#alg-1 which doesn't mention constexpr either positively or negatively.

[mumbleskates]

libcxx/include/__compare/cmp_alg.h

50

Fun cursed fact here, intel 80bit long doubles are also iec559. At least on my skylakex system they have sizeof() 16, have 6 bytes of padding at the end, and otherwise work mostly the same (sign bit at the top, 15 bits of exponent, 63 bits of mantissa in a 64 bit field wherein the MSB is always 1 except when it's sub-normal, and the next highest bit is used for 0=signaling/1=quiet NaN, as the highest bit of the real mantissa). Not completely sure what to do about that!

[jloser]

libcxx/include/__compare/cmp_alg.h

46

Should we use std::same_as and std::floating_point concepts instead? Same applies to other uses ofG type traits that are concepts now as well.

libcxx/test/std/utilities/function.objects/comparisons/compare_three_way.pass.cpp

26

Any reason to prefer this over just return true;? Similarly for the fallback overload (except return false; in that case).

libcxx/test/std/utilities/function.objects/comparisons/transparent.pass.cpp

60

We can drop the empty string second argument if you care.

[• Quuxplusone]

Rebase on std::bit_cast (D75960), and use std::bit_cast in the implementation of std::strong_order.
Rebase on D103478 (which has been merged now).

[• Quuxplusone]

Fix std::strong_order for floats, thanks to
https://stackoverflow.com/questions/59348310/how-to-implement-the-totalorder-predicate-for-floating-point-values
https://stackoverflow.com/questions/69068075/what-is-the-purpose-of-if-x-and-y-represent-the-same-floating-point-datum-i
https://quuxplusone.github.io/blog/2021/09/05/float-format/

Add std::weak_order and std::partial_order; they lack testing.

Drive-by fix some minor stuff.

Still unimplemented: std::strong_order_fallback and so on.

[• Quuxplusone]

Rebase; incorporate D109331 and further bugfixes to D75960.

[• Quuxplusone]

libcxx/test/std/library/description/conventions/type.descriptions/customization.point.object/cpo.pass.cpp

2

This one test file is the only part of D107036 that hasn't been superseded by D110738 + D111514.
@ldionne or whoever, do you think we care about this test file? Should I open a new PR for it (or repurpose this one)? or should I just close D107036 completely?

[ldionne]

libcxx/test/std/library/description/conventions/type.descriptions/customization.point.object/cpo.pass.cpp

2

I think this test is useful, and I would encourage splitting it into another PR to clear things up a bit. And then we can close this one as it has been superseded.

[• Quuxplusone]

The last piece of this (the test) has been superseded by D115588.

libcxx/include/CMakeLists.txt

set(files
   __algorithm/unique.h
   __algorithm/unwrap_iter.h
   __algorithm/upper_bound.h
   __availability
   __bit_reference
   __bits
   __bsd_locale_defaults.h
   __bsd_locale_fallbacks.h
+  __compare/cmp_alg.h
   __compare/common_comparison_category.h
+  __compare/compare_three_way.h
+  __compare/compare_three_way_result.h
   __compare/ordering.h
+  __compare/three_way_comparable.h
+  __concepts/__boolean_testable.h
+  __concepts/common_reference_with.h
+  __concepts/convertible_to.h
+  __concepts/equality_comparable.h
+  __concepts/same_as.h
+  __concepts/totally_ordered.h
   __config
   __debug
   __errc
   __format/format_error.h
   __format/format_parse_context.h
   __function_like.h
   __functional_base
   __functional/binary_function.h
set(files
   __support/xlocale/__nop_locale_mgmt.h
   __support/xlocale/__posix_l_fallback.h
   __support/xlocale/__strtonum_fallback.h
   __threading_support
   __tree
   __tuple
   __undef_macros
   __utility/__decay_copy.h
+  __utility/__priority_tag.h
   __utility/as_const.h
   __utility/cmp.h
   __utility/declval.h
   __utility/exchange.h
   __utility/forward.h
   __utility/in_place.h
   __utility/integer_sequence.h
   __utility/move.h

libcxx/include/__compare/cmp_alg.h

+// -*- C++ -*-
+//===-------------------------- compare -----------------------------------===//
+//
+// 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_CMP_ALG
+#define _LIBCPP___COMPARE_CMP_ALG
+
+#include <__config>
+#include <__compare/compare_three_way.h>
+#include <__compare/ordering.h>
+#include <__utility/__priority_tag.h>
+#include <cmath>
+#include <type_traits>
+
+#ifndef _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)
+
+// [cmp.alg]
+namespace __strong_order {
+  struct __fn {
+    template<class _Ep, class _Fp>
+      requires is_same_v<decay_t<_Ep>, decay_t<_Fp>>
+    _LIBCPP_HIDE_FROM_ABI constexpr strong_ordering go(_Ep&& __e, _Fp&& __f, _PriorityTag<2>)
+      noexcept(noexcept(strong_ordering(strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)))))
+      requires requires { strong_ordering(strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))); }
+    {
+      return strong_ordering(strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
+    }
+
+    template<class _Ep, class _Fp, class _Dp = decay_t<_Ep>>
+      requires is_same_v<_Dp, decay_t<_Fp>> && is_floating_point_v<_Dp>
+    _LIBCPP_HIDE_FROM_ABI constexpr strong_ordering go(_Ep&& __e, _Fp&& __f, _PriorityTag<1>)
+      noexcept
+    {
+      if (__e < __f) {
+        return strong_ordering::less;
+      } else if (__e > __f) {
+        return strong_ordering::greater;
+      } else if (__e == __f) {
+        if (__e == 0) {
+          return _VSTD::signbit(__f) <=> _VSTD::signbit(__e);
+        } else if (_VSTD::isinf(__e)) {
+          return strong_ordering::equal;
+        } else {
+          int __eexp, __fexp;
+          (void)_VSTD::frexp(__e, __eexp);
+          (void)_VSTD::frexp(__f, __fexp);
+          return (__e < 0) ? (__eexp <=> __fexp) : (__fexp <=> __eexp);
+        }
+      } else {
+        // The order is -QNAN, -SNAN, numbers, +SNAN, +QNAN.
+        if (_VSTD::isnan(__e)) {
+          if (_VSTD::isnan(__f)) {
+            // These two NaNs should be ordered by their payload bits,
+            // but there's no way to get at that information portably.
+            return _VSTD::signbit(__f) <=> _VSTD::signbit(__e);
+          } else {
+            return _VSTD::signbit(__e) ? strong_ordering::less : strong_ordering::greater;
+          }
+        } else {
+          return _VSTD::signbit(__f) ? strong_ordering::greater : strong_ordering::less;
+        }
+      }
+    }
+
+    template<class _Ep, class _Fp>
+      requires is_same_v<decay_t<_Ep>, decay_t<_Fp>>
+    _LIBCPP_HIDE_FROM_ABI constexpr strong_ordering go(_Ep&& __e, _Fp&& __f, _PriorityTag<0>)
+      noexcept(noexcept(strong_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)))))
+      requires requires { strong_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))); }
+    {
+      return strong_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
+    }
+
+    template<class _Ep, class _Fp>
+    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ep&& __e, _Fp&& __f)
+      noexcept(noexcept(__go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))))
+      -> decltype(__go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<2>()))
+    {
+      return __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<2>());
+    }
+  };
+} // namespace __strong_order
+
+inline namespace __cpo {
+  inline constexpr auto strong_order = __strong_order::__fn{};
+} // namespace __cpo
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___COMPARE_CMP_ALG

libcxx/include/__compare/compare_three_way.h

+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___COMPARE_COMPARE_THREE_WAY_H
+#define _LIBCPP___COMPARE_COMPARE_THREE_WAY_H
+
+#include <__config>
+#include <__compare/three_way_comparable.h>
+#include <__utility/forward.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)
+
+struct _LIBCPP_TEMPLATE_VIS compare_three_way
+{
+    template<class _T1, class _T2>
+        requires three_way_comparable_with<_T1, _T2>
+    constexpr _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u)))
+        { return          _VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u); }
+
+    using is_transparent = void;
+};
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_H

libcxx/include/__compare/compare_three_way_result.h

+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___COMPARE_COMPARE_THREE_WAY_RESULT_H
+#define _LIBCPP___COMPARE_COMPARE_THREE_WAY_RESULT_H
+
+#include <__config>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+template<class, class, class>
+struct _LIBCPP_HIDE_FROM_ABI __compare_three_way_result { };
+
+template<class _Tp, class _Up>
+struct _LIBCPP_HIDE_FROM_ABI __compare_three_way_result<_Tp, _Up, decltype(
+  declval<const remove_reference_t<_Tp>&>() <=> declval<const remove_reference_t<_Up>&>(), void()
+)> {
+    using type = decltype(declval<const remove_reference_t<_Tp>&>() <=> declval<const remove_reference_t<_Up>&>());
+};
+
+template<class _Tp, class _Up>
+struct _LIBCPP_TEMPLATE_VIS compare_three_way_result : __compare_three_way_result<_Tp, _Up, void> { };
+
+template<class _Tp, class _Up>
+using compare_three_way_result_t = typename compare_three_way_result<_Tp, _Up>::type;
+
+#endif // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_RESULT_H

libcxx/include/__compare/three_way_comparable.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_THREE_WAY_COMPARABLE_H
+#define _LIBCPP___COMPARE_THREE_WAY_COMPARABLE_H
+
+#include <__compare/common_comparison_category.h>
+#include <__concepts/common_reference_with.h>
+#include <__concepts/equality_comparable.h>
+#include <__concepts/same_as.h>
+#include <__concepts/totally_ordered.h>
+#include <__config>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+template<class _Tp, class _Cat>
+concept __compares_as =
+    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 (const remove_reference_t<_Tp>& __t) {
+        { __t <=> __t } -> __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<const remove_reference_t<_Tp>&, const remove_reference_t<_Up>&> &&
+    three_way_comparable<common_reference_t<const remove_reference_t<_Tp>&, const remove_reference_t<_Up>&>, _Cat> &&
+    __weakly_equality_comparable_with<_Tp, _Up> &&
+    __partially_ordered_with<_Tp, _Up> &&
+    requires (const remove_reference_t<_Tp>& __t, const remove_reference_t<_Up>& __u) {
+        { __t <=> __u } -> __compares_as<_Cat>;
+        { __u <=> __t } -> __compares_as<_Cat>;
+    };
+
+#endif // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___COMPARE_THREE_WAY_COMPARABLE_H

libcxx/include/__concepts/__boolean_testable.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___CONCEPTS_BOOLEAN_TESTABLE
+#define _LIBCPP___CONCEPTS_BOOLEAN_TESTABLE
+
+#include <__concepts/convertible_to.h>
+#include <__config>
+
+#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_CONCEPTS)
+
+// [concepts.booleantestable]
+
+template<class _Tp>
+concept __boolean_testable_impl = convertible_to<_Tp, bool>;
+
+template<class _Tp>
+concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
+  { !static_cast<_Tp&&>(__t) } -> __boolean_testable_impl;
+};
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___CONCEPTS_BOOLEAN_TESTABLE

libcxx/include/__concepts/common_reference_with.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___CONCEPTS_COMMON_REFERENCE_WITH_H
+#define _LIBCPP___CONCEPTS_COMMON_REFERENCE_WITH_H
+
+#include <__concepts/convertible_to.h>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <type_traits>
+
+#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_CONCEPTS)
+
+// [concept.commonref]
+
+template<class _Tp, class _Up>
+concept common_reference_with =
+  same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> &&
+  convertible_to<_Tp, common_reference_t<_Tp, _Up>> &&
+  convertible_to<_Up, common_reference_t<_Tp, _Up>>;
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___CONCEPTS_COMMON_REFERENCE_WITH_H

libcxx/include/__concepts/convertible_to.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___CONCEPTS_CONVERTIBLE_TO
+#define _LIBCPP___CONCEPTS_CONVERTIBLE_TO
+
+#include <__config>
+#include <type_traits>
+
+#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_CONCEPTS)
+
+// [concept.convertible]
+
+template<class _From, class _To>
+concept convertible_to =
+  is_convertible_v<_From, _To> &&
+  requires (add_rvalue_reference_t<_From> (&__f)()) {
+    static_cast<_To>(__f());
+  };
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___CONCEPTS_CONVERTIBLE_TO

libcxx/include/__concepts/equality_comparable.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___CONCEPTS_EQUALITY_COMPARABLE
+#define _LIBCPP___CONCEPTS_EQUALITY_COMPARABLE
+
+#include <__concepts/__boolean_testable.h>
+#include <__concepts/common_reference_with.h>
+#include <__config>
+#include <type_traits>
+
+#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_CONCEPTS)
+
+// [concept.equalitycomparable]
+
+template<class _Tp, class _Up>
+concept __weakly_equality_comparable_with =
+  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
+    { __t == __u } -> __boolean_testable;
+    { __t != __u } -> __boolean_testable;
+    { __u == __t } -> __boolean_testable;
+    { __u != __t } -> __boolean_testable;
+  };
+
+template<class _Tp>
+concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
+
+template<class _Tp, class _Up>
+concept equality_comparable_with =
+  equality_comparable<_Tp> && equality_comparable<_Up> &&
+  common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
+  equality_comparable<
+    common_reference_t<
+      __make_const_lvalue_ref<_Tp>,
+      __make_const_lvalue_ref<_Up>>> &&
+  __weakly_equality_comparable_with<_Tp, _Up>;
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___CONCEPTS_EQUALITY_COMPARABLE

libcxx/include/__concepts/same_as.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___CONCEPTS_SAME_AS
+#define _LIBCPP___CONCEPTS_SAME_AS
+
+#include <__config>
+#include <type_traits>
+
+#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_CONCEPTS)
+
+// [concept.same]
+
+template<class _Tp, class _Up>
+concept __same_as_impl = _VSTD::_IsSame<_Tp, _Up>::value;
+
+template<class _Tp, class _Up>
+concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___CONCEPTS_SAME_AS

libcxx/include/__concepts/totally_ordered.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___CONCEPTS_TOTALLY_ORDERED
+#define _LIBCPP___CONCEPTS_TOTALLY_ORDERED
+
+#include <__config>
+#include <type_traits>
+
+#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_CONCEPTS)
+
+// [concept.totallyordered]
+
+template<class _Tp, class _Up>
+concept __partially_ordered_with =
+  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
+    { __t <  __u } -> __boolean_testable;
+    { __t >  __u } -> __boolean_testable;
+    { __t <= __u } -> __boolean_testable;
+    { __t >= __u } -> __boolean_testable;
+    { __u <  __t } -> __boolean_testable;
+    { __u >  __t } -> __boolean_testable;
+    { __u <= __t } -> __boolean_testable;
+    { __u >= __t } -> __boolean_testable;
+  };
+
+template<class _Tp>
+concept totally_ordered = equality_comparable<_Tp> && __partially_ordered_with<_Tp, _Tp>;
+
+template<class _Tp, class _Up>
+concept totally_ordered_with =
+  totally_ordered<_Tp> && totally_ordered<_Up> &&
+  equality_comparable_with<_Tp, _Up> &&
+  totally_ordered<
+    common_reference_t<
+      __make_const_lvalue_ref<_Tp>,
+      __make_const_lvalue_ref<_Up>>> &&
+  __partially_ordered_with<_Tp, _Up>;
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___CONCEPTS_TOTALLY_ORDERED

libcxx/include/__utility/__priority_tag.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_PRIORITY_TAG_H
+#define _LIBCPP___UTILITY_PRIORITY_TAG_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<size_t _Ip> struct _PriorityTag : _PriorityTag<_Ip - 1> {};
+template<> struct _PriorityTag<0> {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___UTILITY_PRIORITY_TAG_H

libcxx/include/compare

namespace std {
   // [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.concept], concept three_way_comparable
+  template<class T, class Cat = partial_ordering>
+    concept three_way_comparable = see below;
+  template<class T, class U, class Cat = partial_ordering>
+    concept three_way_comparable_with = see below;
+
+  // [cmp.result], result of three-way comparison
+  template<class T, class U = T> struct compare_three_way_result;
+
+  template<class T, class U = T>
+    using compare_three_way_result_t = typename compare_three_way_result<T, U>::type;
+
+  // [comparisons.three.way], class compare_three_way
+  struct compare_three_way;
+
   // [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:
public:
     friend constexpr bool operator<=(unspecified, strong_ordering v) noexcept;
     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 <__compare/cmp_alg.h>
 #include <__compare/common_comparison_category.h>
+#include <__compare/compare_three_way.h>
+#include <__compare/compare_three_way_result.h>
 #include <__compare/ordering.h>
+#include <__compare/three_way_comparable.h>
 #include <__config>
 #include <type_traits>
 
-#ifndef _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)
-
-// [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);
-
-#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
-
-_LIBCPP_END_NAMESPACE_STD
-
 #endif // _LIBCPP_COMPARE

libcxx/include/concepts

-// -*- C++ -*-
-//===-------------------------- concepts ----------------------------------===//
+//===----------------------------------------------------------------------===//
 //
 // 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_CONCEPTS
namespace std {
 
   // [concept.strictweakorder], concept strict_weak_order
   template<class R, class T, class U>
     concept strict_weak_order = see below;
 }
 
 */
 
+#include <__concepts/__boolean_testable.h>
+#include <__concepts/common_reference_with.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/equality_comparable.h>
+#include <__concepts/same_as.h>
+#include <__concepts/totally_ordered.h>
 #include <__config>
 #include <__functional/invoke.h>
 #include <__functional_base>
 #include <type_traits>
 #include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
-// [concept.same]
-
-template<class _Tp, class _Up>
-concept __same_as_impl = _VSTD::_IsSame<_Tp, _Up>::value;
-
-template<class _Tp, class _Up>
-concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
-
 // [concept.derived]
 template<class _Dp, class _Bp>
 concept derived_from =
   is_base_of_v<_Bp, _Dp> &&
   is_convertible_v<const volatile _Dp*, const volatile _Bp*>;
 
-// [concept.convertible]
-template<class _From, class _To>
-concept convertible_to =
-  is_convertible_v<_From, _To> &&
-  requires(add_rvalue_reference_t<_From> (&__f)()) {
-    static_cast<_To>(__f());
-  };
-
-// [concept.commonref]
-template<class _Tp, class _Up>
-concept common_reference_with =
-  same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> &&
-  convertible_to<_Tp, common_reference_t<_Tp, _Up>> &&
-  convertible_to<_Up, common_reference_t<_Tp, _Up>>;
-
 // [concept.common]
 template<class _Tp, class _Up>
 concept common_with =
   same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
   requires {
     static_cast<common_type_t<_Tp, _Up>>(declval<_Tp>());
     static_cast<common_type_t<_Tp, _Up>>(declval<_Up>());
   } &&
concept swappable_with =
   common_reference_with<_Tp, _Up> &&
   requires(_Tp&& __t, _Up&& __u) {
     ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Tp>(__t));
     ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Up>(__u));
     ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
     ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Tp>(__t));
   };
 
-// [concept.booleantestable]
-template<class _Tp>
-concept __boolean_testable_impl = convertible_to<_Tp, bool>;
-
-template<class _Tp>
-concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
-  { !std::forward<_Tp>(__t) } -> __boolean_testable_impl;
-};
-
-// [concept.equalitycomparable]
-template<class _Tp, class _Up>
-concept __weakly_equality_comparable_with =
-  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
-    { __t == __u } -> __boolean_testable;
-    { __t != __u } -> __boolean_testable;
-    { __u == __t } -> __boolean_testable;
-    { __u != __t } -> __boolean_testable;
-  };
-
-template<class _Tp>
-concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
-
-template<class _Tp, class _Up>
-concept equality_comparable_with =
-  equality_comparable<_Tp> && equality_comparable<_Up> &&
-  common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
-  equality_comparable<
-    common_reference_t<
-      __make_const_lvalue_ref<_Tp>,
-      __make_const_lvalue_ref<_Up>>> &&
-  __weakly_equality_comparable_with<_Tp, _Up>;
-
-// [concept.totallyordered]
-
-template<class _Tp, class _Up>
-concept __partially_ordered_with =
-  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
-    { __t <  __u } -> __boolean_testable;
-    { __t >  __u } -> __boolean_testable;
-    { __t <= __u } -> __boolean_testable;
-    { __t >= __u } -> __boolean_testable;
-    { __u <  __t } -> __boolean_testable;
-    { __u >  __t } -> __boolean_testable;
-    { __u <= __t } -> __boolean_testable;
-    { __u >= __t } -> __boolean_testable;
-  };
-
-template<class _Tp>
-concept totally_ordered = equality_comparable<_Tp> && __partially_ordered_with<_Tp, _Tp>;
-
-template<class _Tp, class _Up>
-concept totally_ordered_with =
-  totally_ordered<_Tp> && totally_ordered<_Up> &&
-  equality_comparable_with<_Tp, _Up> &&
-  totally_ordered<
-    common_reference_t<
-      __make_const_lvalue_ref<_Tp>,
-      __make_const_lvalue_ref<_Up>>> &&
-  __partially_ordered_with<_Tp, _Up>;
-
 // [concepts.object]
 template<class _Tp>
 concept movable =
   is_object_v<_Tp> &&
   move_constructible<_Tp> &&
   assignable_from<_Tp&, _Tp> &&
   swappable<_Tp>;
 

libcxx/include/functional

struct greater_equal {
     bool operator()(const T& x, const T& y) const;
 };
 
 template <class T> // <class T=void> in C++14
 struct less_equal {
     bool operator()(const T& x, const T& y) const;
 };
 
+// [comparisons.three.way], class compare_three_way
+struct compare_three_way;
+
 template <class T> // <class T=void> in C++14
 struct logical_and {
     bool operator()(const T& x, const T& y) const;
 };
 
 template <class T> // <class T=void> in C++14
 struct logical_or {
     bool operator()(const T& x, const T& y) const;

 
 POLICY:  For non-variadic implementations, the number of arguments is limited
          to 3.  It is hoped that the need for non-variadic implementations
          will be minimal.
 
 */
 
 #include <__algorithm/search.h>
+#include <__compare/compare_three_way.h>
 #include <__config>
 #include <__debug>
 #include <__functional/binary_function.h> // TODO: deprecate
 #include <__functional/binary_negate.h>
 #include <__functional/bind_front.h>
 #include <__functional/bind.h>
 #include <__functional/binder1st.h>
 #include <__functional/binder2nd.h>

libcxx/include/module.modulemap

module codecvt {
     header "codecvt"
     export *
   }
   module compare {
     header "compare"
     export *
 
     module __compare {
+      module cmp_alg                    { private header "__compare/cmp_alg.h"                    }
       module common_comparison_category { private header "__compare/common_comparison_category.h" }
+      module compare_three_way          { private header "__compare/compare_three_way.h"          }
+      module compare_three_way_result   { private header "__compare/compare_three_way_result.h"   }
       module ordering                   { private header "__compare/ordering.h"                   }
+      module three_way_comparable       { private header "__compare/three_way_comparable.h"       }
     }
   }
   module complex {
     header "complex"
     export *
   }
   module concepts {
     header "concepts"
     export *
+
+    module __concepts {
+      module __boolean_testable         { private header "__concepts/__boolean_testable.h"        }
+      module convertible_to             { private header "__concepts/convertible_to.h"            }
+      module common_reference_with      { private header "__concepts/common_reference_with.h"     }
+      module equality_comparable        { private header "__concepts/equality_comparable.h"       }
+      module same_as                    { private header "__concepts/same_as.h"                   }
+      module totally_ordered            { private header "__concepts/totally_ordered.h"           }
+    }
   }
   module condition_variable {
     header "condition_variable"
     export *
   }
   module deque {
     header "deque"
     export initializer_list

libcxx/test/libcxx/diagnostics/detail.headers/compare/cmp_alg.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/cmp_alg.h'}}
+#include <__compare/cmp_alg.h>

libcxx/test/libcxx/diagnostics/detail.headers/compare/compare_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/compare_three_way.h'}}
+#include <__compare/compare_three_way.h>

libcxx/test/libcxx/diagnostics/detail.headers/compare/compare_three_way_result.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/compare_three_way_result.h'}}
+#include <__compare/compare_three_way_result.h>

libcxx/test/libcxx/diagnostics/detail.headers/compare/three_way_comparable.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/three_way_comparable.h'}}
+#include <__compare/three_way_comparable.h>

libcxx/test/libcxx/diagnostics/detail.headers/concepts/__boolean_testable.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: '__concepts/__boolean_testable.h'}}
+#include <__concepts/__boolean_testable.h>

libcxx/test/libcxx/diagnostics/detail.headers/concepts/common_reference_with.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: '__concepts/common_reference_with.h'}}
+#include <__concepts/common_reference_with.h>

libcxx/test/libcxx/diagnostics/detail.headers/concepts/convertible_to.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: '__concepts/convertible_to.h'}}
+#include <__concepts/convertible_to.h>

libcxx/test/libcxx/diagnostics/detail.headers/concepts/equality_comparable.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: '__concepts/equality_comparable.h'}}
+#include <__concepts/equality_comparable.h>

libcxx/test/libcxx/diagnostics/detail.headers/concepts/same_as.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: '__concepts/same_as.h'}}
+#include <__concepts/same_as.h>

libcxx/test/libcxx/diagnostics/detail.headers/concepts/totally_ordered.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: '__concepts/totally_ordered.h'}}
+#include <__concepts/totally_ordered.h>

libcxx/test/libcxx/diagnostics/detail.headers/utility/__priority_tag.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: '__utility/__priority_tag.h'}}
+#include <__utility/__priority_tag.h>

libcxx/test/std/library/description/conventions/type.descriptions/customization.point.object/cpo.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
+
+// [customization.point.object]
+// [range.adaptor.object] "A range adaptor object is a customization point object..."
+
+#include <compare>
+#include <iterator>
+#include <ranges>
+#include <sstream>
+#include <utility>
+
+template<class CPO, class... Args>
+constexpr bool test(CPO& o, Args&&...)
+{
+    auto p = o;
+    using T = decltype(p);
+
+    // The type of a customization point object, ignoring cv-qualifiers, shall model semiregular.
+    static_assert(std::semiregular<T>);
+
+    // All instances of a specific customization point object type shall be equal.
+    // (However, they need not support operator==, so there's nothing to test here.)
+
+    // The type T of a customization point object, ignoring cv-qualifiers, shall model...
+    static_assert(std::invocable<T&, Args...>);
+    static_assert(std::invocable<const T&, Args...>);
+    static_assert(std::invocable<T, Args...>);
+    static_assert(std::invocable<const T, Args...>);
+
+    return true;
+}
+
+int main(int, char**)
+{
+    int a[10];
+    int arrays[10][10];
+    std::pair<int, int> pairs[10];
+    std::istringstream iss;
+
+    // [iterator.cust]
+    static_assert(test(std::ranges::iter_move, a+0));
+    static_assert(test(std::ranges::iter_swap, a+0, a+1));
+
+    // [cmp.alg]
+    static_assert(test(std::strong_order, 1, 2));
+    static_assert(test(std::weak_order, 1, 2));
+    static_assert(test(std::partial_order, 1, 2));
+//    static_assert(test(std::compare_strong_order_fallback, 1, 2));
+//    static_assert(test(std::compare_weak_order_fallback, 1, 2));
+//    static_assert(test(std::compare_partial_order_fallback, 1, 2));
+
+    // [range.access]
+    static_assert(test(std::ranges::begin, a));
+    static_assert(test(std::ranges::end, a));
+    static_assert(test(std::ranges::cbegin, a));
+    static_assert(test(std::ranges::cend, a));
+//    static_assert(test(std::ranges::rbegin, a));
+//    static_assert(test(std::ranges::rend, a));
+//    static_assert(test(std::ranges::crbegin, a));
+//    static_assert(test(std::ranges::crend, a));
+    static_assert(test(std::ranges::size, a));
+    static_assert(test(std::ranges::ssize, a));
+    static_assert(test(std::ranges::empty, a));
+    static_assert(test(std::ranges::data, a));
+//    static_assert(test(std::ranges::cdata, a));
+
+    // [range.factories]
+    // views::empty<T> is not a CPO
+//    static_assert(test(std::views::empty<int>));  // technically not documented as a CPO yet
+//    static_assert(test(std::views::single, 4));
+//    static_assert(test(std::views::iota, 1));
+//    static_assert(test(std::views::iota, 1, 10));
+//    static_assert(test(std::views::istream_view<int>, iss));  // technically not documented as a CPO yet
+
+    // [range.adaptors]
+    static_assert(test(std::views::all, a));
+//    static_assert(test(std::views::filter, a, [](int x){ return x < 10; }));
+//    static_assert(test(std::views::transform, a, [](int x){ return x + 1; }));
+    static_assert(test(std::views::take, a, 10));
+    static_assert(test(std::views::take_while, a, [](int x){ return x < 10; }));
+//    static_assert(test(std::views::drop, a, 10));
+//    static_assert(test(std::views::drop_while, a, [](int x){ return x < 10; }));
+    static_assert(test(std::views::join, arrays));
+    static_assert(test(std::views::lazy_split, a, 4));
+    static_assert(test(std::views::split, a, 4));
+    static_assert(test(std::views::counted, a, 10));
+    static_assert(test(std::views::common, a));
+    static_assert(test(std::views::reverse, a));
+    static_assert(test(std::views::elements<0>, pairs));
+
+    return 0;
+}

libcxx/test/std/utilities/function.objects/comparisons/compare_three_way.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <compare>
+// <functional>
+
+// compare_three_way
+
+#include <compare>
+#include <cassert>
+#include <type_traits>
+
+#include "pointer_comparison_test_helper.h"
+
+template<class T, class U>
+constexpr auto test_sfinae(T t, U u)
+    -> decltype(std::compare_three_way()(t, u), std::true_type{})
+    { return std::true_type{}; }
+
+constexpr auto test_sfinae(...)
+    { return std::false_type{}; }
+
+int main(int, char**)
+{
+    static_assert(std::compare_three_way()(1, 1) == (1 <=> 1));
+    static_assert(std::compare_three_way()(1, 2) == (1 <=> 2));
+    static_assert(std::compare_three_way()(2, 1) == (2 <=> 1));
+
+    do_pointer_comparison_test(std::compare_three_way());
+
+    static_assert(test_sfinae(1, 2));
+    static_assert(!test_sfinae(1, nullptr));
+
+    return 0;
+}

libcxx/test/std/utilities/function.objects/comparisons/transparent.pass.cpp

int main(int, char**)
     static_assert (  is_transparent<std::greater<void>>::value, "" );
     static_assert (  is_transparent<std::greater<>>::value, "" );
 
     static_assert ( !is_transparent<std::greater_equal<int>>::value, "" );
     static_assert ( !is_transparent<std::greater_equal<std::string>>::value, "" );
     static_assert (  is_transparent<std::greater_equal<void>>::value, "" );
     static_assert (  is_transparent<std::greater_equal<>>::value, "" );
 
+#if TEST_STD_VER > 17
+    static_assert(is_transparent<std::compare_three_way>);
+#endif
+
     return 0;
 }