Merge branch 'master' into string_constexpr

Author: miscco

stl/inc/atomic

@@ -445,7 +445,7 @@ inline void _Atomic_lock_release(_Smtx_t* _Spinlock) noexcept {
 }
 
 template <class _Spinlock_t>
-class _Atomic_lock_guard {
+class _NODISCARD _Atomic_lock_guard {
 public:
     explicit _Atomic_lock_guard(_Spinlock_t& _Spinlock_) noexcept : _Spinlock(_Spinlock_) {
         _Atomic_lock_acquire(_Spinlock);

stl/inc/compare

@@ -333,7 +333,7 @@ struct compare_three_way_result<_Ty1, _Ty2> {
 struct compare_three_way {
     template <class _Ty1, class _Ty2>
         requires three_way_comparable_with<_Ty1, _Ty2> // TRANSITION, GH-489
-    constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
         noexcept(noexcept(_STD forward<_Ty1>(_Left) <=> _STD forward<_Ty2>(_Right))) /* strengthened */ {
         return _STD forward<_Ty1>(_Left) <=> _STD forward<_Ty2>(_Right);
     }
@@ -396,35 +396,37 @@ namespace _Strong_order {
                 using _Floating_type = decay_t<_Ty1>;
                 using _Traits        = _Floating_type_traits<_Floating_type>;
                 using _Uint_type     = typename _Traits::_Uint_type;
+                using _Sint_type     = make_signed_t<_Uint_type>;
 
-                auto _Left_uint  = _STD bit_cast<_Uint_type>(_Left);
-                auto _Right_uint = _STD bit_cast<_Uint_type>(_Right);
+                const auto _Left_uint  = _STD bit_cast<_Uint_type>(_Left);
+                const auto _Right_uint = _STD bit_cast<_Uint_type>(_Right);
 
                 // 1. Ultra-fast path: equal representations are equal.
                 if (_Left_uint == _Right_uint) {
                     return strong_ordering::equal;
                 }
 
                 // 2. Examine the sign bits.
-                const bool _Left_negative  = (_Left_uint & _Traits::_Shifted_sign_mask) != 0;
-                const bool _Right_negative = (_Right_uint & _Traits::_Shifted_sign_mask) != 0;
+                const _Uint_type _Left_shifted_sign  = _Left_uint & _Traits::_Shifted_sign_mask;
+                const _Uint_type _Right_shifted_sign = _Right_uint & _Traits::_Shifted_sign_mask;
 
-                // 3. Fast path: any negative value is less than any positive value.
-                if (_Left_negative != _Right_negative) {
-                    return _Left_negative ? strong_ordering::less : strong_ordering::greater;
-                }
+                // 3. Interpret floating-point bit patterns as sign magnitude representations of integers,
+                //    and then transform them into ones' complement representation.
+                // (Ones' complement representations of positive zero and negative zero are different.)
+                const _Uint_type _Left_sign  = _Left_shifted_sign >> _Traits::_Sign_shift;
+                const _Uint_type _Right_sign = _Right_shifted_sign >> _Traits::_Sign_shift;
 
-                // 4. Clear the (identical) sign bits. We've already stored them for use at the end.
-                _Left_uint &= ~_Traits::_Shifted_sign_mask;
-                _Right_uint &= ~_Traits::_Shifted_sign_mask;
+                const _Uint_type _Left_xor  = _Left_shifted_sign - _Left_sign;
+                const _Uint_type _Right_xor = _Right_shifted_sign - _Right_sign;
 
-                // 5. Perform the final comparison, reversed for negative values.
-                // (For example, 1.5 is less than 2.5, but -1.5 is greater than -2.5.)
-                if (_Left_negative) {
-                    return _Right_uint <=> _Left_uint;
-                } else {
-                    return _Left_uint <=> _Right_uint;
-                }
+                const _Uint_type _Left_ones_complement_uint  = _Left_uint ^ _Left_xor;
+                const _Uint_type _Right_ones_complement_uint = _Right_uint ^ _Right_xor;
+
+                const auto _Left_ones_complement  = static_cast<_Sint_type>(_Left_ones_complement_uint);
+                const auto _Right_ones_complement = static_cast<_Sint_type>(_Right_ones_complement_uint);
+
+                // 4. Perform the final comparison.
+                return _Left_ones_complement <=> _Right_ones_complement;
             } else if constexpr (_Strat == _St::_Three) {
                 return static_cast<strong_ordering>(compare_three_way{}(_Left, _Right));
             } else {
@@ -498,6 +500,7 @@ namespace _Weak_order {
                 using _Floating_type = decay_t<_Ty1>;
                 using _Traits        = _Floating_type_traits<_Floating_type>;
                 using _Uint_type     = typename _Traits::_Uint_type;
+                using _Sint_type     = make_signed_t<_Uint_type>;
 
                 auto _Left_uint  = _STD bit_cast<_Uint_type>(_Left);
                 auto _Right_uint = _STD bit_cast<_Uint_type>(_Right);
@@ -507,47 +510,42 @@ namespace _Weak_order {
                     return weak_ordering::equivalent;
                 }
 
-                // 2. Fold negative zero into positive zero.
-                constexpr _Uint_type _Negative_zero = _Traits::_Shifted_sign_mask;
+                // 2. Examine the sign bits.
+                const _Uint_type _Left_shifted_sign  = _Left_uint & _Traits::_Shifted_sign_mask;
+                const _Uint_type _Right_shifted_sign = _Right_uint & _Traits::_Shifted_sign_mask;
 
-                if (_Left_uint == _Negative_zero) {
-                    _Left_uint = 0;
-                } else if (_Right_uint == _Negative_zero) { // The representations are known to be non-equal here.
-                    _Right_uint = 0;
-                }
+                // 3. Fold all NaN values together.
+                // (The fact that _Infinity_plus_one represents a signaling NaN is irrelevant here.)
+                constexpr _Uint_type _Infinity_plus_one = _Traits::_Shifted_exponent_mask + 1;
 
-                // 3. Examine the sign bits.
-                const bool _Left_negative  = (_Left_uint & _Traits::_Shifted_sign_mask) != 0;
-                const bool _Right_negative = (_Right_uint & _Traits::_Shifted_sign_mask) != 0;
+                const _Uint_type _Left_magnitude  = _Left_uint & ~_Traits::_Shifted_sign_mask;
+                const _Uint_type _Right_magnitude = _Right_uint & ~_Traits::_Shifted_sign_mask;
 
-                // 4. Fast path: after folding negative zero, any negative value is less than any positive value.
-                if (_Left_negative != _Right_negative) {
-                    return _Left_negative ? weak_ordering::less : weak_ordering::greater;
+                if (_Left_magnitude > _Infinity_plus_one) {
+                    _Left_uint = _Left_shifted_sign | _Infinity_plus_one;
                 }
 
-                // 5. Clear the (identical) sign bits. We've already stored them for use at the end.
-                _Left_uint &= ~_Traits::_Shifted_sign_mask;
-                _Right_uint &= ~_Traits::_Shifted_sign_mask;
+                if (_Right_magnitude > _Infinity_plus_one) {
+                    _Right_uint = _Right_shifted_sign | _Infinity_plus_one;
+                }
 
-                // 6. Fold all NaN values together.
-                // (The fact that _Infinity_plus_one represents a signaling NaN is irrelevant here.)
-                constexpr _Uint_type _Infinity_plus_one = _Traits::_Shifted_exponent_mask + 1;
+                // 4. Interpret floating-point bit patterns as sign magnitude representations of integers,
+                //    and then transform them into two's complement representation.
+                // (Two's complement representations of positive zero and negative zero are the same.)
+                const _Uint_type _Left_sign  = _Left_shifted_sign >> _Traits::_Sign_shift;
+                const _Uint_type _Right_sign = _Right_shifted_sign >> _Traits::_Sign_shift;
 
-                if (_Left_uint > _Infinity_plus_one) {
-                    _Left_uint = _Infinity_plus_one;
-                }
+                const _Uint_type _Left_xor  = _Left_shifted_sign - _Left_sign;
+                const _Uint_type _Right_xor = _Right_shifted_sign - _Right_sign;
 
-                if (_Right_uint > _Infinity_plus_one) {
-                    _Right_uint = _Infinity_plus_one;
-                }
+                const _Uint_type _Left_twos_complement_uint  = (_Left_uint ^ _Left_xor) + _Left_sign;
+                const _Uint_type _Right_twos_complement_uint = (_Right_uint ^ _Right_xor) + _Right_sign;
 
-                // 7. Perform the final comparison, reversed for negative values.
-                // (For example, 1.5 is less than 2.5, but -1.5 is greater than -2.5.)
-                if (_Left_negative) {
-                    return static_cast<weak_ordering>(_Right_uint <=> _Left_uint);
-                } else {
-                    return static_cast<weak_ordering>(_Left_uint <=> _Right_uint);
-                }
+                const auto _Left_twos_complement  = static_cast<_Sint_type>(_Left_twos_complement_uint);
+                const auto _Right_twos_complement = static_cast<_Sint_type>(_Right_twos_complement_uint);
+
+                // 5. Perform the final comparison.
+                return static_cast<weak_ordering>(_Left_twos_complement <=> _Right_twos_complement);
             } else if constexpr (_Strat == _St::_Three) {
                 return static_cast<weak_ordering>(compare_three_way{}(_Left, _Right));
             } else if constexpr (_Strat == _St::_Strong) {

stl/inc/complex

@@ -60,10 +60,10 @@ struct _C_ldouble_complex {
 
 _STD_BEGIN
 
-// implements multi-precision floating point arithmetic for numerical algorithms
+// implements multi-precision floating-point arithmetic for numerical algorithms
 #pragma float_control(precise, on, push)
 namespace _Float_multi_prec {
-    // multi-precision floating point types
+    // multi-precision floating-point types
     template <class _Ty, int _Prec>
     struct _Fmp_t;
 
@@ -1877,7 +1877,7 @@ _Ty _Fabs(const complex<_Ty>& _Left, int* _Pexp) { // Used by sqrt(), return mag
             _Bv    = _Bv * static_cast<_Ty>(0.0625);
         } else {
             constexpr _Ty _Flt_eps = _Ctraits<_Ty>::_Flt_eps();
-            // TRANSITION, workaround for non floating point _Ty
+            // TRANSITION, workaround for non-floating-point _Ty
             constexpr _Ty _Leg_tiny = _Flt_eps == 0 ? _Ty{0} : 2 * _Ctraits<_Ty>::_Flt_norm_min() / _Flt_eps;
 
             if (_Av < _Leg_tiny) {
@@ -1914,7 +1914,7 @@ _Ty _Fabs(const complex<_Ty>& _Left, int* _Pexp) { // Used by sqrt(), return mag
 
 // FUNCTION TEMPLATE log
 template <class _Ty>
-_NODISCARD _Ty _Log_abs(const complex<_Ty>& _Left) noexcept { // for double, long double, and non floating point types
+_NODISCARD _Ty _Log_abs(const complex<_Ty>& _Left) noexcept { // for double, long double, and non-floating-point types
     return static_cast<_Ty>(
         _Math_algorithms::_Log_hypot(static_cast<double>(_STD real(_Left)), static_cast<double>(_STD imag(_Left))));
 }

stl/inc/condition_variable

@@ -29,7 +29,7 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 template <class _Lock>
-struct _Unlock_guard {
+struct _NODISCARD _Unlock_guard {
     explicit _Unlock_guard(_Lock& _Mtx_) : _Mtx(_Mtx_) {
         _Mtx.unlock();
     }

stl/inc/coroutine

@@ -88,13 +88,14 @@ struct coroutine_handle<void> {
         __builtin_coro_destroy(_Ptr);
     }
 
-protected:
+private:
     void* _Ptr = nullptr;
 };
 
 template <class _Promise>
-struct coroutine_handle : coroutine_handle<> {
-    using coroutine_handle<>::coroutine_handle;
+struct coroutine_handle {
+    constexpr coroutine_handle() noexcept = default;
+    constexpr coroutine_handle(nullptr_t) noexcept {}
 
     _NODISCARD static coroutine_handle from_promise(_Promise& _Prom) noexcept { // strengthened
         const auto _Prom_ptr  = const_cast<void*>(static_cast<const volatile void*>(_STD addressof(_Prom)));
@@ -109,15 +110,46 @@ struct coroutine_handle : coroutine_handle<> {
         return *this;
     }
 
+    _NODISCARD constexpr void* address() const noexcept {
+        return _Ptr;
+    }
+
     _NODISCARD static constexpr coroutine_handle from_address(void* const _Addr) noexcept { // strengthened
         coroutine_handle _Result;
         _Result._Ptr = _Addr;
         return _Result;
     }
 
+    constexpr operator coroutine_handle<>() const noexcept {
+        return coroutine_handle<>::from_address(_Ptr);
+    }
+
+    constexpr explicit operator bool() const noexcept {
+        return _Ptr != nullptr;
+    }
+
+    _NODISCARD bool done() const noexcept { // strengthened
+        return __builtin_coro_done(_Ptr);
+    }
+
+    void operator()() const {
+        __builtin_coro_resume(_Ptr);
+    }
+
+    void resume() const {
+        __builtin_coro_resume(_Ptr);
+    }
+
+    void destroy() const noexcept { // strengthened
+        __builtin_coro_destroy(_Ptr);
+    }
+
     _NODISCARD _Promise& promise() const noexcept { // strengthened
         return *reinterpret_cast<_Promise*>(__builtin_coro_promise(_Ptr, 0, false));
     }
+
+private:
+    void* _Ptr = nullptr;
 };
 
 _NODISCARD constexpr bool operator==(const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {
@@ -145,9 +177,13 @@ struct noop_coroutine_promise {};
 
 // STRUCT coroutine_handle<noop_coroutine_promise>
 template <>
-struct coroutine_handle<noop_coroutine_promise> : coroutine_handle<> {
+struct coroutine_handle<noop_coroutine_promise> {
     friend coroutine_handle noop_coroutine() noexcept;
 
+    constexpr operator coroutine_handle<>() const noexcept {
+        return coroutine_handle<>::from_address(_Ptr);
+    }
+
     constexpr explicit operator bool() const noexcept {
         return true;
     }
@@ -159,17 +195,19 @@ struct coroutine_handle<noop_coroutine_promise> : coroutine_handle<> {
     constexpr void resume() const noexcept {}
     constexpr void destroy() const noexcept {}
 
-    using _Promise = noop_coroutine_promise;
-
-    _NODISCARD _Promise& promise() const noexcept {
+    _NODISCARD noop_coroutine_promise& promise() const noexcept {
         // Returns a reference to the associated promise
-        return *reinterpret_cast<_Promise*>(__builtin_coro_promise(_Ptr, 0, false));
+        return *reinterpret_cast<noop_coroutine_promise*>(__builtin_coro_promise(_Ptr, 0, false));
     }
 
-private:
-    coroutine_handle() noexcept {
-        _Ptr = __builtin_coro_noop();
+    _NODISCARD constexpr void* address() const noexcept {
+        return _Ptr;
     }
+
+private:
+    coroutine_handle() noexcept = default;
+
+    void* _Ptr = __builtin_coro_noop();
 };
 
 // ALIAS noop_coroutine_handle