mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-06-27 14:58:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Release Cosmopolitan v3.6.0

Browse source 
This release is an atomic upgrade to GCC 14.1.0 with C23 and C++23
This commit is contained in:
Justine Tunney 2024-07-23 03:16:17 -07:00
parent 62ace3623a
commit 5660ec4741
No known key found for this signature in database
GPG key ID: BE714B4575D6E328
1585 changed files with 117353 additions and 271644 deletions
Download patch file Download diff file Expand all files Collapse all files

12
third_party/libcxx/__concepts/arithmetic.h vendored
View file

@ -26,25 +26,29 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concepts.arithmetic], arithmetic concepts
template<class _Tp>
template <class _Tp>
concept integral = is_integral_v<_Tp>;
template<class _Tp>
template <class _Tp>
concept signed_integral = integral<_Tp> && is_signed_v<_Tp>;
template<class _Tp>
template <class _Tp>
concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
template<class _Tp>
template <class _Tp>
concept floating_point = is_floating_point_v<_Tp>;
// Concept helpers for the internal type traits for the fundamental types.
template <class _Tp>
concept __libcpp_unsigned_integer = __libcpp_is_unsigned_integer<_Tp>::value;
template <class _Tp>
concept __libcpp_signed_integer = __libcpp_is_signed_integer<_Tp>::value;
template <class _Tp>
concept __libcpp_integer = __libcpp_unsigned_integer<_Tp> || __libcpp_signed_integer<_Tp>;
#endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD

12
third_party/libcxx/__concepts/assignable.h vendored
View file

@ -26,13 +26,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concept.assignable]
template<class _Lhs, class _Rhs>
template <class _Lhs, class _Rhs>
concept assignable_from =
is_lvalue_reference_v<_Lhs> &&
common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>> &&
requires (_Lhs __lhs, _Rhs&& __rhs) {
{ __lhs = _VSTD::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
};
is_lvalue_reference_v<_Lhs> &&
common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>> &&
requires(_Lhs __lhs, _Rhs&& __rhs) {
{ __lhs = std::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
};
#endif // _LIBCPP_STD_VER >= 20

6
third_party/libcxx/__concepts/boolean_testable.h vendored
View file

@ -23,12 +23,12 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concepts.booleantestable]
template<class _Tp>
template <class _Tp>
concept __boolean_testable_impl = convertible_to<_Tp, bool>;
template<class _Tp>
template <class _Tp>
concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
{ !_VSTD::forward<_Tp>(__t) } -> __boolean_testable_impl;
{ !std::forward<_Tp>(__t) } -> __boolean_testable_impl;
};
#endif // _LIBCPP_STD_VER >= 20

7
third_party/libcxx/__concepts/class_or_enum.h vendored
View file

@ -25,14 +25,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// Whether a type is a class type or enumeration type according to the Core wording.
template<class _Tp>
template <class _Tp>
concept __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>;
// Work around Clang bug https://llvm.org/PR52970
// TODO: remove this workaround once libc++ no longer has to support Clang 13 (it was fixed in Clang 14).
template<class _Tp>
concept __workaround_52970 = is_class_v<__remove_cvref_t<_Tp>> || is_union_v<__remove_cvref_t<_Tp>>;
#endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD

7
third_party/libcxx/__concepts/common_reference_with.h vendored
View file

@ -24,11 +24,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concept.commonref]
template<class _Tp, class _Up>
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>>;
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 >= 20

30
third_party/libcxx/__concepts/common_with.h vendored
View file

@ -27,21 +27,23 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concept.common]
template<class _Tp, class _Up>
// clang-format off
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>>(std::declval<_Tp>());
static_cast<common_type_t<_Tp, _Up>>(std::declval<_Up>());
} &&
common_reference_with<
add_lvalue_reference_t<const _Tp>,
add_lvalue_reference_t<const _Up>> &&
common_reference_with<
add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
common_reference_t<
add_lvalue_reference_t<const _Tp>,
add_lvalue_reference_t<const _Up>>>;
same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
requires {
static_cast<common_type_t<_Tp, _Up>>(std::declval<_Tp>());
static_cast<common_type_t<_Tp, _Up>>(std::declval<_Up>());
} &&
common_reference_with<
add_lvalue_reference_t<const _Tp>,
add_lvalue_reference_t<const _Up>> &&
common_reference_with<
add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
common_reference_t<
add_lvalue_reference_t<const _Tp>,
add_lvalue_reference_t<const _Up>>>;
// clang-format on
#endif // _LIBCPP_STD_VER >= 20

