From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2181) id 44439396BC11; Wed, 11 Aug 2021 15:42:38 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 44439396BC11 MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Jonathan Wakely To: gcc-cvs@gcc.gnu.org, libstdc++-cvs@gcc.gnu.org Subject: [gcc r11-8847] libstdc++: Change [cmp.alg] assertions to constraints X-Act-Checkin: gcc X-Git-Author: Jonathan Wakely X-Git-Refname: refs/heads/releases/gcc-11 X-Git-Oldrev: ea32f15d44e4f50f3eb9deb3135e0b6d50f7ec43 X-Git-Newrev: 2fbb6039c5fcc7b85b048eeb748bea4753ff99cc Message-Id: <20210811154238.44439396BC11@sourceware.org> Date: Wed, 11 Aug 2021 15:42:38 +0000 (GMT) X-BeenThere: libstdc++-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libstdc++-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 11 Aug 2021 15:42:38 -0000 https://gcc.gnu.org/g:2fbb6039c5fcc7b85b048eeb748bea4753ff99cc commit r11-8847-g2fbb6039c5fcc7b85b048eeb748bea4753ff99cc Author: Jonathan Wakely Date: Mon Jun 14 12:25:43 2021 +0100 libstdc++: Change [cmp.alg] assertions to constraints This moves the same_as, decay_t<_Up>> checks from the [cmp.alg] function bodies into their constraints. Also add a test for the compare_xxx_order_fallback algorithms. libstdc++-v3/ChangeLog: * libsupc++/compare (__decayed_same_as): New helper concept. (strong_order, weak_order, partial_order): Constrain with new concept instead of using static_assert. (compare_strong_order_fallback, compare_weak_order_fallback) (compare_partial_order_fallback): Likewise. Do not deduce return types. Remove redundant if-constexpr checks. * testsuite/18_support/comparisons/algorithms/fallback.cc: New test. (cherry picked from commit e2c79b968ff95421c31a5a9a1b80b11321fe70d2) Diff: --- libstdc++-v3/libsupc++/compare | 39 ++++++++------------ .../18_support/comparisons/algorithms/fallback.cc | 42 ++++++++++++++++++++++ 2 files changed, 57 insertions(+), 24 deletions(-) diff --git a/libstdc++-v3/libsupc++/compare b/libstdc++-v3/libsupc++/compare index 82d00889272..b1f342113f1 100644 --- a/libstdc++-v3/libsupc++/compare +++ b/libstdc++-v3/libsupc++/compare @@ -600,6 +600,9 @@ namespace std // FIXME: || floating_point> || __cmp3way; + template + concept __decayed_same_as = same_as, decay_t<_Up>>; + class _Strong_order { template @@ -620,14 +623,12 @@ namespace std friend class _Strong_fallback; public: - template + template _Up> requires __strongly_ordered<_Tp, _Up> constexpr strong_ordering operator()(_Tp&& __e, _Up&& __f) const noexcept(_S_noexcept<_Tp, _Up>()) { - static_assert(same_as, decay_t<_Up>>); - /* FIXME: if constexpr (floating_point>) return __cmp_cust::__fp_strong_order(__e, __f); @@ -669,14 +670,12 @@ namespace std friend class _Weak_fallback; public: - template + template _Up> requires __weakly_ordered<_Tp, _Up> constexpr weak_ordering operator()(_Tp&& __e, _Up&& __f) const noexcept(_S_noexcept<_Tp, _Up>()) { - static_assert(same_as, decay_t<_Up>>); - if constexpr (floating_point>) return __cmp_cust::__fp_weak_ordering(__e, __f); else if constexpr (__adl_weak<_Tp, _Up>) @@ -716,14 +715,12 @@ namespace std friend class _Partial_fallback; public: - template + template _Up> requires __partially_ordered<_Tp, _Up> constexpr partial_ordering operator()(_Tp&& __e, _Up&& __f) const noexcept(_S_noexcept<_Tp, _Up>()) { - static_assert(same_as, decay_t<_Up>>); - if constexpr (__adl_partial<_Tp, _Up>) return partial_ordering(partial_order(static_cast<_Tp&&>(__e), static_cast<_Up&&>(__f))); @@ -759,18 +756,16 @@ namespace std } public: - template + template _Up> requires __strongly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up> - constexpr decltype(auto) + constexpr strong_ordering operator()(_Tp&& __e, _Up&& __f) const noexcept(_S_noexcept<_Tp, _Up>()) { - static_assert(same_as, decay_t<_Up>>); - if constexpr (__strongly_ordered<_Tp, _Up>) return _Strong_order{}(static_cast<_Tp&&>(__e), static_cast<_Up&&>(__f)); - else if constexpr (__op_eq_lt<_Tp, _Up>) + else // __op_eq_lt<_Tp, _Up> return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f) ? strong_ordering::equal : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f) @@ -793,18 +788,16 @@ namespace std } public: - template + template _Up> requires __weakly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up> - constexpr decltype(auto) + constexpr weak_ordering operator()(_Tp&& __e, _Up&& __f) const noexcept(_S_noexcept<_Tp, _Up>()) { - static_assert(same_as, decay_t<_Up>>); - if constexpr (__weakly_ordered<_Tp, _Up>) return _Weak_order{}(static_cast<_Tp&&>(__e), static_cast<_Up&&>(__f)); - else if constexpr (__op_eq_lt<_Tp, _Up>) + else // __op_eq_lt<_Tp, _Up> return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f) ? weak_ordering::equivalent : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f) @@ -827,18 +820,16 @@ namespace std } public: - template + template _Up> requires __partially_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up> - constexpr decltype(auto) + constexpr partial_ordering operator()(_Tp&& __e, _Up&& __f) const noexcept(_S_noexcept<_Tp, _Up>()) { - static_assert(same_as, decay_t<_Up>>); - if constexpr (__partially_ordered<_Tp, _Up>) return _Partial_order{}(static_cast<_Tp&&>(__e), static_cast<_Up&&>(__f)); - else if constexpr (__op_eq_lt<_Tp, _Up>) + else // __op_eq_lt<_Tp, _Up> return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f) ? partial_ordering::equivalent : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f) diff --git a/libstdc++-v3/testsuite/18_support/comparisons/algorithms/fallback.cc b/libstdc++-v3/testsuite/18_support/comparisons/algorithms/fallback.cc new file mode 100644 index 00000000000..ae458528f17 --- /dev/null +++ b/libstdc++-v3/testsuite/18_support/comparisons/algorithms/fallback.cc @@ -0,0 +1,42 @@ +// { dg-options "-std=gnu++20" } +// { dg-do compile { target c++20 } } + +#include + +using std::strong_ordering; +using std::partial_ordering; + +namespace adl +{ + struct S { }; + void strong_ordering(const S&, const S&); + bool operator==(const S&, S&) { return true; } + bool operator<(const S&, S&) { return true; } +} + +template + concept has_strong_order_fallback = requires (T& t, U& u) { + std::compare_strong_order_fallback(t, u); + }; + +template + concept has_weak_order_fallback = requires (T& t, U& u) { + std::compare_weak_order_fallback(t, u); + }; + +template + concept has_partial_order_fallback = requires (T& t, U& u) { + std::compare_partial_order_fallback(t, u); + }; + +using adl::S; + +static_assert( has_strong_order_fallback ); +static_assert( has_strong_order_fallback ); +static_assert( ! has_strong_order_fallback ); +static_assert( has_weak_order_fallback ); +static_assert( has_weak_order_fallback ); +static_assert( ! has_weak_order_fallback ); +static_assert( has_partial_order_fallback ); +static_assert( has_partial_order_fallback ); +static_assert( ! has_partial_order_fallback );