diff --git a/libcxx/docs/Status/SpaceshipProjects.csv b/libcxx/docs/Status/SpaceshipProjects.csv --- a/libcxx/docs/Status/SpaceshipProjects.csv +++ b/libcxx/docs/Status/SpaceshipProjects.csv @@ -3,14 +3,14 @@ | `three_way_comparable_with `_",None,Ruslan Arutyunyan,|In Progress| | `[cmp.result] `_,| `compare_three_way_result `_,None,Arthur O'Dwyer,|Complete| | `[expos.only.func] `_,"| `synth-three-way `_ -| `synth-three-way-result `_",[cmp.concept],Kent Ross,|In Progress| +| `synth-three-way-result `_",[cmp.concept],Kent Ross,|Complete| | `[comparisons.three.way] `_,| `compare_three_way `_,[cmp.concept],Christopher Di Bella,|In Progress| | `[cmp.alg] `_,"| `strong_order `_ | `weak_order `_ | `partial_order `_",None,Arthur O'Dwyer,|In Progress| | `[alg.three.way] `_,| `lexicographical_compare_three_way `_,[comparisons.three.way],Christopher Di Bella,|In Progress| | `[coroutine.handle.compare] `_,| coroutine_handle,[comparisons.three.way],Unassigned,|Not Started| -| `[pairs.spec] `_,| `pair `_,[expos.only.func],Kent Ross,|In Progress| +| `[pairs.spec] `_,| `pair `_,[expos.only.func],Kent Ross,|Complete| | `[syserr.errcat.nonvirtuals] `_,| error_category,[comparisons.three.way],Unassigned,|Not Started| | `[syserr.compare] `_,"| error_code | error_condition",None,Unassigned,|Not Started| diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt --- a/libcxx/include/CMakeLists.txt +++ b/libcxx/include/CMakeLists.txt @@ -104,6 +104,7 @@ __compare/common_comparison_category.h __compare/compare_three_way_result.h __compare/ordering.h + __compare/synth_three_way.h __compare/three_way_comparable.h __concepts/arithmetic.h __concepts/assignable.h diff --git a/libcxx/include/__compare/synth_three_way.h b/libcxx/include/__compare/synth_three_way.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__compare/synth_three_way.h @@ -0,0 +1,51 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___COMPARE_SYNTH_THREE_WAY_H +#define _LIBCPP___COMPARE_SYNTH_THREE_WAY_H + +#include <__config> +#include <__compare/ordering.h> +#include <__compare/three_way_comparable.h> +#include <__concepts/boolean_testable.h> +#include <__utility/declval.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS) + +// [expos.only.func] + +_LIBCPP_HIDE_FROM_ABI inline constexpr auto __synth_three_way = + [](const _Tp& __t, const _Up& __u) + requires requires { + { __t < __u } -> __boolean_testable; + { __u < __t } -> __boolean_testable; + } + { + if constexpr (three_way_comparable_with<_Tp, _Up>) { + return __t <=> __u; + } else { + if (__t < __u) return weak_ordering::less; + if (__u < __t) return weak_ordering::greater; + return weak_ordering::equivalent; + } + }; + +template +using __synth_three_way_result = decltype(__synth_three_way(declval<_Tp&>(), declval<_Up&>())); + +#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS) + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___COMPARE_SYNTH_THREE_WAY_H diff --git a/libcxx/include/__utility/pair.h b/libcxx/include/__utility/pair.h --- a/libcxx/include/__utility/pair.h +++ b/libcxx/include/__utility/pair.h @@ -9,6 +9,8 @@ #ifndef _LIBCPP___UTILITY_PAIR_H #define _LIBCPP___UTILITY_PAIR_H +#include <__compare/common_comparison_category.h> +#include <__compare/synth_three_way.h> #include <__config> #include <__functional/unwrap_ref.h> #include <__tuple> @@ -308,6 +310,8 @@ pair(_T1, _T2) -> pair<_T1, _T2>; #endif +// [pairs.spec], specialized algorithms + template inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool @@ -316,6 +320,23 @@ return __x.first == __y.first && __x.second == __y.second; } +#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS) + +template +_LIBCPP_HIDE_FROM_ABI constexpr +common_comparison_category_t< + __synth_three_way_result<_T1>, + __synth_three_way_result<_T2> > +operator<=>(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) +{ + if (auto __c = _VSTD::__synth_three_way(__x.first, __y.first); __c != 0) { + return __c; + } + return _VSTD::__synth_three_way(__x.second, __y.second); +} + +#else // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS) + template inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool @@ -356,6 +377,8 @@ return !(__y < __x); } +#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS) + template inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 typename enable_if diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap --- a/libcxx/include/module.modulemap +++ b/libcxx/include/module.modulemap @@ -374,6 +374,7 @@ module common_comparison_category { private header "__compare/common_comparison_category.h" } module compare_three_way_result { private header "__compare/compare_three_way_result.h" } module ordering { private header "__compare/ordering.h" } + module synth_three_way { private header "__compare/synth_three_way.h" } module three_way_comparable { private header "__compare/three_way_comparable.h" } } } diff --git a/libcxx/include/utility b/libcxx/include/utility --- a/libcxx/include/utility +++ b/libcxx/include/utility @@ -96,11 +96,15 @@ }; template bool operator==(const pair&, const pair&); // constexpr in C++14 -template bool operator!=(const pair&, const pair&); // constexpr in C++14 -template bool operator< (const pair&, const pair&); // constexpr in C++14 -template bool operator> (const pair&, const pair&); // constexpr in C++14 -template bool operator>=(const pair&, const pair&); // constexpr in C++14 -template bool operator<=(const pair&, const pair&); // constexpr in C++14 +template bool operator!=(const pair&, const pair&); // constexpr in C++14, removed in C++20 +template bool operator< (const pair&, const pair&); // constexpr in C++14, removed in C++20 +template bool operator> (const pair&, const pair&); // constexpr in C++14, removed in C++20 +template bool operator>=(const pair&, const pair&); // constexpr in C++14, removed in C++20 +template bool operator<=(const pair&, const pair&); // constexpr in C++14, removed in C++20 +template + constexpr common_comparison_type_t, + synth-three-way-result> + operator<=>(const pair&, const pair&); // C++20 template pair make_pair(T1&&, T2&&); // constexpr in C++14 template diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/compare/synth_three_way.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/compare/synth_three_way.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/compare/synth_three_way.module.verify.cpp @@ -0,0 +1,16 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__compare/synth_three_way.h'}} +#include <__compare/synth_three_way.h> diff --git a/libcxx/test/libcxx/library/description/conventions/expos.only.func/synth_three_way.pass.cpp b/libcxx/test/libcxx/library/description/conventions/expos.only.func/synth_three_way.pass.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/library/description/conventions/expos.only.func/synth_three_way.pass.cpp @@ -0,0 +1,166 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, libcpp-no-concepts +// ADDITIONAL_COMPILE_FLAGS: -Wno-sign-compare + +// constexpr auto __synth_three_way = ...; + +#include +#include +#include +#include // Includes synth-three-way via std::pair::operator<=> + +#include "test_macros.h" + +template concept can_synth_three_way = requires(T t) { std::__synth_three_way(t, t); }; + +// A custom three-way result type +struct CustomEquality { + friend constexpr bool operator==(const CustomEquality&, int) noexcept { return true; } + friend constexpr bool operator<(const CustomEquality&, int) noexcept { return false; } + friend constexpr bool operator<(int, const CustomEquality&) noexcept { return false; } +}; + +constexpr bool test() { + { + assert(std::__synth_three_way(1, 1) == std::strong_ordering::equal); + assert(std::__synth_three_way(2, 1) == std::strong_ordering::greater); + assert(std::__synth_three_way(1, 2) == std::strong_ordering::less); + ASSERT_SAME_TYPE(std::strong_ordering, std::__synth_three_way_result); + ASSERT_SAME_TYPE(std::strong_ordering, std::__synth_three_way_result); + } + { + constexpr double nan = std::numeric_limits::quiet_NaN(); + assert(std::__synth_three_way(1.0, 1.0) == std::partial_ordering::equivalent); + assert(std::__synth_three_way(2.0, 1.0) == std::partial_ordering::greater); + assert(std::__synth_three_way(1.0, 2.0) == std::partial_ordering::less); + assert(std::__synth_three_way(nan, nan) == std::partial_ordering::unordered); + ASSERT_SAME_TYPE(std::partial_ordering, std::__synth_three_way_result); + ASSERT_SAME_TYPE(std::partial_ordering, std::__synth_three_way_result); + ASSERT_SAME_TYPE(std::partial_ordering, std::__synth_three_way_result); + ASSERT_SAME_TYPE(std::partial_ordering, std::__synth_three_way_result); + } + { + struct StrongSpaceship { + int value; + constexpr bool operator==(const StrongSpaceship&) const = default; + constexpr std::strong_ordering operator<=>(const StrongSpaceship& other) const { return value <=> other.value; } + }; + assert(std::__synth_three_way(StrongSpaceship{1}, StrongSpaceship{1}) == std::strong_ordering::equal); + assert(std::__synth_three_way(StrongSpaceship{2}, StrongSpaceship{1}) == std::strong_ordering::greater); + assert(std::__synth_three_way(StrongSpaceship{1}, StrongSpaceship{2}) == std::strong_ordering::less); + ASSERT_SAME_TYPE(std::strong_ordering, std::__synth_three_way_result); + } + { + struct WeakSpaceship { + int value; + constexpr bool operator==(const WeakSpaceship&) const = default; + constexpr std::weak_ordering operator<=>(const WeakSpaceship& other) const { + return value <=> other.value; + } + }; + assert(std::__synth_three_way(WeakSpaceship{1}, WeakSpaceship{1}) == std::weak_ordering::equivalent); + assert(std::__synth_three_way(WeakSpaceship{2}, WeakSpaceship{1}) == std::weak_ordering::greater); + assert(std::__synth_three_way(WeakSpaceship{1}, WeakSpaceship{2}) == std::weak_ordering::less); + ASSERT_SAME_TYPE(std::weak_ordering, std::__synth_three_way_result); + } + { + struct PartialSpaceship { + double value; + constexpr bool operator==(const PartialSpaceship&) const = default; + constexpr std::partial_ordering operator<=>(const PartialSpaceship& other) const { + return value <=> other.value; + } + }; + constexpr double nan = std::numeric_limits::quiet_NaN(); + assert(std::__synth_three_way(PartialSpaceship{1.0}, PartialSpaceship{1.0}) == std::partial_ordering::equivalent); + assert(std::__synth_three_way(PartialSpaceship{2.0}, PartialSpaceship{1.0}) == std::partial_ordering::greater); + assert(std::__synth_three_way(PartialSpaceship{1.0}, PartialSpaceship{2.0}) == std::partial_ordering::less); + assert(std::__synth_three_way(PartialSpaceship{nan}, PartialSpaceship{nan}) == std::partial_ordering::unordered); + ASSERT_SAME_TYPE(std::partial_ordering, std::__synth_three_way_result); + } + { + struct NoSpaceship { + int value; + constexpr bool operator==(const NoSpaceship&) const = default; + constexpr bool operator<(const NoSpaceship& other) const { return value < other.value; } + }; + assert(std::__synth_three_way(NoSpaceship{1}, NoSpaceship{1}) == std::weak_ordering::equivalent); + assert(std::__synth_three_way(NoSpaceship{2}, NoSpaceship{1}) == std::weak_ordering::greater); + assert(std::__synth_three_way(NoSpaceship{1}, NoSpaceship{2}) == std::weak_ordering::less); + ASSERT_SAME_TYPE(std::weak_ordering, std::__synth_three_way_result); + } + { + // Types with operator<=> but no operator== are not three_way_comparable and will fall back to operator< and + // compare as weakly ordered. + struct SpaceshipNoEquals { + constexpr std::strong_ordering operator<=>(const SpaceshipNoEquals&) const { + return std::strong_ordering::equivalent; + } + }; + assert(std::__synth_three_way(SpaceshipNoEquals{}, SpaceshipNoEquals{}) == std::weak_ordering::equivalent); + ASSERT_SAME_TYPE(std::weak_ordering, std::__synth_three_way_result); + } + { + // Custom three-way-comparison result types cannot satisfy standard concepts (and therefore synth-three-way) + // because they are not understood by std::common_comparison_category, but they can still be used in + // the same way as standard orderings to do comparisons, and thus can be used by synth-three-way to yield a + // weakly-ordered result. + struct CustomSpaceship { + constexpr CustomEquality operator<=>(const CustomSpaceship&) const { return CustomEquality(); } + }; + assert((CustomSpaceship() <=> CustomSpaceship()) == 0); + assert(!(CustomSpaceship() < CustomSpaceship())); + assert(std::__synth_three_way(CustomSpaceship(), CustomSpaceship()) == std::weak_ordering::equivalent); + ASSERT_SAME_TYPE(std::weak_ordering, std::__synth_three_way_result); + } + // SFINAE tests demonstrating synth-three-way needs three_way_comparable or operator<. + { + struct NoRelative { + constexpr bool operator==(const NoRelative&) const; + }; + static_assert(!can_synth_three_way); + } + { + struct NoLessThan { + constexpr bool operator==(const NoLessThan&) const; + constexpr bool operator>(const NoLessThan&) const; + constexpr bool operator>=(const NoLessThan&) const; + constexpr bool operator<=(const NoLessThan&) const; + }; + static_assert(!can_synth_three_way); + } + { + assert(std::__synth_three_way(1, 1U) == std::weak_ordering::equivalent); + assert(std::__synth_three_way(-1, 0U) == std::weak_ordering::greater); + // Even with the warning suppressed (-Wno-sign-compare) there should still be no <=> operator + // between signed and unsigned types, so we should end up with a synthesized weak ordering. + ASSERT_SAME_TYPE(std::weak_ordering, std::__synth_three_way_result); + // When an unsigned type can be narrowed to a larger signed type, <=> should be defined and we + // should get a strong ordering. (This probably does not raise a warning due to safe narrowing.) + assert((static_cast(-1) <=> static_cast(0)) == std::strong_ordering::less); + assert(std::__synth_three_way(static_cast(-1), + static_cast(0)) == std::strong_ordering::less); + ASSERT_SAME_TYPE(std::strong_ordering, std::__synth_three_way_result); + } + + return true; +} + +int main(int, char**) { + test(); + static_assert(test()); + + { + constexpr double nan = std::numeric_limits::quiet_NaN(); + assert(std::__synth_three_way(nan, 1.0) == std::partial_ordering::unordered); + } + + return 0; +} diff --git a/libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp b/libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/std/utilities/utility/pairs/pairs.spec/three_way_comparison.pass.cpp @@ -0,0 +1,115 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +// + +// template struct pair + +// template bool operator<=>(const pair&, const pair&); + +// UNSUPPORTED: c++03, c++11, c++14, c++17, libcpp-no-concepts + +#include +#include +#include +#include // std::is_constant_evaluated +#include + +#include "test_macros.h" + +template concept HasEqual = requires(T t) { t == t; }; +template concept HasLess = requires(T t) { t < t; }; +template concept HasSpaceship = requires(T t) { t <=> t; }; + +constexpr bool test() { + { + // Pairs of types that both have strong ordering should compare with strong ordering. + using P = std::pair; + ASSERT_SAME_TYPE(decltype(P() <=> P()), std::strong_ordering); + assert((P(1, 1) <=> P(1, 2)) == std::strong_ordering::less); + assert((P(2, 1) <=> P(1, 2)) == std::strong_ordering::greater); + assert((P(0, 0) <=> P(0, 0)) == std::strong_ordering::equal); + } + { + // Pairs of int and a type with no spaceship operator should compare with weak ordering. + struct NoSpaceship { + int value; + constexpr bool operator==(const NoSpaceship&) const = default; + constexpr bool operator<(const NoSpaceship& other) const { return value < other.value; } + }; + using P = std::pair; + ASSERT_SAME_TYPE(decltype(P() <=> P()), std::weak_ordering); + assert((P(1, {1}) <=> P(1, {2})) == std::weak_ordering::less); + assert((P(2, {1}) <=> P(1, {2})) == std::weak_ordering::greater); + assert((P(0, {0}) <=> P(0, {0})) == std::weak_ordering::equivalent); + } + { + // Pairs of int (strongly ordered) and double (partially ordered) should compare with partial ordering. + using P = std::pair; + constexpr double nan = std::numeric_limits::quiet_NaN(); + ASSERT_SAME_TYPE(decltype(P() <=> P()), std::partial_ordering); + assert((P(1, 1.0) <=> P(1, 2.0)) == std::partial_ordering::less); + assert((P(1, 1.0) <=> P(1, 1.0)) == std::partial_ordering::equivalent); + assert((P(1, -0.0) <=> P(1, 0.0)) == std::partial_ordering::equivalent); + assert((P(1, 2.0) <=> P(1, 1.0)) == std::partial_ordering::greater); + assert((P(1, nan) <=> P(2, nan)) == std::partial_ordering::less); + assert((P(2, nan) <=> P(1, nan)) == std::partial_ordering::greater); + assert((P(1, nan) <=> P(1, nan)) == std::partial_ordering::unordered); + } + { + using P = std::pair; + constexpr double nan = std::numeric_limits::quiet_NaN(); + ASSERT_SAME_TYPE(decltype(P() <=> P()), std::partial_ordering); + assert((P(2.0, 1) <=> P(1.0, 2)) == std::partial_ordering::greater); + assert((P(1.0, 1) <=> P(1.0, 2)) == std::partial_ordering::less); + assert((P(nan, 1) <=> P(nan, 2)) == std::partial_ordering::unordered); + } + { + struct NoRelative { + constexpr bool operator==(const NoRelative&) const; + }; + static_assert(HasEqual>); + static_assert(!HasLess>); + static_assert(!HasSpaceship>); + } + { + struct NoLessThan { + constexpr bool operator==(const NoLessThan&) const; + constexpr bool operator>(const NoLessThan&) const; + }; + static_assert(HasEqual>); + static_assert(!HasLess>); + static_assert(!HasSpaceship>); + } + +#ifdef TEST_COMPILER_GCC + // GCC cannot evaluate NaN @ non-NaN constexpr, so test that runtime-only. + if (!std::is_constant_evaluated()) +#endif + { + { + using P = std::pair; + constexpr double nan = std::numeric_limits::quiet_NaN(); + assert((P(1, 2.0) <=> P(1, nan)) == std::partial_ordering::unordered); + } + { + using P = std::pair; + constexpr double nan = std::numeric_limits::quiet_NaN(); + assert((P(1.0, 1) <=> P(nan, 2)) == std::partial_ordering::unordered); + } + } + + return true; +} + +int main(int, char**) { + test(); + static_assert(test()); + + return 0; +}