29
third_party/libcxx/__concepts/constructible.h vendored
View file

@ -23,31 +23,30 @@ _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20
// [concept.constructible]
template<class _Tp, class... _Args>
concept constructible_from =
destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
template <class _Tp, class... _Args>
concept constructible_from = destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
// [concept.default.init]
template<class _Tp>
template <class _Tp>
concept __default_initializable = requires { ::new _Tp; };
template<class _Tp>
concept default_initializable = constructible_from<_Tp> &&
requires { _Tp{}; } && __default_initializable<_Tp>;
template <class _Tp>
concept default_initializable = constructible_from<_Tp> && requires { _Tp{}; } && __default_initializable<_Tp>;
// [concept.moveconstructible]
template<class _Tp>
concept move_constructible =
constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
template <class _Tp>
concept move_constructible = constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
// [concept.copyconstructible]
template<class _Tp>
// clang-format off
template <class _Tp>
concept copy_constructible =
move_constructible<_Tp> &&
constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
move_constructible<_Tp> &&
constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
// clang-format on
#endif // _LIBCPP_STD_VER >= 20

8
third_party/libcxx/__concepts/convertible_to.h vendored
View file

@ -23,12 +23,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concept.convertible]
template<class _From, class _To>
concept convertible_to =
is_convertible_v<_From, _To> &&
requires {
static_cast<_To>(std::declval<_From>());
};
template <class _From, class _To>
concept convertible_to = is_convertible_v<_From, _To> && requires { static_cast<_To>(std::declval<_From>()); };
#endif // _LIBCPP_STD_VER >= 20

14
third_party/libcxx/__concepts/copyable.h vendored
View file

@ -24,13 +24,15 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concepts.object]
template<class _Tp>
// clang-format off
template <class _Tp>
concept copyable =
copy_constructible<_Tp> &&
movable<_Tp> &&
assignable_from<_Tp&, _Tp&> &&
assignable_from<_Tp&, const _Tp&> &&
assignable_from<_Tp&, const _Tp>;
copy_constructible<_Tp> &&
movable<_Tp> &&
assignable_from<_Tp&, _Tp&> &&
assignable_from<_Tp&, const _Tp&> &&
assignable_from<_Tp&, const _Tp>;
// clang-format on
#endif // _LIBCPP_STD_VER >= 20

6
third_party/libcxx/__concepts/derived_from.h vendored
View file

@ -23,10 +23,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [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*>;
template <class _Dp, class _Bp>
concept derived_from = is_base_of_v<_Bp, _Dp> && is_convertible_v<const volatile _Dp*, const volatile _Bp*>;
#endif // _LIBCPP_STD_VER >= 20

2
third_party/libcxx/__concepts/destructible.h vendored
View file

@ -22,7 +22,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concept.destructible]
template<class _Tp>
template <class _Tp>
concept destructible = is_nothrow_destructible_v<_Tp>;
#endif // _LIBCPP_STD_VER >= 20

2
third_party/libcxx/__concepts/different_from.h vendored
View file

@ -21,7 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20
template<class _Tp, class _Up>
template <class _Tp, class _Up>
concept __different_from = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
#endif // _LIBCPP_STD_VER >= 20

34
third_party/libcxx/__concepts/equality_comparable.h vendored
View file

@ -25,27 +25,29 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concept.equalitycomparable]
template<class _Tp, class _Up>
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;
};
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>
template <class _Tp>
concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
template<class _Tp, class _Up>
// clang-format off
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>;
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>;
// clang-format on
#endif // _LIBCPP_STD_VER >= 20

6
third_party/libcxx/__concepts/invocable.h vendored
View file

@ -23,14 +23,14 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concept.invocable]
template<class _Fn, class... _Args>
template <class _Fn, class... _Args>
concept invocable = requires(_Fn&& __fn, _Args&&... __args) {
_VSTD::invoke(_VSTD::forward<_Fn>(__fn), _VSTD::forward<_Args>(__args)...); // not required to be equality preserving
std::invoke(std::forward<_Fn>(__fn), std::forward<_Args>(__args)...); // not required to be equality preserving
};
// [concept.regular.invocable]
template<class _Fn, class... _Args>
template <class _Fn, class... _Args>
concept regular_invocable = invocable<_Fn, _Args...>;
#endif // _LIBCPP_STD_VER >= 20

8
third_party/libcxx/__concepts/movable.h vendored
View file

