Various cleanups (#2140)

StephanTLavavej · web-flow · commit 18d8f37c990f · 2021-08-26T18:31:36.000-07:00
diff --git a/stl/inc/algorithm b/stl/inc/algorithm
@@ -41,7 +41,7 @@ _STD_BEGIN
 _INLINE_VAR constexpr int _ISORT_MAX = 32; // maximum size for insertion sort
 
 template <class _It>
-_INLINE_VAR constexpr auto _Isort_max = _Iter_diff_t<_It>{_ISORT_MAX};
+_INLINE_VAR constexpr _Iter_diff_t<_It> _Isort_max{_ISORT_MAX};
 
 template <class _Diff>
 constexpr ptrdiff_t _Temporary_buffer_size(const _Diff _Value) noexcept {
diff --git a/stl/inc/cvt/wbuffer b/stl/inc/cvt/wbuffer
@@ -254,7 +254,7 @@ namespace stdext {
                 if (_Mystrbuf && _Status != _Wrote) {
                     // got buffer, haven't written, try to compose an element
                     if (_Status != _Eof) {
-                        if (_Str.size() == 0) {
+                        if (_Str.empty()) {
                             _Status = _Need;
                         } else {
                             _Status = _Got;
diff --git a/stl/inc/exception b/stl/inc/exception
@@ -264,25 +264,27 @@ public:
         return __ExceptionPtrCompare(&_Lhs, &_Rhs);
     }
 
-    _NODISCARD friend bool operator==(nullptr_t, const exception_ptr& _Rhs) noexcept {
-        return !_Rhs;
-    }
-
     _NODISCARD friend bool operator==(const exception_ptr& _Lhs, nullptr_t) noexcept {
         return !_Lhs;
     }
 
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator==(nullptr_t, const exception_ptr& _Rhs) noexcept {
+        return !_Rhs;
+    }
+
     _NODISCARD friend bool operator!=(const exception_ptr& _Lhs, const exception_ptr& _Rhs) noexcept {
         return !(_Lhs == _Rhs);
     }
 
-    _NODISCARD friend bool operator!=(nullptr_t _Lhs, const exception_ptr& _Rhs) noexcept {
+    _NODISCARD friend bool operator!=(const exception_ptr& _Lhs, nullptr_t _Rhs) noexcept {
         return !(_Lhs == _Rhs);
     }
 
-    _NODISCARD friend bool operator!=(const exception_ptr& _Lhs, nullptr_t _Rhs) noexcept {
+    _NODISCARD friend bool operator!=(nullptr_t _Lhs, const exception_ptr& _Rhs) noexcept {
         return !(_Lhs == _Rhs);
     }
+#endif // !_HAS_CXX20
 
 private:
 #ifdef __clang__
diff --git a/stl/inc/experimental/coroutine b/stl/inc/experimental/coroutine
@@ -88,8 +88,9 @@ namespace experimental {
             return _Ptr;
         }
 
-        __declspec(
-            deprecated("is deprecated. Use coroutine_handle::address() instead")) void* to_address() const noexcept {
+        [[deprecated("coroutine_handle::to_address() is deprecated. "
+                     "Use coroutine_handle::address() instead.")]] void*
+            to_address() const noexcept {
             return _Ptr;
         }
 
@@ -131,8 +132,9 @@ namespace experimental {
     struct coroutine_handle : coroutine_handle<> { // general form
         using coroutine_handle<>::coroutine_handle;
 
-        __declspec(deprecated("with pointer parameter is deprecated. Use coroutine_handle::from_promise(T&) "
-                              "instead")) static coroutine_handle from_promise(_PromiseT* _Prom) noexcept {
+        [[deprecated("coroutine_handle::from_promise(T*) with pointer parameter is deprecated. "
+                     "Use coroutine_handle::from_promise(T&) instead.")]] static coroutine_handle
+            from_promise(_PromiseT* _Prom) noexcept {
             return from_promise(*_Prom);
         }
 
diff --git a/stl/inc/future b/stl/inc/future
@@ -1157,7 +1157,7 @@ public:
     }
 
     _NODISCARD future<_Ty> get_future() {
-        return future<_Ty>(_MyPromise._Get_state_for_future(), _Nil());
+        return future<_Ty>(_MyPromise._Get_state_for_future(), _Nil{});
     }
 
     void set_value(const _Ty& _Val) {
@@ -1219,7 +1219,7 @@ public:
     }
 
     _NODISCARD future<_Ty&> get_future() {
-        return future<_Ty&>(_MyPromise._Get_state_for_future(), _Nil());
+        return future<_Ty&>(_MyPromise._Get_state_for_future(), _Nil{});
     }
 
     void set_value(_Ty& _Val) {
@@ -1273,7 +1273,7 @@ public:
     }
 
     _NODISCARD future<void> get_future() {
-        return future<void>(_MyPromise._Get_state_for_future(), _Nil());
+        return future<void>(_MyPromise._Get_state_for_future(), _Nil{});
     }
 
     void set_value() {
@@ -1365,7 +1365,7 @@ public:
     }
 
     _NODISCARD future<_Ret> get_future() {
-        return future<_Ret>(_MyPromise._Get_state_for_future(), _Nil());
+        return future<_Ret>(_MyPromise._Get_state_for_future(), _Nil{});
     }
 
     void operator()(_ArgTypes... _Args) {
@@ -1494,7 +1494,7 @@ _NODISCARD future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> async(
         _Get_associated_state<_Ret>(_Policy, _Fake_no_copy_callable_adapter<_Fty, _ArgTypes...>(
                                                  _STD forward<_Fty>(_Fnarg), _STD forward<_ArgTypes>(_Args)...)));
 
-    return future<_Ret>(_Pr._Get_state_for_future(), _Nil());
+    return future<_Ret>(_Pr._Get_state_for_future(), _Nil{});
 }
 
 template <class _Fty, class... _ArgTypes>
diff --git a/stl/inc/random b/stl/inc/random
@@ -3011,7 +3011,7 @@ private:
                 _LogSx = _STD log(_Sx) + static_cast<_Ty>(_ExpMax) * (_Ln2 * 2);
             }
 
-            const auto _Fx = _Ty{_STD sqrt(_Ty{-2} * _LogSx / _Sx)};
+            const _Ty _Fx{_STD sqrt(_Ty{-2} * _LogSx / _Sx)};
             if (_Keep) { // save second value for next call
                 _Xx2   = _Fx * _Vx2;
                 _Valid = true;
diff --git a/stl/inc/stdatomic.h b/stl/inc/stdatomic.h
@@ -9,6 +9,10 @@
 #include <yvals.h>
 #if _STL_COMPILER_PREPROCESSOR
 
+#ifndef __cplusplus
+#error <stdatomic.h> is not yet supported when compiling as C, but this is planned for a future release.
+#endif // __cplusplus
+
 #ifdef _M_CEE_PURE
 #error <stdatomic.h> is not supported when compiling with /clr:pure.
 #endif // _M_CEE_PURE
diff --git a/stl/inc/string b/stl/inc/string
@@ -95,7 +95,7 @@ _NODISCARD inline int stoi(const string& _Str, size_t* _Idx = nullptr, int _Base
         _Xinvalid_argument("invalid stoi argument");
     }
 
-    if (_Errno_ref == ERANGE || _Ans < INT_MIN || INT_MAX < _Ans) {
+    if (_Errno_ref == ERANGE) {
         _Xout_of_range("stoi argument out of range");
     }
 
@@ -276,7 +276,7 @@ _NODISCARD inline int stoi(const wstring& _Str, size_t* _Idx = nullptr, int _Bas
         _Xinvalid_argument("invalid stoi argument");
     }
 
-    if (_Errno_ref == ERANGE || _Ans < INT_MIN || INT_MAX < _Ans) {
+    if (_Errno_ref == ERANGE) {
         _Xout_of_range("stoi argument out of range");
     }
 
diff --git a/stl/inc/tuple b/stl/inc/tuple
@@ -963,7 +963,7 @@ constexpr _Ret _Tuple_cat(index_sequence<_Kx...>, index_sequence<_Ix...>, _Ty&&
 template <class... _Tuples>
 _NODISCARD constexpr typename _Tuple_cat1<_Tuples...>::type tuple_cat(_Tuples&&... _Tpls) { // concatenate tuples
     using _Cat1 = _Tuple_cat1<_Tuples...>;
-    return _Tuple_cat<typename _Cat1::type>(typename _Cat1::_Kx_arg_seq(), typename _Cat1::_Ix_arg_seq(),
+    return _Tuple_cat<typename _Cat1::type>(typename _Cat1::_Kx_arg_seq{}, typename _Cat1::_Ix_arg_seq{},
         _STD forward_as_tuple(_STD forward<_Tuples>(_Tpls)...));
 }
 
diff --git a/stl/inc/xcharconv_ryu.h b/stl/inc/xcharconv_ryu.h
@@ -134,7 +134,6 @@ _NODISCARD inline uint64_t __double_to_bits(const double __d) {
 // vvvvvvvvvv DERIVED FROM d2s.h vvvvvvvvvv
 
 inline constexpr int __DOUBLE_MANTISSA_BITS = 52;
-inline constexpr int __DOUBLE_EXPONENT_BITS = 11;
 inline constexpr int __DOUBLE_BIAS = 1023;
 
 inline constexpr int __DOUBLE_POW5_INV_BITCOUNT = 122;
@@ -950,7 +949,6 @@ _NODISCARD inline to_chars_result __d2exp_buffered_n(char* _First, char* const _
 // vvvvvvvvvv DERIVED FROM f2s.c vvvvvvvvvv
 
 inline constexpr int __FLOAT_MANTISSA_BITS = 23;
-inline constexpr int __FLOAT_EXPONENT_BITS = 8;
 inline constexpr int __FLOAT_BIAS = 127;
 
 // This table is generated by PrintFloatLookupTable.
diff --git a/stl/inc/xlocmon b/stl/inc/xlocmon
@@ -360,7 +360,7 @@ protected:
             _State |= ios_base::eofbit;
         }
 
-        if (_Str.size() == 0) {
+        if (_Str.empty()) {
             _State |= ios_base::failbit; // _Getmfld failed
         } else { // convert to long double
             const char* _Eb = _Str.c_str();
@@ -476,7 +476,7 @@ private:
                     int _Fracdigseen        = 0;
                     int _Fracdigits         = _Ppunct_fac->frac_digits();
                     const string _Grouping  = _Ppunct_fac->grouping();
-                    const _Elem _Kseparator = _Grouping.size() == 0 ? _Elem{} : _Ppunct_fac->thousands_sep();
+                    const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Ppunct_fac->thousands_sep();
 
                     if (_Kseparator == _Elem{} || CHAR_MAX <= static_cast<unsigned char>(*_Grouping.c_str())) {
                         for (; _First != _Last && (_Idx = _Find_elem(_Atoms, *_First)) < 10; ++_First) {
@@ -540,7 +540,7 @@ private:
                         }
                     }
 
-                    if (_Val.size() == 0) {
+                    if (_Val.empty()) {
                         _Bad = true; // fail if no elements parsed
                     } else {
                         for (; _Fracdigseen < _Fracdigits; ++_Fracdigseen) {
diff --git a/stl/inc/xlocnum b/stl/inc/xlocnum
@@ -656,7 +656,7 @@ private:
         const locale& _Loc) const { // get integer field from [_First, _Last) into _Ac
         const auto& _Punct_fac  = _STD use_facet<numpunct<_Elem>>(_Loc);
         const string _Grouping  = _Punct_fac.grouping();
-        const _Elem _Kseparator = _Grouping.size() == 0 ? _Elem{} : _Punct_fac.thousands_sep();
+        const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Punct_fac.thousands_sep();
 
         constexpr int _Numget_signoff = 22;
         constexpr int _Numget_xoff    = 24;
@@ -812,7 +812,7 @@ private:
                 }
             }
         } else { // grouping specified, gather digits and group sizes
-            const _Elem _Kseparator = _Grouping.size() == 0 ? _Elem{} : _Punct_fac.thousands_sep();
+            const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Punct_fac.thousands_sep();
             string _Groups(1, '\0');
             size_t _Group = 0;
 
@@ -1003,7 +1003,7 @@ private:
                 }
             }
         } else { // grouping specified, gather digits and group sizes
-            const _Elem _Kseparator = _Grouping.size() == 0 ? _Elem{} : _Punct_fac.thousands_sep();
+            const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Punct_fac.thousands_sep();
             string _Groups(1, '\0');
             size_t _Group = 0;
 
diff --git a/stl/inc/xthreads.h b/stl/inc/xthreads.h
@@ -28,27 +28,27 @@ struct _Thrd_t { // thread identifier for Win32
 // Size and alignment for _Mtx_internal_imp_t and _Cnd_internal_imp_t
 #ifdef _CRT_WINDOWS
 #ifdef _WIN64
-#define _Mtx_internal_imp_size      32
-#define _Mtx_internal_imp_alignment 8
-#define _Cnd_internal_imp_size      16
-#define _Cnd_internal_imp_alignment 8
+_INLINE_VAR constexpr size_t _Mtx_internal_imp_size      = 32;
+_INLINE_VAR constexpr size_t _Mtx_internal_imp_alignment = 8;
+_INLINE_VAR constexpr size_t _Cnd_internal_imp_size      = 16;
+_INLINE_VAR constexpr size_t _Cnd_internal_imp_alignment = 8;
 #else // _WIN64
-#define _Mtx_internal_imp_size      20
-#define _Mtx_internal_imp_alignment 4
-#define _Cnd_internal_imp_size      8
-#define _Cnd_internal_imp_alignment 4
+_INLINE_VAR constexpr size_t _Mtx_internal_imp_size      = 20;
+_INLINE_VAR constexpr size_t _Mtx_internal_imp_alignment = 4;
+_INLINE_VAR constexpr size_t _Cnd_internal_imp_size      = 8;
+_INLINE_VAR constexpr size_t _Cnd_internal_imp_alignment = 4;
 #endif // _WIN64
 #else // _CRT_WINDOWS
 #ifdef _WIN64
-#define _Mtx_internal_imp_size      80
-#define _Mtx_internal_imp_alignment 8
-#define _Cnd_internal_imp_size      72
-#define _Cnd_internal_imp_alignment 8
+_INLINE_VAR constexpr size_t _Mtx_internal_imp_size      = 80;
+_INLINE_VAR constexpr size_t _Mtx_internal_imp_alignment = 8;
+_INLINE_VAR constexpr size_t _Cnd_internal_imp_size      = 72;
+_INLINE_VAR constexpr size_t _Cnd_internal_imp_alignment = 8;
 #else // _WIN64
-#define _Mtx_internal_imp_size      48
-#define _Mtx_internal_imp_alignment 4
-#define _Cnd_internal_imp_size      40
-#define _Cnd_internal_imp_alignment 4
+_INLINE_VAR constexpr size_t _Mtx_internal_imp_size      = 48;
+_INLINE_VAR constexpr size_t _Mtx_internal_imp_alignment = 4;
+_INLINE_VAR constexpr size_t _Cnd_internal_imp_size      = 40;
+_INLINE_VAR constexpr size_t _Cnd_internal_imp_alignment = 4;
 #endif // _WIN64
 #endif // _CRT_WINDOWS
 
diff --git a/stl/inc/xutility b/stl/inc/xutility
@@ -1276,10 +1276,10 @@ struct _Distance_unknown {
 };
 
 template <class _Diff>
-_INLINE_VAR constexpr auto _Max_possible_v = _Diff{static_cast<make_unsigned_t<_Diff>>(-1) >> 1};
+_INLINE_VAR constexpr _Diff _Max_possible_v{static_cast<make_unsigned_t<_Diff>>(-1) >> 1};
 
 template <class _Diff>
-_INLINE_VAR constexpr auto _Min_possible_v = _Diff{-_Max_possible_v<_Diff> - 1};
+_INLINE_VAR constexpr _Diff _Min_possible_v{-_Max_possible_v<_Diff> - 1};
 
 template <class _Iter, class = void>
 _INLINE_VAR constexpr bool _Offset_verifiable_v = false;
diff --git a/stl/src/cthread.cpp b/stl/src/cthread.cpp
@@ -33,7 +33,7 @@ namespace {
         *b.started = 1;
         _Cnd_signal(*b.cond);
         _Mtx_unlock(*b.mtx);
-        const unsigned int res = (b.func) (b.data);
+        const unsigned int res = b.func(b.data);
         _Cnd_do_broadcast_at_thread_exit();
         return res;
     }
diff --git a/stl/src/fiopen.cpp b/stl/src/fiopen.cpp
@@ -23,7 +23,7 @@ FILE* _Xfsopen(_In_z_ const wchar_t* filename, _In_ int mode, _In_ int prot) {
     return _wfsopen(filename, mods[mode], prot);
 }
 
-template <typename CharT>
+template <class CharT>
 FILE* _Xfiopen(const CharT* filename, ios_base::openmode mode, int prot) {
     static const int valid[] = {
         // valid combinations of open flags
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
@@ -281,16 +281,7 @@ std/utilities/memory/default.allocator/allocator.members/allocate.verify.cpp SKI
 
 
 # *** MISSING STL FEATURES ***
-# C++23 P1048R1 "is_scoped_enum"
-std/utilities/meta/meta.unary/meta.unary.prop/is_scoped_enum.pass.cpp FAIL
-
-# C++23 P1679R3 "contains() For basic_string/basic_string_view"
-std/strings/basic.string/string.contains/contains.char.pass.cpp FAIL
-std/strings/basic.string/string.contains/contains.ptr.pass.cpp FAIL
-std/strings/basic.string/string.contains/contains.string_view.pass.cpp FAIL
-std/strings/string.view/string.view.template/contains.char.pass.cpp FAIL
-std/strings/string.view/string.view.template/contains.ptr.pass.cpp FAIL
-std/strings/string.view/string.view.template/contains.string_view.pass.cpp FAIL
+# Nothing here! :-)
 
 
 # *** MISSING COMPILER FEATURES ***
diff --git a/tests/libcxx/skipped_tests.txt b/tests/libcxx/skipped_tests.txt
@@ -281,16 +281,7 @@ utilities\memory\default.allocator\allocator.members\allocate.verify.cpp
 
 
 # *** MISSING STL FEATURES ***
-# C++23 P1048R1 "is_scoped_enum"
-utilities\meta\meta.unary\meta.unary.prop\is_scoped_enum.pass.cpp
-
-# C++23 P1679R3 "contains() For basic_string/basic_string_view"
-strings\basic.string\string.contains\contains.char.pass.cpp
-strings\basic.string\string.contains\contains.ptr.pass.cpp
-strings\basic.string\string.contains\contains.string_view.pass.cpp
-strings\string.view\string.view.template\contains.char.pass.cpp
-strings\string.view\string.view.template\contains.ptr.pass.cpp
-strings\string.view\string.view.template\contains.string_view.pass.cpp
+# Nothing here! :-)
 
 
 # *** MISSING COMPILER FEATURES ***
diff --git a/tests/std/include/test_death.hpp b/tests/std/include/test_death.hpp
@@ -9,7 +9,7 @@
 #include <string>
 #include <vector>
 
-#include <test_windows.hpp>
+#include <Windows.h>
 
 namespace std_testing {
     constexpr int internal_failure = 103;
diff --git a/tests/std/include/test_thread_support.hpp b/tests/std/include/test_thread_support.hpp
@@ -10,7 +10,7 @@
 #include <stdlib.h>
 #include <thread>
 #ifdef _MSC_EXTENSIONS
-#include <test_windows.hpp>
+#include <Windows.h>
 #endif // _MSC_EXTENSIONS
 
 class one_shot {
diff --git a/tests/std/include/test_windows.hpp b/tests/std/include/test_windows.hpp
diff --git a/tests/std/tests/Dev08_563686_ostream/test.cpp b/tests/std/tests/Dev08_563686_ostream/test.cpp
@@ -29,7 +29,7 @@
 #include <sstream>
 #include <stdlib.h>
 
-#include <test_windows.hpp>
+#include <Windows.h>
 
 int main() {
     // Track CRT blocks
diff --git a/tests/std/tests/Dev09_056375_locale_cleanup/test.cpp b/tests/std/tests/Dev09_056375_locale_cleanup/test.cpp
@@ -5,7 +5,7 @@
 #include <locale>
 #include <stdio.h>
 
-#include <test_windows.hpp>
+#include <Windows.h>
 
 using namespace std;
 
diff --git a/tests/std/tests/Dev09_056375_locale_cleanup/testdll.cpp b/tests/std/tests/Dev09_056375_locale_cleanup/testdll.cpp
diff --git a/tests/std/tests/Dev11_0493504_error_category_lifetime/test.cpp b/tests/std/tests/Dev11_0493504_error_category_lifetime/test.cpp
diff --git a/tests/std/tests/VSO_0121275_filesystem_canonical_should_handle_many_double_dots/test.cpp b/tests/std/tests/VSO_0121275_filesystem_canonical_should_handle_many_double_dots/test.cpp
diff --git a/tests/std/tests/VSO_0226079_mutex/test.cpp b/tests/std/tests/VSO_0226079_mutex/test.cpp
diff --git a/tests/std/tests/VSO_0744055_atomic_load_8_bytes_readonly/test.cpp b/tests/std/tests/VSO_0744055_atomic_load_8_bytes_readonly/test.cpp

Original file line number	Diff line number	Diff line change
`@@ -264,25 +264,27 @@ public:`
`264`	`264`	`return __ExceptionPtrCompare(&_Lhs, &_Rhs);`
`265`	`265`	`}`
`266`	`266`
`267`		`- _NODISCARD friend bool operator==(nullptr_t, const exception_ptr& _Rhs) noexcept {`
`268`		`- return !_Rhs;`
`269`		`- }`
`270`		`-`
`271`	`267`	`_NODISCARD friend bool operator==(const exception_ptr& _Lhs, nullptr_t) noexcept {`
`272`	`268`	`return !_Lhs;`
`273`	`269`	`}`
`274`	`270`
	`271`	`+#if !_HAS_CXX20`
	`272`	`+ _NODISCARD friend bool operator==(nullptr_t, const exception_ptr& _Rhs) noexcept {`
	`273`	`+ return !_Rhs;`
	`274`	`+ }`
	`275`	`+`
`275`	`276`	`_NODISCARD friend bool operator!=(const exception_ptr& _Lhs, const exception_ptr& _Rhs) noexcept {`
`276`	`277`	`return !(_Lhs == _Rhs);`
`277`	`278`	`}`
`278`	`279`
`279`		`- _NODISCARD friend bool operator!=(nullptr_t _Lhs, const exception_ptr& _Rhs) noexcept {`
	`280`	`+ _NODISCARD friend bool operator!=(const exception_ptr& _Lhs, nullptr_t _Rhs) noexcept {`
`280`	`281`	`return !(_Lhs == _Rhs);`
`281`	`282`	`}`
`282`	`283`
`283`		`- _NODISCARD friend bool operator!=(const exception_ptr& _Lhs, nullptr_t _Rhs) noexcept {`
	`284`	`+ _NODISCARD friend bool operator!=(nullptr_t _Lhs, const exception_ptr& _Rhs) noexcept {`
`284`	`285`	`return !(_Lhs == _Rhs);`
`285`	`286`	`}`
	`287`	`+#endif // !_HAS_CXX20`
`286`	`288`
`287`	`289`	`private:`
`288`	`290`	`#ifdef __clang__`
Original file line number	Diff line number	Diff line change
`@@ -88,8 +88,9 @@ namespace experimental {`
`88`	`88`	`return _Ptr;`
`89`	`89`	`}`
`90`	`90`
`91`		`- __declspec(`
`92`		`- deprecated("is deprecated. Use coroutine_handle::address() instead")) void* to_address() const noexcept {`
	`91`	`+ [[deprecated("coroutine_handle::to_address() is deprecated. "`
	`92`	`+ "Use coroutine_handle::address() instead.")]] void*`
	`93`	`+ to_address() const noexcept {`
`93`	`94`	`return _Ptr;`
`94`	`95`	`}`
`95`	`96`
`@@ -131,8 +132,9 @@ namespace experimental {`
`131`	`132`	`struct coroutine_handle : coroutine_handle<> { // general form`
`132`	`133`	`using coroutine_handle<>::coroutine_handle;`
`133`	`134`
`134`		`- __declspec(deprecated("with pointer parameter is deprecated. Use coroutine_handle::from_promise(T&) "`
`135`		`- "instead")) static coroutine_handle from_promise(_PromiseT* _Prom) noexcept {`
	`135`	`+ [[deprecated("coroutine_handle::from_promise(T*) with pointer parameter is deprecated. "`
	`136`	`+ "Use coroutine_handle::from_promise(T&) instead.")]] static coroutine_handle`
	`137`	`+ from_promise(_PromiseT* _Prom) noexcept {`
`136`	`138`	`return from_promise(*_Prom);`
`137`	`139`	`}`
`138`	`140`
Original file line number	Diff line number	Diff line change
`@@ -1157,7 +1157,7 @@ public:`
`1157`	`1157`	`}`
`1158`	`1158`
`1159`	`1159`	`_NODISCARD future<_Ty> get_future() {`
`1160`		`- return future<_Ty>(_MyPromise._Get_state_for_future(), _Nil());`
	`1160`	`+ return future<_Ty>(_MyPromise._Get_state_for_future(), _Nil{});`
`1161`	`1161`	`}`
`1162`	`1162`
`1163`	`1163`	`void set_value(const _Ty& _Val) {`
`@@ -1219,7 +1219,7 @@ public:`
`1219`	`1219`	`}`
`1220`	`1220`
`1221`	`1221`	`_NODISCARD future<_Ty&> get_future() {`
`1222`		`- return future<_Ty&>(_MyPromise._Get_state_for_future(), _Nil());`
	`1222`	`+ return future<_Ty&>(_MyPromise._Get_state_for_future(), _Nil{});`
`1223`	`1223`	`}`
`1224`	`1224`
`1225`	`1225`	`void set_value(_Ty& _Val) {`
`@@ -1273,7 +1273,7 @@ public:`
`1273`	`1273`	`}`
`1274`	`1274`
`1275`	`1275`	`_NODISCARD future<void> get_future() {`
`1276`		`- return future<void>(_MyPromise._Get_state_for_future(), _Nil());`
	`1276`	`+ return future<void>(_MyPromise._Get_state_for_future(), _Nil{});`
`1277`	`1277`	`}`
`1278`	`1278`
`1279`	`1279`	`void set_value() {`
`@@ -1365,7 +1365,7 @@ public:`
`1365`	`1365`	`}`
`1366`	`1366`
`1367`	`1367`	`_NODISCARD future<_Ret> get_future() {`
`1368`		`- return future<_Ret>(_MyPromise._Get_state_for_future(), _Nil());`
	`1368`	`+ return future<_Ret>(_MyPromise._Get_state_for_future(), _Nil{});`
`1369`	`1369`	`}`
`1370`	`1370`
`1371`	`1371`	`void operator()(_ArgTypes... _Args) {`
`@@ -1494,7 +1494,7 @@ _NODISCARD future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> async(`
`1494`	`1494`	`_Get_associated_state<_Ret>(_Policy, _Fake_no_copy_callable_adapter<_Fty, _ArgTypes...>(`
`1495`	`1495`	`_STD forward<_Fty>(_Fnarg), _STD forward<_ArgTypes>(_Args)...)));`
`1496`	`1496`
`1497`		`- return future<_Ret>(_Pr._Get_state_for_future(), _Nil());`
	`1497`	`+ return future<_Ret>(_Pr._Get_state_for_future(), _Nil{});`
`1498`	`1498`	`}`
`1499`	`1499`
`1500`	`1500`	`template <class _Fty, class... _ArgTypes>`
Original file line number	Diff line number	Diff line change
`@@ -3011,7 +3011,7 @@ private:`
`3011`	`3011`	`_LogSx = _STD log(_Sx) + static_cast<_Ty>(_ExpMax) * (_Ln2 * 2);`
`3012`	`3012`	`}`
`3013`	`3013`
`3014`		`- const auto _Fx = _Ty{_STD sqrt(_Ty{-2} * _LogSx / _Sx)};`
	`3014`	`+ const _Ty _Fx{_STD sqrt(_Ty{-2} * _LogSx / _Sx)};`
`3015`	`3015`	`if (_Keep) { // save second value for next call`
`3016`	`3016`	`_Xx2 = _Fx * _Vx2;`
`3017`	`3017`	`_Valid = true;`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ _NODISCARD inline int stoi(const string& _Str, size_t* _Idx = nullptr, int _Base`
`95`	`95`	`_Xinvalid_argument("invalid stoi argument");`
`96`	`96`	`}`
`97`	`97`
`98`		`- if (_Errno_ref == ERANGE \|\| _Ans < INT_MIN \|\| INT_MAX < _Ans) {`
	`98`	`+ if (_Errno_ref == ERANGE) {`
`99`	`99`	`_Xout_of_range("stoi argument out of range");`
`100`	`100`	`}`
`101`	`101`
`@@ -276,7 +276,7 @@ _NODISCARD inline int stoi(const wstring& _Str, size_t* _Idx = nullptr, int _Bas`
`276`	`276`	`_Xinvalid_argument("invalid stoi argument");`
`277`	`277`	`}`
`278`	`278`
`279`		`- if (_Errno_ref == ERANGE \|\| _Ans < INT_MIN \|\| INT_MAX < _Ans) {`
	`279`	`+ if (_Errno_ref == ERANGE) {`
`280`	`280`	`_Xout_of_range("stoi argument out of range");`
`281`	`281`	`}`
`282`	`282`
Original file line number	Diff line number	Diff line change
`@@ -963,7 +963,7 @@ constexpr _Ret _Tuple_cat(index_sequence<_Kx...>, index_sequence<_Ix...>, _Ty&&`
`963`	`963`	`template <class... _Tuples>`
`964`	`964`	`_NODISCARD constexpr typename _Tuple_cat1<_Tuples...>::type tuple_cat(_Tuples&&... _Tpls) { // concatenate tuples`
`965`	`965`	`using _Cat1 = _Tuple_cat1<_Tuples...>;`
`966`		`- return _Tuple_cat<typename _Cat1::type>(typename _Cat1::_Kx_arg_seq(), typename _Cat1::_Ix_arg_seq(),`
	`966`	`+ return _Tuple_cat<typename _Cat1::type>(typename _Cat1::_Kx_arg_seq{}, typename _Cat1::_Ix_arg_seq{},`
`967`	`967`	`_STD forward_as_tuple(_STD forward<_Tuples>(_Tpls)...));`
`968`	`968`	`}`
`969`	`969`