@ -25,12 +25,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concepts.object]
template<class _Tp>
concept movable =
is_object_v<_Tp> &&
move_constructible<_Tp> &&
assignable_from<_Tp&, _Tp> &&
swappable<_Tp>;
template <class _Tp>
concept movable = is_object_v<_Tp> && move_constructible<_Tp> && assignable_from<_Tp&, _Tp> && swappable<_Tp>;
#endif // _LIBCPP_STD_VER >= 20

5
third_party/libcxx/__concepts/predicate.h vendored
View file

@ -24,9 +24,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concept.predicate]
template<class _Fn, class... _Args>
concept predicate =
regular_invocable<_Fn, _Args...> && __boolean_testable<invoke_result_t<_Fn, _Args...>>;
template <class _Fn, class... _Args>
concept predicate = regular_invocable<_Fn, _Args...> && __boolean_testable<invoke_result_t<_Fn, _Args...>>;
#endif // _LIBCPP_STD_VER >= 20

2
third_party/libcxx/__concepts/regular.h vendored
View file

@ -23,7 +23,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concept.object]
template<class _Tp>
template <class _Tp>
concept regular = semiregular<_Tp> && equality_comparable<_Tp>;
#endif // _LIBCPP_STD_VER >= 20

9
third_party/libcxx/__concepts/relation.h vendored
View file

@ -22,19 +22,18 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concept.relation]
template<class _Rp, class _Tp, class _Up>
template <class _Rp, class _Tp, class _Up>
concept relation =
predicate<_Rp, _Tp, _Tp> && predicate<_Rp, _Up, _Up> &&
predicate<_Rp, _Tp, _Up> && predicate<_Rp, _Up, _Tp>;
predicate<_Rp, _Tp, _Tp> && predicate<_Rp, _Up, _Up> && predicate<_Rp, _Tp, _Up> && predicate<_Rp, _Up, _Tp>;
// [concept.equiv]
template<class _Rp, class _Tp, class _Up>
template <class _Rp, class _Tp, class _Up>
concept equivalence_relation = relation<_Rp, _Tp, _Up>;
// [concept.strictweakorder]
template<class _Rp, class _Tp, class _Up>
template <class _Rp, class _Tp, class _Up>
concept strict_weak_order = relation<_Rp, _Tp, _Up>;
#endif // _LIBCPP_STD_VER >= 20

4
third_party/libcxx/__concepts/same_as.h vendored
View file

@ -22,10 +22,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concept.same]
template<class _Tp, class _Up>
template <class _Tp, class _Up>
concept __same_as_impl = _IsSame<_Tp, _Up>::value;
template<class _Tp, class _Up>
template <class _Tp, class _Up>
concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
#endif // _LIBCPP_STD_VER >= 20

2
third_party/libcxx/__concepts/semiregular.h vendored
View file

@ -23,7 +23,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [concept.object]
template<class _Tp>
template <class _Tp>
concept semiregular = copyable<_Tp> && default_initializable<_Tp>;
#endif // _LIBCPP_STD_VER >= 20

118
third_party/libcxx/__concepts/swappable.h vendored
View file

@ -15,8 +15,8 @@
#include <__concepts/constructible.h>
#include <__config>
#include <__type_traits/extent.h>
#include <__type_traits/is_nothrow_move_assignable.h>
#include <__type_traits/is_nothrow_move_constructible.h>
#include <__type_traits/is_nothrow_assignable.h>
#include <__type_traits/is_nothrow_constructible.h>
#include <__type_traits/remove_cvref.h>
#include <__utility/exchange.h>
#include <__utility/forward.h>
@ -28,6 +28,9 @@
# pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20
@ -37,85 +40,84 @@ _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges {
namespace __swap {
template<class _Tp>
void swap(_Tp&, _Tp&) = delete;
template <class _Tp>
void swap(_Tp&, _Tp&) = delete;
template<class _Tp, class _Up>
concept __unqualified_swappable_with =
// clang-format off
template <class _Tp, class _Up>
concept __unqualified_swappable_with =
(__class_or_enum<remove_cvref_t<_Tp>> || __class_or_enum<remove_cvref_t<_Up>>) &&
requires(_Tp&& __t, _Up&& __u) {
swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
swap(std::forward<_Tp>(__t), std::forward<_Up>(__u));
};
// clang-format on
struct __fn;
struct __fn;
template<class _Tp, class _Up, size_t _Size>
concept __swappable_arrays =
!__unqualified_swappable_with<_Tp(&)[_Size], _Up(&)[_Size]> &&
// clang-format off
template <class _Tp, class _Up, size_t _Size>
concept __swappable_arrays =
!__unqualified_swappable_with<_Tp (&)[_Size], _Up (&)[_Size]> &&
extent_v<_Tp> == extent_v<_Up> &&
requires(_Tp(& __t)[_Size], _Up(& __u)[_Size], const __fn& __swap) {
__swap(__t[0], __u[0]);
requires(_Tp (&__t)[_Size], _Up (&__u)[_Size], const __fn& __swap) {
__swap(__t[0], __u[0]);
};
// clang-format on
template<class _Tp>
concept __exchangeable =
!__unqualified_swappable_with<_Tp&, _Tp&> &&
move_constructible<_Tp> &&
assignable_from<_Tp&, _Tp>;
template <class _Tp>
concept __exchangeable =
!__unqualified_swappable_with<_Tp&, _Tp&> && move_constructible<_Tp> && assignable_from<_Tp&, _Tp>;
struct __fn {
// 2.1 `S` is `(void)swap(E1, E2)`* if `E1` or `E2` has class or enumeration type and...
// *The name `swap` is used here unqualified.
template<class _Tp, class _Up>
requires __unqualified_swappable_with<_Tp, _Up>
_LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
{
swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
struct __fn {
// 2.1 `S` is `(void)swap(E1, E2)`* if `E1` or `E2` has class or enumeration type and...
// *The name `swap` is used here unqualified.
template <class _Tp, class _Up>
requires __unqualified_swappable_with<_Tp, _Up>
_LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(swap(std::forward<_Tp>(__t), std::forward<_Up>(__u)))) {
swap(std::forward<_Tp>(__t), std::forward<_Up>(__u));
}
// 2.2 Otherwise, if `E1` and `E2` are lvalues of array types with equal extent and...
template <class _Tp, class _Up, size_t _Size>
requires __swappable_arrays<_Tp, _Up, _Size>
_LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp (&__t)[_Size], _Up (&__u)[_Size]) const
noexcept(noexcept((*this)(*__t, *__u))) {
// TODO(cjdb): replace with `ranges::swap_ranges`.
for (size_t __i = 0; __i < _Size; ++__i) {
(*this)(__t[__i], __u[__i]);
}
}
// 2.2 Otherwise, if `E1` and `E2` are lvalues of array types with equal extent and...
template<class _Tp, class _Up, size_t _Size>
requires __swappable_arrays<_Tp, _Up, _Size>
_LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp(& __t)[_Size], _Up(& __u)[_Size]) const
noexcept(noexcept((*this)(*__t, *__u)))
{
// TODO(cjdb): replace with `ranges::swap_ranges`.
for (size_t __i = 0; __i < _Size; ++__i) {
(*this)(__t[__i], __u[__i]);
}
}
// 2.3 Otherwise, if `E1` and `E2` are lvalues of the same type `T` that models...
template<__exchangeable _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp& __x, _Tp& __y) const
noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_assignable_v<_Tp>)
{
__y = _VSTD::exchange(__x, _VSTD::move(__y));
}
};
// 2.3 Otherwise, if `E1` and `E2` are lvalues of the same type `T` that models...
template <__exchangeable _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp& __x, _Tp& __y) const
noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_assignable_v<_Tp>) {
__y = std::exchange(__x, std::move(__y));
}
};
} // namespace __swap
inline namespace __cpo {
inline constexpr auto swap = __swap::__fn{};
inline constexpr auto swap = __swap::__fn{};
} // namespace __cpo
} // namespace ranges
template<class _Tp>
template <class _Tp>
concept swappable = requires(_Tp& __a, _Tp& __b) { ranges::swap(__a, __b); };
template<class _Tp, class _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));
};
template <class _Tp, class _Up>
concept swappable_with = common_reference_with<_Tp, _Up> && requires(_Tp&& __t, _Up&& __u) {
ranges::swap(std::forward<_Tp>(__t), std::forward<_Tp>(__t));
ranges::swap(std::forward<_Up>(__u), std::forward<_Up>(__u));
ranges::swap(std::forward<_Tp>(__t), std::forward<_Up>(__u));
ranges::swap(std::forward<_Up>(__u), std::forward<_Tp>(__t));
};
#endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif // _LIBCPP___CONCEPTS_SWAPPABLE_H

43
third_party/libcxx/__concepts/totally_ordered.h vendored
View file

@ -25,31 +25,32 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// [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, 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>
template <class _Tp>
concept totally_ordered = equality_comparable<_Tp> && __partially_ordered_with<_Tp, _Tp>;
template<class _Tp, class _Up>
// clang-format off
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>;
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>;
// clang-format on
#endif // _LIBCPP_STD_VER >= 20