From 069043998b243522473b8f352e1505449c0eb37e Mon Sep 17 00:00:00 2001 From: "A. Jiang" Date: Thu, 8 Feb 2024 15:45:47 +0800 Subject: [PATCH 1/9] Test coverage for non-sized sentinel code paths --- .../test.compile.pass.cpp | 58 ++++++++++++++++--- 1 file changed, 51 insertions(+), 7 deletions(-) diff --git a/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp b/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp index 7952c1e5ce8..c76a3fe19fb 100644 --- a/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp +++ b/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp @@ -17,6 +17,22 @@ struct tagged_truth { } }; +template +struct tagged_zeroer { + template + constexpr int operator()(T&&) const noexcept { + return 0; + } +}; + +template +struct tagged_true_comparator { + template + constexpr bool operator()(T&&, U&&) const noexcept { + return true; + } +}; + template struct tagged_equal { template @@ -57,6 +73,12 @@ struct tagged_zero_equality { } }; +template +struct tagged_base {}; + +template +struct tagged_derived : tagged_base {}; + template struct holder { T t; @@ -69,13 +91,22 @@ using simple_identity = tagged_identity; using simple_left_selector = tagged_left_selector; using simple_zero_equality = tagged_zero_equality; -using validator = holder*; -using validating_truth = tagged_truth>; -using validating_equal = tagged_equal>; -using validating_less = tagged_less>; -using validating_identity = tagged_identity>; -using validating_left_selector = tagged_left_selector>; -using validating_zero_equality = tagged_zero_equality>; +using validator = holder*; +using validating_truth = tagged_truth>; +using validating_zeroer = tagged_zeroer>; +using validating_true_comparator = tagged_true_comparator>; +using validating_equal = tagged_equal>; +using validating_less = tagged_less>; +using validating_identity = tagged_identity>; +using validating_left_selector = tagged_left_selector>; +using validating_zero_equality = tagged_zero_equality>; +using validating_derived = tagged_derived>; +using validating_base = tagged_base>; + +static_assert(std::sentinel_for); +#ifndef __EDG__ +static_assert(!std::sized_sentinel_for); +#endif // !defined(__EDG__) template bool less_function(T lhs, T rhs) { @@ -88,6 +119,10 @@ void test_ranges_algorithms() { int iarr[1]{}; validator varr[1]{}; + validating_derived darr[1]{}; + validating_derived* const dptr = darr; + validating_base* const bptr = darr; // behaves as a non-sized sentinel + (void) all_of(varr, varr, simple_truth{}); (void) all_of(varr, simple_truth{}); (void) all_of(iarr, iarr, validating_truth{}); @@ -161,6 +196,7 @@ void test_ranges_algorithms() { (void) find_end(varr, varr, validating_equal{}); (void) find_end(iarr, iarr, iarr, iarr, validating_equal{}); (void) find_end(iarr, iarr, validating_equal{}); + (void) find_end(dptr, bptr, dptr, bptr, validating_true_comparator{}); (void) find_first_of(varr, varr, varr, varr); (void) find_first_of(varr, varr); @@ -175,6 +211,7 @@ void test_ranges_algorithms() { (void) adjacent_find(iarr, iarr, {}, validating_identity{}); // (void) adjacent_find(iarr, validating_equal{}); // needs to check ADL-found swap (void) adjacent_find(iarr, {}, validating_identity{}); + (void) adjacent_find(dptr, bptr, validating_true_comparator{}); (void) count(varr, varr, validator{}); (void) count(varr, validator{}); @@ -190,11 +227,13 @@ void test_ranges_algorithms() { (void) mismatch(varr, varr); (void) mismatch(iarr, iarr, iarr, iarr, validating_equal{}); (void) mismatch(iarr, iarr, validating_equal{}); + (void) mismatch(dptr, bptr, dptr, bptr, validating_true_comparator{}); (void) equal(varr, varr, varr, varr); (void) equal(varr, varr); (void) equal(iarr, iarr, iarr, iarr, validating_equal{}); (void) equal(iarr, iarr, validating_equal{}); + (void) equal(dptr, bptr, dptr, bptr, validating_true_comparator{}); (void) is_permutation(varr, varr, varr, varr); (void) is_permutation(varr, varr); @@ -204,22 +243,26 @@ void test_ranges_algorithms() { (void) is_permutation(iarr, iarr, validating_equal{}); (void) is_permutation(iarr, iarr, iarr, iarr, {}, validating_identity{}); (void) is_permutation(iarr, iarr, {}, validating_identity{}); + (void) is_permutation(dptr, bptr, dptr, bptr, validating_true_comparator{}); (void) search(varr, varr, varr, varr); (void) search(varr, varr); (void) search(iarr, iarr, iarr, iarr, validating_equal{}); (void) search(iarr, iarr, validating_equal{}); + (void) search(dptr, bptr, dptr, bptr, validating_true_comparator{}); (void) search_n(varr, varr, 0, validator{}); (void) search_n(varr, 0, validator{}); (void) search_n(iarr, iarr, 0, 0, validating_equal{}); (void) search_n(iarr, 0, 0, validating_equal{}); + (void) search_n(dptr, bptr, 0, validating_derived{}, validating_true_comparator{}); #if _HAS_CXX23 (void) starts_with(varr, varr, varr, varr); (void) starts_with(varr, varr); (void) starts_with(iarr, iarr, iarr, iarr, validating_equal{}); (void) starts_with(iarr, iarr, validating_equal{}); + (void) starts_with(dptr, bptr, dptr, bptr, validating_true_comparator{}); (void) ends_with(varr, varr, varr, varr); (void) ends_with(varr, varr); @@ -402,6 +445,7 @@ void test_ranges_algorithms() { (void) partition_point(varr, simple_zero_equality{}); (void) partition_point(iarr, iarr, validating_zero_equality{}); (void) partition_point(iarr, validating_zero_equality{}); + (void) partition_point(dptr, bptr, validating_zero_equality{}, validating_zeroer{}); (void) merge(varr, varr, varr2, varr2, varr3); (void) merge(varr, varr2, varr3); From ad179945331386a07c95f4578520a45194ac8a4c Mon Sep 17 00:00:00 2001 From: "A. Jiang" Date: Thu, 8 Feb 2024 16:51:29 +0800 Subject: [PATCH 2/9] `_STD`- and `_RANGES`-qualify internal names --- stl/inc/memory | 230 ++++++++++++++++++++++++------------------------ stl/inc/xmemory | 44 ++++----- 2 files changed, 137 insertions(+), 137 deletions(-) diff --git a/stl/inc/memory b/stl/inc/memory index 384a7b1e0c9..046356b77e9 100644 --- a/stl/inc/memory +++ b/stl/inc/memory @@ -59,14 +59,14 @@ namespace ranges { requires constructible_from, iter_reference_t<_It>> _STATIC_CALL_OPERATOR uninitialized_copy_result<_It, _Out> operator()( _It _First1, _Se _Last1, _Out _First2, _OSe _Last2) _CONST_CALL_OPERATOR { - _Adl_verify_range(_First1, _Last1); - _Adl_verify_range(_First2, _Last2); - auto _UResult = _Uninitialized_copy_unchecked(_Unwrap_iter<_Se>(_STD move(_First1)), - _Unwrap_sent<_It>(_STD move(_Last1)), _Unwrap_iter<_OSe>(_STD move(_First2)), - _Unwrap_sent<_Out>(_STD move(_Last2))); - - _Seek_wrapped(_First1, _STD move(_UResult.in)); - _Seek_wrapped(_First2, _STD move(_UResult.out)); + _STD _Adl_verify_range(_First1, _Last1); + _STD _Adl_verify_range(_First2, _Last2); + auto _UResult = _Uninitialized_copy_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First1)), + _RANGES _Unwrap_sent<_It>(_STD move(_Last1)), _RANGES _Unwrap_iter<_OSe>(_STD move(_First2)), + _RANGES _Unwrap_sent<_Out>(_STD move(_Last2))); + + _STD _Seek_wrapped(_First1, _STD move(_UResult.in)); + _STD _Seek_wrapped(_First2, _STD move(_UResult.out)); return {_STD move(_First1), _STD move(_First2)}; } @@ -76,10 +76,10 @@ namespace ranges { operator()(_Rng1&& _Range1, _Rng2&& _Range2) _CONST_CALL_OPERATOR { auto _First1 = _RANGES begin(_Range1); auto _UResult = _Uninitialized_copy_unchecked( - _Unwrap_range_iter<_Rng1>(_STD move(_First1)), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2)); + _RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2)); - _Seek_wrapped(_First1, _STD move(_UResult.in)); - return {_STD move(_First1), _Rewrap_iterator(_Range2, _STD move(_UResult.out))}; + _STD _Seek_wrapped(_First1, _STD move(_UResult.in)); + return {_STD move(_First1), _RANGES _Rewrap_iterator(_Range2, _STD move(_UResult.out))}; } private: @@ -98,12 +98,12 @@ namespace ranges { && _Sized_or_unreachable_sentinel_for<_Se, _It> && _Sized_or_unreachable_sentinel_for<_OSe, _Out>) { if constexpr (_Is_sized1 && _Is_sized2) { - return _Copy_memcpy_common(_IFirst, _RANGES next(_IFirst, _STD move(_ILast)), _OFirst, + return _RANGES _Copy_memcpy_common(_IFirst, _RANGES next(_IFirst, _STD move(_ILast)), _OFirst, _RANGES next(_OFirst, _STD move(_OLast))); } else if constexpr (_Is_sized1) { - return _Copy_memcpy_distance(_IFirst, _OFirst, _IFirst, _RANGES next(_IFirst, _STD move(_ILast))); + return _RANGES _Copy_memcpy_distance(_IFirst, _OFirst, _IFirst, _RANGES next(_IFirst, _STD move(_ILast))); } else if constexpr (_Is_sized2) { - return _Copy_memcpy_distance(_IFirst, _OFirst, _OFirst, _RANGES next(_OFirst, _STD move(_OLast))); + return _RANGES _Copy_memcpy_distance(_IFirst, _OFirst, _OFirst, _RANGES next(_OFirst, _STD move(_OLast))); } else { _STL_ASSERT(false, "Tried to uninitialized_copy two ranges with unreachable sentinels"); } @@ -131,10 +131,10 @@ _NoThrowFwdIt uninitialized_copy_n(const _InIt _First, const _Diff _Count_raw, _ return _Dest; } - auto _UFirst = _Get_unwrapped_n(_First, _Count); - auto _UDest = _Get_unwrapped_n(_Dest, _Count); + auto _UFirst = _STD _Get_unwrapped_n(_First, _Count); + auto _UDest = _STD _Get_unwrapped_n(_Dest, _Count); if constexpr (_Iter_copy_cat::_Bitcopy_constructible) { - _UDest = _Copy_memmove_n(_UFirst, static_cast(_Count), _UDest); + _UDest = _STD _Copy_memmove_n(_UFirst, static_cast(_Count), _UDest); } else { _Uninitialized_backout _Backout{_UDest}; @@ -145,7 +145,7 @@ _NoThrowFwdIt uninitialized_copy_n(const _InIt _First, const _Diff _Count_raw, _ _UDest = _Backout._Release(); } - _Seek_wrapped(_Dest, _UDest); + _STD _Seek_wrapped(_Dest, _UDest); return _Dest; } @@ -179,19 +179,19 @@ namespace ranges { return {_STD move(_First1), _STD move(_First2)}; } - _Adl_verify_range(_First2, _Last2); - auto _IFirst = _Get_unwrapped_n(_STD move(_First1), _Count); - auto _OFirst = _Unwrap_iter<_OSe>(_STD move(_First2)); - auto _OLast = _Unwrap_sent<_Out>(_STD move(_Last2)); + _STD _Adl_verify_range(_First2, _Last2); + auto _IFirst = _STD _Get_unwrapped_n(_STD move(_First1), _Count); + auto _OFirst = _RANGES _Unwrap_iter<_OSe>(_STD move(_First2)); + auto _OLast = _RANGES _Unwrap_sent<_Out>(_STD move(_Last2)); if constexpr (_Iter_copy_cat<_It, _Out>::_Bitcopy_constructible && _Sized_or_unreachable_sentinel_for<_OSe, _Out>) { if constexpr (sized_sentinel_for<_OSe, _Out>) { - auto _UResult = _Copy_memcpy_common( + auto _UResult = _RANGES _Copy_memcpy_common( _IFirst, _IFirst + _Count, _OFirst, _RANGES next(_OFirst, _STD move(_OLast))); _IFirst = _STD move(_UResult.in); _OFirst = _STD move(_UResult.out); } else { - auto _UResult = _Copy_memcpy_count(_IFirst, _OFirst, static_cast(_Count)); + auto _UResult = _RANGES _Copy_memcpy_count(_IFirst, _OFirst, static_cast(_Count)); _IFirst = _STD move(_UResult.in); _OFirst = _STD move(_UResult.out); } @@ -205,8 +205,8 @@ namespace ranges { _OFirst = _Backout._Release(); } - _Seek_wrapped(_First1, _STD move(_IFirst)); - _Seek_wrapped(_First2, _STD move(_OFirst)); + _STD _Seek_wrapped(_First1, _STD move(_IFirst)); + _STD _Seek_wrapped(_First2, _STD move(_OFirst)); return {_STD move(_First1), _STD move(_First2)}; } }; @@ -219,11 +219,11 @@ namespace ranges { _EXPORT_STD template _NoThrowFwdIt uninitialized_move(const _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) { // move [_First, _Last) to raw [_Dest, ...) - _Adl_verify_range(_First, _Last); - const auto _UFirst = _Get_unwrapped(_First); - const auto _ULast = _Get_unwrapped(_Last); - const auto _UDest = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast)); - _Seek_wrapped(_Dest, _STD _Uninitialized_move_unchecked(_UFirst, _ULast, _UDest)); + _STD _Adl_verify_range(_First, _Last); + const auto _UFirst = _STD _Get_unwrapped(_First); + const auto _ULast = _STD _Get_unwrapped(_Last); + const auto _UDest = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast)); + _STD _Seek_wrapped(_Dest, _STD _Uninitialized_move_unchecked(_UFirst, _ULast, _UDest)); return _Dest; } @@ -247,14 +247,14 @@ namespace ranges { requires constructible_from, iter_rvalue_reference_t<_It>> _STATIC_CALL_OPERATOR uninitialized_move_result<_It, _Out> operator()( _It _First1, _Se _Last1, _Out _First2, _OSe _Last2) _CONST_CALL_OPERATOR { - _Adl_verify_range(_First1, _Last1); - _Adl_verify_range(_First2, _Last2); - auto _UResult = _RANGES _Uninitialized_move_unchecked(_Unwrap_iter<_Se>(_STD move(_First1)), - _Unwrap_sent<_It>(_STD move(_Last1)), _Unwrap_iter<_OSe>(_STD move(_First2)), - _Unwrap_sent<_Out>(_STD move(_Last2))); - - _Seek_wrapped(_First1, _STD move(_UResult.in)); - _Seek_wrapped(_First2, _STD move(_UResult.out)); + _STD _Adl_verify_range(_First1, _Last1); + _STD _Adl_verify_range(_First2, _Last2); + auto _UResult = _RANGES _Uninitialized_move_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First1)), + _RANGES _Unwrap_sent<_It>(_STD move(_Last1)), _RANGES _Unwrap_iter<_OSe>(_STD move(_First2)), + _RANGES _Unwrap_sent<_Out>(_STD move(_Last2))); + + _STD _Seek_wrapped(_First1, _STD move(_UResult.in)); + _STD _Seek_wrapped(_First2, _STD move(_UResult.out)); return {_STD move(_First1), _STD move(_First2)}; } @@ -264,10 +264,10 @@ namespace ranges { operator()(_Rng1&& _Range1, _Rng2&& _Range2) _CONST_CALL_OPERATOR { auto _First1 = _RANGES begin(_Range1); auto _UResult = _RANGES _Uninitialized_move_unchecked( - _Unwrap_range_iter<_Rng1>(_STD move(_First1)), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2)); + _RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2)); - _Seek_wrapped(_First1, _STD move(_UResult.in)); - return {_STD move(_First1), _Rewrap_iterator(_Range2, _STD move(_UResult.out))}; + _STD _Seek_wrapped(_First1, _STD move(_UResult.in)); + return {_STD move(_First1), _RANGES _Rewrap_iterator(_Range2, _STD move(_UResult.out))}; } }; @@ -283,10 +283,10 @@ pair<_InIt, _NoThrowFwdIt> uninitialized_move_n(_InIt _First, const _Diff _Count return {_First, _Dest}; } - auto _UFirst = _Get_unwrapped_n(_First, _Count); - auto _UDest = _Get_unwrapped_n(_Dest, _Count); + auto _UFirst = _STD _Get_unwrapped_n(_First, _Count); + auto _UDest = _STD _Get_unwrapped_n(_Dest, _Count); if constexpr (_Iter_move_cat::_Bitcopy_constructible) { - _UDest = _Copy_memmove_n(_UFirst, static_cast(_Count), _UDest); + _UDest = _STD _Copy_memmove_n(_UFirst, static_cast(_Count), _UDest); _UFirst += _Count; } else { _Uninitialized_backout _Backout{_UDest}; @@ -298,8 +298,8 @@ pair<_InIt, _NoThrowFwdIt> uninitialized_move_n(_InIt _First, const _Diff _Count _UDest = _Backout._Release(); } - _Seek_wrapped(_Dest, _UDest); - _Seek_wrapped(_First, _UFirst); + _STD _Seek_wrapped(_Dest, _UDest); + _STD _Seek_wrapped(_First, _UFirst); return {_First, _Dest}; } @@ -342,19 +342,19 @@ namespace ranges { return {_STD move(_First1), _STD move(_First2)}; } - _Adl_verify_range(_First2, _Last2); - auto _IFirst = _Get_unwrapped_n(_STD move(_First1), _Count); - auto _OFirst = _Unwrap_iter<_OSe>(_STD move(_First2)); - const auto _OLast = _Unwrap_sent<_Out>(_STD move(_Last2)); + _STD _Adl_verify_range(_First2, _Last2); + auto _IFirst = _STD _Get_unwrapped_n(_STD move(_First1), _Count); + auto _OFirst = _RANGES _Unwrap_iter<_OSe>(_STD move(_First2)); + const auto _OLast = _RANGES _Unwrap_sent<_Out>(_STD move(_Last2)); if constexpr (_Iter_move_cat<_It, _Out>::_Bitcopy_constructible && _Sized_or_unreachable_sentinel_for<_OSe, _Out>) { if constexpr (sized_sentinel_for<_OSe, _Out>) { - auto _UResult = _Copy_memcpy_common( + auto _UResult = _RANGES _Copy_memcpy_common( _IFirst, _IFirst + _Count, _OFirst, _RANGES next(_OFirst, _STD move(_OLast))); _IFirst = _STD move(_UResult.in); _OFirst = _STD move(_UResult.out); } else { - auto _UResult = _Copy_memcpy_count(_IFirst, _OFirst, static_cast(_Count)); + auto _UResult = _RANGES _Copy_memcpy_count(_IFirst, _OFirst, static_cast(_Count)); _IFirst = _STD move(_UResult.in); _OFirst = _STD move(_UResult.out); } @@ -368,8 +368,8 @@ namespace ranges { _OFirst = _Backout._Release(); } - _Seek_wrapped(_First1, _STD move(_IFirst)); - _Seek_wrapped(_First2, _STD move(_OFirst)); + _STD _Seek_wrapped(_First1, _STD move(_IFirst)); + _STD _Seek_wrapped(_First2, _STD move(_OFirst)); return {_STD move(_First1), _STD move(_First2)}; } }; @@ -381,11 +381,11 @@ namespace ranges { template <_No_throw_forward_iterator _It, _No_throw_sentinel_for<_It> _Se, class _Ty> requires constructible_from, const _Ty&> _STATIC_CALL_OPERATOR _It operator()(_It _First, _Se _Last, const _Ty& _Val) _CONST_CALL_OPERATOR { - _Adl_verify_range(_First, _Last); + _STD _Adl_verify_range(_First, _Last); auto _UResult = _Uninitialized_fill_unchecked( - _Unwrap_iter<_Se>(_STD move(_First)), _Unwrap_sent<_It>(_STD move(_Last)), _Val); + _RANGES _Unwrap_iter<_Se>(_STD move(_First)), _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _Val); - _Seek_wrapped(_First, _STD move(_UResult)); + _STD _Seek_wrapped(_First, _STD move(_UResult)); return _First; } @@ -393,7 +393,7 @@ namespace ranges { requires constructible_from, const _Ty&> _STATIC_CALL_OPERATOR borrowed_iterator_t<_Rng> operator()( _Rng&& _Range, const _Ty& _Val) _CONST_CALL_OPERATOR { - return _Rewrap_iterator(_Range, _Uninitialized_fill_unchecked(_Ubegin(_Range), _Uend(_Range), _Val)); + return _RANGES _Rewrap_iterator(_Range, _Uninitialized_fill_unchecked(_Ubegin(_Range), _Uend(_Range), _Val)); } private: @@ -405,13 +405,13 @@ namespace ranges { if constexpr (_Fill_memset_is_safe<_It, _Ty>) { const auto _OFinal = _RANGES next(_OFirst, _STD move(_OLast)); - _Fill_memset(_OFirst, _Val, static_cast(_OFinal - _OFirst)); + _STD _Fill_memset(_OFirst, _Val, static_cast(_OFinal - _OFirst)); return _OFinal; } else { if constexpr (_Fill_zero_memset_is_safe<_It, _Ty>) { - if (_Is_all_bits_zero(_Val)) { + if (_STD _Is_all_bits_zero(_Val)) { const auto _OFinal = _RANGES next(_OFirst, _STD move(_OLast)); - _Fill_zero_memset(_OFirst, static_cast(_OFinal - _OFirst)); + _STD _Fill_zero_memset(_OFirst, static_cast(_OFinal - _OFirst)); return _OFinal; } } @@ -439,15 +439,15 @@ _NoThrowFwdIt uninitialized_fill_n(_NoThrowFwdIt _First, const _Diff _Count_raw, return _First; } - auto _UFirst = _Get_unwrapped_n(_First, _Count); + auto _UFirst = _STD _Get_unwrapped_n(_First, _Count); if constexpr (_Fill_memset_is_safe) { - _Fill_memset(_UFirst, _Val, static_cast(_Count)); + _STD _Fill_memset(_UFirst, _Val, static_cast(_Count)); _UFirst += _Count; } else { if constexpr (_Fill_zero_memset_is_safe) { - if (_Is_all_bits_zero(_Val)) { - _Fill_zero_memset(_UFirst, static_cast(_Count)); - _Seek_wrapped(_First, _UFirst + _Count); + if (_STD _Is_all_bits_zero(_Val)) { + _STD _Fill_zero_memset(_UFirst, static_cast(_Count)); + _STD _Seek_wrapped(_First, _UFirst + _Count); return _First; } } @@ -461,7 +461,7 @@ _NoThrowFwdIt uninitialized_fill_n(_NoThrowFwdIt _First, const _Diff _Count_raw, _UFirst = _Backout._Release(); } - _Seek_wrapped(_First, _UFirst); + _STD _Seek_wrapped(_First, _UFirst); return _First; } @@ -492,15 +492,15 @@ namespace ranges { return _First; } - auto _UFirst = _Get_unwrapped_n(_STD move(_First), _Count); + auto _UFirst = _STD _Get_unwrapped_n(_STD move(_First), _Count); if constexpr (_Fill_memset_is_safe) { - _Fill_memset(_UFirst, _Val, static_cast(_Count)); - _Seek_wrapped(_First, _UFirst + _Count); + _STD _Fill_memset(_UFirst, _Val, static_cast(_Count)); + _STD _Seek_wrapped(_First, _UFirst + _Count); } else { if constexpr (_Fill_zero_memset_is_safe) { - if (_Is_all_bits_zero(_Val)) { - _Fill_zero_memset(_UFirst, static_cast(_Count)); - _Seek_wrapped(_First, _UFirst + _Count); + if (_STD _Is_all_bits_zero(_Val)) { + _STD _Fill_zero_memset(_UFirst, static_cast(_Count)); + _STD _Seek_wrapped(_First, _UFirst + _Count); return _First; } } @@ -511,7 +511,7 @@ namespace ranges { _Backout._Emplace_back(_Val); } - _Seek_wrapped(_First, _Backout._Release()); + _STD _Seek_wrapped(_First, _Backout._Release()); } return _First; } @@ -564,8 +564,8 @@ namespace ranges { _EXPORT_STD template _CONSTEXPR20 void destroy(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) { // destroy all elements in [_First, _Last) - _Adl_verify_range(_First, _Last); - _Destroy_range(_Get_unwrapped(_First), _Get_unwrapped(_Last)); + _STD _Adl_verify_range(_First, _Last); + _STD _Destroy_range(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last)); } _EXPORT_STD template = 0> @@ -592,9 +592,9 @@ namespace ranges { template <_No_throw_input_iterator _It, _No_throw_sentinel_for<_It> _Se> requires destructible> _STATIC_CALL_OPERATOR constexpr _It operator()(_It _First, _Se _Last) _CONST_CALL_OPERATOR noexcept { - _Adl_verify_range(_First, _Last); - _Seek_wrapped(_First, - _RANGES _Destroy_unchecked(_Unwrap_iter<_Se>(_STD move(_First)), _Unwrap_sent<_It>(_STD move(_Last)))); + _STD _Adl_verify_range(_First, _Last); + _STD _Seek_wrapped(_First, + _RANGES _Destroy_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)), _RANGES _Unwrap_sent<_It>(_STD move(_Last)))); return _First; } @@ -603,8 +603,8 @@ namespace ranges { _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()( _Rng&& _Range) _CONST_CALL_OPERATOR noexcept { auto _First = _RANGES begin(_Range); - _Seek_wrapped( - _First, _RANGES _Destroy_unchecked(_Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range))); + _STD _Seek_wrapped( + _First, _RANGES _Destroy_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range))); return _First; } }; @@ -621,16 +621,16 @@ _CONSTEXPR20 _NoThrowFwdIt destroy_n(_NoThrowFwdIt _First, const _Diff _Count_ra return _First; } - auto _UFirst = _Get_unwrapped_n(_First, _Count); + auto _UFirst = _STD _Get_unwrapped_n(_First, _Count); if constexpr (is_trivially_destructible_v<_Iter_value_t<_NoThrowFwdIt>>) { _STD advance(_UFirst, _Count); } else { for (; _Count > 0; --_Count, (void) ++_UFirst) { - _Destroy_in_place(*_UFirst); + _STD _Destroy_in_place(*_UFirst); } } - _Seek_wrapped(_First, _UFirst); + _STD _Seek_wrapped(_First, _UFirst); return _First; } @@ -650,7 +650,7 @@ namespace ranges { return _First; } - auto _UFirst = _Get_unwrapped_n(_STD move(_First), _Count); + auto _UFirst = _STD _Get_unwrapped_n(_STD move(_First), _Count); if constexpr (is_trivially_destructible_v>) { _RANGES advance(_UFirst, _Count); } else { @@ -661,7 +661,7 @@ namespace ranges { } while (_Count > 0); } - _Seek_wrapped(_First, _STD move(_UFirst)); + _STD _Seek_wrapped(_First, _STD move(_UFirst)); return _First; } }; @@ -674,12 +674,12 @@ _EXPORT_STD template void uninitialized_default_construct(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) { // default-initialize all elements in [_First, _Last) using _Ty = remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>; - _Adl_verify_range(_First, _Last); + _STD _Adl_verify_range(_First, _Last); if constexpr (!is_trivially_default_constructible_v<_Ty>) { - _Uninitialized_backout _Backout{_Get_unwrapped(_First)}; + _Uninitialized_backout _Backout{_STD _Get_unwrapped(_First)}; - for (const auto _ULast = _Get_unwrapped(_Last); _Backout._Last != _ULast; ++_Backout._Last) { - _Default_construct_in_place(*_Backout._Last); + for (const auto _ULast = _STD _Get_unwrapped(_Last); _Backout._Last != _ULast; ++_Backout._Last) { + _STD _Default_construct_in_place(*_Backout._Last); } _Backout._Release(); @@ -696,11 +696,11 @@ namespace ranges { template <_No_throw_forward_iterator _It, _No_throw_sentinel_for<_It> _Se> requires default_initializable> _STATIC_CALL_OPERATOR _It operator()(_It _First, _Se _Last) _CONST_CALL_OPERATOR { - _Adl_verify_range(_First, _Last); + _STD _Adl_verify_range(_First, _Last); auto _UResult = _Uninitialized_default_construct_unchecked( - _Unwrap_iter<_Se>(_STD move(_First)), _Unwrap_sent<_It>(_STD move(_Last))); + _RANGES _Unwrap_iter<_Se>(_STD move(_First)), _RANGES _Unwrap_sent<_It>(_STD move(_Last))); - _Seek_wrapped(_First, _STD move(_UResult)); + _STD _Seek_wrapped(_First, _STD move(_UResult)); return _First; } @@ -709,7 +709,7 @@ namespace ranges { _STATIC_CALL_OPERATOR borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) _CONST_CALL_OPERATOR { auto _UResult = _Uninitialized_default_construct_unchecked(_Ubegin(_Range), _Uend(_Range)); - return _Rewrap_iterator(_Range, _STD move(_UResult)); + return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult)); } private: @@ -727,7 +727,7 @@ namespace ranges { _Uninitialized_backout _Backout{_STD move(_OFirst)}; for (; _Backout._Last != _OLast; ++_Backout._Last) { - _Default_construct_in_place(*_Backout._Last); + _STD _Default_construct_in_place(*_Backout._Last); } return _Backout._Release(); @@ -751,13 +751,13 @@ _NoThrowFwdIt uninitialized_default_construct_n(_NoThrowFwdIt _First, const _Dif if constexpr (is_trivially_default_constructible_v<_Ty>) { _STD advance(_First, _Count); } else { - _Uninitialized_backout _Backout{_Get_unwrapped_n(_First, _Count)}; + _Uninitialized_backout _Backout{_STD _Get_unwrapped_n(_First, _Count)}; for (; _Count > 0; ++_Backout._Last, (void) --_Count) { - _Default_construct_in_place(*_Backout._Last); + _STD _Default_construct_in_place(*_Backout._Last); } - _Seek_wrapped(_First, _Backout._Release()); + _STD _Seek_wrapped(_First, _Backout._Release()); } return _First; } @@ -781,13 +781,13 @@ namespace ranges { if constexpr (is_trivially_default_constructible_v<_Ty>) { _RANGES advance(_First, _Count); } else { - _Uninitialized_backout _Backout{_Get_unwrapped_n(_STD move(_First), _Count)}; + _Uninitialized_backout _Backout{_STD _Get_unwrapped_n(_STD move(_First), _Count)}; for (; _Count > 0; --_Count, (void) ++_Backout._Last) { - _Default_construct_in_place(*_Backout._Last); + _STD _Default_construct_in_place(*_Backout._Last); } - _Seek_wrapped(_First, _Backout._Release()); + _STD _Seek_wrapped(_First, _Backout._Release()); } return _First; } @@ -800,11 +800,11 @@ namespace ranges { _EXPORT_STD template void uninitialized_value_construct(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) { // value-initialize all elements in [_First, _Last) - _Adl_verify_range(_First, _Last); - const auto _UFirst = _Get_unwrapped(_First); - const auto _ULast = _Get_unwrapped(_Last); + _STD _Adl_verify_range(_First, _Last); + const auto _UFirst = _STD _Get_unwrapped(_First); + const auto _ULast = _STD _Get_unwrapped(_Last); if constexpr (_Use_memset_value_construct_v<_Unwrapped_t>) { - _Zero_range(_UFirst, _ULast); + _STD _Zero_range(_UFirst, _ULast); } else { _Uninitialized_backout _Backout{_UFirst}; @@ -826,11 +826,11 @@ namespace ranges { template <_No_throw_forward_iterator _It, _No_throw_sentinel_for<_It> _Se> requires default_initializable> _STATIC_CALL_OPERATOR _It operator()(_It _First, _Se _Last) _CONST_CALL_OPERATOR { - _Adl_verify_range(_First, _Last); + _STD _Adl_verify_range(_First, _Last); auto _UResult = _Uninitialized_value_construct_unchecked( - _Unwrap_iter<_Se>(_STD move(_First)), _Unwrap_sent<_It>(_STD move(_Last))); + _RANGES _Unwrap_iter<_Se>(_STD move(_First)), _RANGES _Unwrap_sent<_It>(_STD move(_Last))); - _Seek_wrapped(_First, _STD move(_UResult)); + _STD _Seek_wrapped(_First, _STD move(_UResult)); return _First; } @@ -839,7 +839,7 @@ namespace ranges { _STATIC_CALL_OPERATOR borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) _CONST_CALL_OPERATOR { auto _UResult = _Uninitialized_value_construct_unchecked(_Ubegin(_Range), _Uend(_Range)); - return _Rewrap_iterator(_Range, _STD move(_UResult)); + return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult)); } private: @@ -850,7 +850,7 @@ namespace ranges { _STL_INTERNAL_STATIC_ASSERT(default_initializable>); if constexpr (_Use_memset_value_construct_v<_It>) { - return _Zero_range(_OFirst, _RANGES next(_OFirst, _STD move(_OLast))); + return _STD _Zero_range(_OFirst, _RANGES next(_OFirst, _STD move(_OLast))); } else { _Uninitialized_backout _Backout{_STD move(_OFirst)}; @@ -875,7 +875,7 @@ _NoThrowFwdIt uninitialized_value_construct_n(_NoThrowFwdIt _First, const _Diff return _First; } - _Seek_wrapped(_First, _Uninitialized_value_construct_n_unchecked1(_Get_unwrapped_n(_First, _Count), _Count)); + _STD _Seek_wrapped(_First, _STD _Uninitialized_value_construct_n_unchecked1(_STD _Get_unwrapped_n(_First, _Count), _Count)); return _First; } @@ -894,9 +894,9 @@ namespace ranges { return _First; } - auto _UFirst = _Get_unwrapped_n(_STD move(_First), _Count); + auto _UFirst = _STD _Get_unwrapped_n(_STD move(_First), _Count); if constexpr (_Use_memset_value_construct_v<_It>) { - _Seek_wrapped(_First, _Zero_range(_UFirst, _UFirst + _Count)); + _STD _Seek_wrapped(_First, _STD _Zero_range(_UFirst, _UFirst + _Count)); } else { _Uninitialized_backout _Backout{_STD move(_UFirst)}; @@ -904,7 +904,7 @@ namespace ranges { _Backout._Emplace_back(); } - _Seek_wrapped(_First, _Backout._Release()); + _STD _Seek_wrapped(_First, _Backout._Release()); } return _First; } diff --git a/stl/inc/xmemory b/stl/inc/xmemory index 1e524c0b1da..64a644fb8df 100644 --- a/stl/inc/xmemory +++ b/stl/inc/xmemory @@ -1114,7 +1114,7 @@ _CONSTEXPR20 void _Destroy_range(_NoThrowFwdIt _First, const _NoThrowSentinel _L // note that this is an optimization for debug mode codegen; in release mode the BE removes all of this if constexpr (!is_trivially_destructible_v<_Iter_value_t<_NoThrowFwdIt>>) { for (; _First != _Last; ++_First) { - _Destroy_in_place(*_First); + _STD _Destroy_in_place(*_First); } } } @@ -1686,8 +1686,8 @@ namespace ranges { template in_out_result<_InIt, _OutIt> _Copy_memcpy_count(_InIt _IFirst, _OutIt _OFirst, const size_t _Count) noexcept { - const auto _IFirstPtr = _To_address(_IFirst); - const auto _OFirstPtr = _To_address(_OFirst); + const auto _IFirstPtr = _STD _To_address(_IFirst); + const auto _OFirstPtr = _STD _To_address(_OFirst); const auto _IFirst_ch = const_cast(reinterpret_cast(_IFirstPtr)); const auto _OFirst_ch = const_cast(reinterpret_cast(_OFirstPtr)); const size_t _Count_bytes = _Count * sizeof(iter_value_t<_InIt>); @@ -1710,10 +1710,10 @@ namespace ranges { in_out_result<_InIt, _OutIt> _Copy_memcpy_distance( _InIt _IFirst, _OutIt _OFirst, const _DistIt _DFirst, const _DistIt _DLast) noexcept { // equivalent to _Copy_memcpy_count(_IFirst, _OFirst, _DLast - _DFirst) but computes distance more efficiently - const auto _IFirstPtr = _To_address(_IFirst); - const auto _OFirstPtr = _To_address(_OFirst); - const auto _DFirstPtr = _To_address(_DFirst); - const auto _DLastPtr = _To_address(_DLast); + const auto _IFirstPtr = _STD _To_address(_IFirst); + const auto _OFirstPtr = _STD _To_address(_OFirst); + const auto _DFirstPtr = _STD _To_address(_DFirst); + const auto _DLastPtr = _STD _To_address(_DLast); const auto _IFirst_ch = const_cast(reinterpret_cast(_IFirstPtr)); const auto _OFirst_ch = const_cast(reinterpret_cast(_OFirstPtr)); const auto _DFirst_ch = const_cast(reinterpret_cast(_DFirstPtr)); @@ -1916,7 +1916,7 @@ _CONSTEXPR20 _NoThrowFwdIt _Uninitialized_copy_unchecked(_InIt _First, const _In if (!_STD is_constant_evaluated()) #endif // _HAS_CXX20 { - return _Copy_memmove(_First, _Last, _Dest); + return _STD _Copy_memmove(_First, _Last, _Dest); } } @@ -1931,11 +1931,11 @@ _CONSTEXPR20 _NoThrowFwdIt _Uninitialized_copy_unchecked(_InIt _First, const _In _EXPORT_STD template _NoThrowFwdIt uninitialized_copy(const _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) { // copy [_First, _Last) to raw [_Dest, ...) - _Adl_verify_range(_First, _Last); - auto _UFirst = _Get_unwrapped(_First); - const auto _ULast = _Get_unwrapped(_Last); - auto _UDest = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast)); - _Seek_wrapped(_Dest, _Uninitialized_copy_unchecked(_UFirst, _ULast, _UDest)); + _STD _Adl_verify_range(_First, _Last); + auto _UFirst = _STD _Get_unwrapped(_First); + const auto _ULast = _STD _Get_unwrapped(_Last); + auto _UDest = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast)); + _STD _Seek_wrapped(_Dest, _STD _Uninitialized_copy_unchecked(_UFirst, _ULast, _UDest)); return _Dest; } @@ -2002,15 +2002,15 @@ _CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_fill_n( _EXPORT_STD template void uninitialized_fill(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, const _Tval& _Val) { // copy _Val throughout raw [_First, _Last) - _Adl_verify_range(_First, _Last); - auto _UFirst = _Get_unwrapped(_First); - const auto _ULast = _Get_unwrapped(_Last); + _STD _Adl_verify_range(_First, _Last); + auto _UFirst = _STD _Get_unwrapped(_First); + const auto _ULast = _STD _Get_unwrapped(_Last); if constexpr (_Fill_memset_is_safe<_Unwrapped_t, _Tval>) { - _Fill_memset(_UFirst, _Val, static_cast(_ULast - _UFirst)); + _STD _Fill_memset(_UFirst, _Val, static_cast(_ULast - _UFirst)); } else { if constexpr (_Fill_zero_memset_is_safe<_Unwrapped_t, _Tval>) { - if (_Is_all_bits_zero(_Val)) { - _Fill_zero_memset(_UFirst, static_cast(_ULast - _UFirst)); + if (_STD _Is_all_bits_zero(_Val)) { + _STD _Fill_zero_memset(_UFirst, static_cast(_ULast - _UFirst)); return; } } @@ -2032,8 +2032,8 @@ _INLINE_VAR constexpr bool _Use_memset_value_construct_v = template _Ptr _Zero_range(const _Ptr _First, const _Ptr _Last) { // fill [_First, _Last) with zeroes - char* const _First_ch = reinterpret_cast(_To_address(_First)); - char* const _Last_ch = reinterpret_cast(_To_address(_Last)); + char* const _First_ch = reinterpret_cast(_STD _To_address(_First)); + char* const _Last_ch = reinterpret_cast(_STD _To_address(_Last)); _CSTD memset(_First_ch, 0, static_cast(_Last_ch - _First_ch)); return _Last; } @@ -2067,7 +2067,7 @@ _NoThrowFwdIt _Uninitialized_value_construct_n_unchecked1(_NoThrowFwdIt _UFirst, // value-initialize all elements in [_UFirst, _UFirst + _Count) _STL_INTERNAL_CHECK(_Count >= 0); if constexpr (_Use_memset_value_construct_v<_NoThrowFwdIt>) { - return _Zero_range(_UFirst, _UFirst + _Count); + return _STD _Zero_range(_UFirst, _UFirst + _Count); } else { _Uninitialized_backout<_NoThrowFwdIt> _Backout{_UFirst}; for (; 0 < _Count; --_Count) { From f29f64c275f8268d56484eb0c95ae6f0f09f05d0 Mon Sep 17 00:00:00 2001 From: "A. Jiang" Date: Thu, 8 Feb 2024 17:01:47 +0800 Subject: [PATCH 3/9] Clang-format --- stl/inc/memory | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/stl/inc/memory b/stl/inc/memory index 046356b77e9..23de717a9fc 100644 --- a/stl/inc/memory +++ b/stl/inc/memory @@ -75,8 +75,8 @@ namespace ranges { _STATIC_CALL_OPERATOR uninitialized_copy_result, borrowed_iterator_t<_Rng2>> operator()(_Rng1&& _Range1, _Rng2&& _Range2) _CONST_CALL_OPERATOR { auto _First1 = _RANGES begin(_Range1); - auto _UResult = _Uninitialized_copy_unchecked( - _RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2)); + auto _UResult = _Uninitialized_copy_unchecked(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)), + _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2)); _STD _Seek_wrapped(_First1, _STD move(_UResult.in)); return {_STD move(_First1), _RANGES _Rewrap_iterator(_Range2, _STD move(_UResult.out))}; @@ -101,9 +101,11 @@ namespace ranges { return _RANGES _Copy_memcpy_common(_IFirst, _RANGES next(_IFirst, _STD move(_ILast)), _OFirst, _RANGES next(_OFirst, _STD move(_OLast))); } else if constexpr (_Is_sized1) { - return _RANGES _Copy_memcpy_distance(_IFirst, _OFirst, _IFirst, _RANGES next(_IFirst, _STD move(_ILast))); + return _RANGES _Copy_memcpy_distance( + _IFirst, _OFirst, _IFirst, _RANGES next(_IFirst, _STD move(_ILast))); } else if constexpr (_Is_sized2) { - return _RANGES _Copy_memcpy_distance(_IFirst, _OFirst, _OFirst, _RANGES next(_OFirst, _STD move(_OLast))); + return _RANGES _Copy_memcpy_distance( + _IFirst, _OFirst, _OFirst, _RANGES next(_OFirst, _STD move(_OLast))); } else { _STL_ASSERT(false, "Tried to uninitialized_copy two ranges with unreachable sentinels"); } @@ -263,8 +265,8 @@ namespace ranges { _STATIC_CALL_OPERATOR uninitialized_move_result, borrowed_iterator_t<_Rng2>> operator()(_Rng1&& _Range1, _Rng2&& _Range2) _CONST_CALL_OPERATOR { auto _First1 = _RANGES begin(_Range1); - auto _UResult = _RANGES _Uninitialized_move_unchecked( - _RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2)); + auto _UResult = _RANGES _Uninitialized_move_unchecked(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)), + _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2)); _STD _Seek_wrapped(_First1, _STD move(_UResult.in)); return {_STD move(_First1), _RANGES _Rewrap_iterator(_Range2, _STD move(_UResult.out))}; @@ -393,7 +395,8 @@ namespace ranges { requires constructible_from, const _Ty&> _STATIC_CALL_OPERATOR borrowed_iterator_t<_Rng> operator()( _Rng&& _Range, const _Ty& _Val) _CONST_CALL_OPERATOR { - return _RANGES _Rewrap_iterator(_Range, _Uninitialized_fill_unchecked(_Ubegin(_Range), _Uend(_Range), _Val)); + return _RANGES _Rewrap_iterator( + _Range, _Uninitialized_fill_unchecked(_Ubegin(_Range), _Uend(_Range), _Val)); } private: @@ -593,8 +596,8 @@ namespace ranges { requires destructible> _STATIC_CALL_OPERATOR constexpr _It operator()(_It _First, _Se _Last) _CONST_CALL_OPERATOR noexcept { _STD _Adl_verify_range(_First, _Last); - _STD _Seek_wrapped(_First, - _RANGES _Destroy_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)), _RANGES _Unwrap_sent<_It>(_STD move(_Last)))); + _STD _Seek_wrapped(_First, _RANGES _Destroy_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)), + _RANGES _Unwrap_sent<_It>(_STD move(_Last)))); return _First; } @@ -875,7 +878,8 @@ _NoThrowFwdIt uninitialized_value_construct_n(_NoThrowFwdIt _First, const _Diff return _First; } - _STD _Seek_wrapped(_First, _STD _Uninitialized_value_construct_n_unchecked1(_STD _Get_unwrapped_n(_First, _Count), _Count)); + _STD _Seek_wrapped( + _First, _STD _Uninitialized_value_construct_n_unchecked1(_STD _Get_unwrapped_n(_First, _Count), _Count)); return _First; } From aeab4b71525346135e29eb8ec188de9f92d11089 Mon Sep 17 00:00:00 2001 From: "A. Jiang" Date: Thu, 8 Feb 2024 17:02:17 +0800 Subject: [PATCH 4/9] Workaround for DevCom-10456452 --- stl/inc/new | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/new b/stl/inc/new index 6b6a8164e3e..850df643737 100644 --- a/stl/inc/new +++ b/stl/inc/new @@ -94,7 +94,7 @@ _EXPORT_STD template _NODISCARD_LAUNDER constexpr _Ty* launder(_Ty* _Ptr) noexcept { static_assert(!is_function_v<_Ty> && !is_void_v<_Ty>, "N4950 [ptr.launder]/1: Mandates: !is_function_v && !is_void_v is true."); - return __builtin_launder(_Ptr); + return ::__builtin_launder(_Ptr); // TRANSITION, DevCom-10456452, should not be qualified } #if defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM) || defined(_M_ARM64) From 7e51c15516187cc91cc1e5b9ffb70b880d840970 Mon Sep 17 00:00:00 2001 From: "A. Jiang" Date: Thu, 8 Feb 2024 17:04:51 +0800 Subject: [PATCH 5/9] Test coverage --- .../test.compile.pass.cpp | 194 ++++++++++++++++++ 1 file changed, 194 insertions(+) diff --git a/tests/std/tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp b/tests/std/tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp index e4d1e2fc036..61930b3b940 100644 --- a/tests/std/tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp +++ b/tests/std/tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp @@ -7,6 +7,8 @@ #if _HAS_CXX17 #include #endif // _HAS_CXX17 +#include +#include #include #include @@ -80,6 +82,22 @@ struct tagged_urng { result_type value_{}; }; +template +struct tagged_nontrivial { + tagged_nontrivial() noexcept {} + tagged_nontrivial(const tagged_nontrivial&) noexcept {} + tagged_nontrivial(tagged_nontrivial&&) noexcept {} + + tagged_nontrivial& operator=(const tagged_nontrivial&) noexcept { + return *this; + } + tagged_nontrivial& operator=(tagged_nontrivial&&) noexcept { + return *this; + } + + ~tagged_nontrivial() noexcept {} +}; + template struct tagged_left_selector { template @@ -109,6 +127,7 @@ using validating_identity = tagged_identity>; using validating_left_selector = tagged_left_selector>; using validating_zero_equality = tagged_zero_equality>; using validating_urng = tagged_urng>; +using validating_nontrivial = tagged_nontrivial>; #if _HAS_CXX20 using validating_compare_three_way = tagged_compare_three_way>; @@ -409,6 +428,70 @@ void test_algorithms() { // (void) std::prev_permutation(varr, varr); // requires Cpp17ValueSwappable (void) std::prev_permutation(iarr, iarr, validating_less{}); + + validating_nontrivial narr[1]{}; + validating_nontrivial narr2[1]{}; + +#if _HAS_CXX17 + std::uninitialized_default_construct(varr, varr); + std::uninitialized_default_construct(narr, narr); + + (void) std::uninitialized_default_construct_n(varr, 0); + (void) std::uninitialized_default_construct_n(narr, 0); + + std::uninitialized_value_construct(varr, varr); + std::uninitialized_value_construct(narr, narr); + + (void) std::uninitialized_value_construct_n(varr, 0); + (void) std::uninitialized_value_construct_n(narr, 0); +#endif // _HAS_CXX17 + + (void) std::uninitialized_copy(varr, varr, varr2); + (void) std::uninitialized_copy(narr, narr, narr2); + + (void) std::uninitialized_copy_n(varr, 0, varr2); + (void) std::uninitialized_copy_n(narr, 0, narr2); + +#if _HAS_CXX17 + (void) std::uninitialized_move(varr, varr, varr2); + (void) std::uninitialized_move(narr, narr, narr2); + + (void) std::uninitialized_move_n(varr, 0, varr2); + (void) std::uninitialized_move_n(narr, 0, narr2); +#endif // _HAS_CXX17 + + std::uninitialized_fill(varr, varr, validator{}); + std::uninitialized_fill(narr, narr, validating_nontrivial{}); + + (void) std::uninitialized_fill_n(varr, 0, validator{}); + (void) std::uninitialized_fill_n(narr, 0, validating_nontrivial{}); + + std::uninitialized_fill(varr, varr, validator{}); + std::uninitialized_fill(narr, narr, validating_nontrivial{}); + +#if _HAS_CXX20 + { + validator vx{}; + validating_nontrivial nx{}; + + std::construct_at(&vx); + std::construct_at(std::addressof(nx)); + } +#endif // _HAS_CXX20 + +#if _HAS_CXX17 + alignas(validator) alignas( + validating_nontrivial) unsigned char buffer[std::max(sizeof(validator), sizeof(validating_nontrivial))]{}; + + std::destroy_at(new (buffer) validator{}); + std::destroy_at(new (buffer) validating_nontrivial{}); + + std::destroy(varr, varr); + std::destroy(narr, narr); + + (void) std::destroy_n(varr, 0); + (void) std::destroy_n(narr, 0); +#endif // _HAS_CXX17 } #if _HAS_CXX17 @@ -619,6 +702,45 @@ void test_per_execution_policy() { (void) std::lexicographical_compare(ExecutionPolicy, varr, varr, varr, varr); (void) std::lexicographical_compare(ExecutionPolicy, iarr, iarr, iarr, iarr, validating_less{}); + + validating_nontrivial narr[1]{}; + validating_nontrivial narr2[1]{}; + + std::uninitialized_default_construct(ExecutionPolicy, varr, varr); + std::uninitialized_default_construct(ExecutionPolicy, narr, narr); + + (void) std::uninitialized_default_construct_n(ExecutionPolicy, varr, 0); + (void) std::uninitialized_default_construct_n(ExecutionPolicy, narr, 0); + + std::uninitialized_value_construct(ExecutionPolicy, varr, varr); + std::uninitialized_value_construct(ExecutionPolicy, narr, narr); + + (void) std::uninitialized_value_construct_n(ExecutionPolicy, varr, 0); + (void) std::uninitialized_value_construct_n(ExecutionPolicy, narr, 0); + + (void) std::uninitialized_copy(ExecutionPolicy, varr, varr, varr2); + (void) std::uninitialized_copy(ExecutionPolicy, narr, narr, narr2); + + (void) std::uninitialized_copy_n(ExecutionPolicy, varr, 0, varr2); + (void) std::uninitialized_copy_n(ExecutionPolicy, narr, 0, narr2); + + (void) std::uninitialized_move(ExecutionPolicy, varr, varr, varr2); + (void) std::uninitialized_move(ExecutionPolicy, narr, narr, narr2); + + (void) std::uninitialized_move_n(ExecutionPolicy, varr, 0, varr2); + (void) std::uninitialized_move_n(ExecutionPolicy, narr, 0, narr2); + + std::uninitialized_fill(ExecutionPolicy, varr, varr, validator{}); + std::uninitialized_fill(ExecutionPolicy, narr, narr, validating_nontrivial{}); + + (void) std::uninitialized_fill_n(ExecutionPolicy, varr, 0, validator{}); + (void) std::uninitialized_fill_n(ExecutionPolicy, narr, 0, validating_nontrivial{}); + + std::destroy(ExecutionPolicy, varr, varr); + std::destroy(ExecutionPolicy, narr, narr); + + (void) std::destroy_n(ExecutionPolicy, varr, 0); + (void) std::destroy_n(ExecutionPolicy, narr, 0); } void test_parallel_algorithms() { @@ -729,6 +851,78 @@ void test_ranges_non_projected_algorithms() { (void) shift_right(varr, varr, 0); (void) shift_right(varr, 0); #endif // _HAS_CXX23 + + validating_nontrivial narr[1]{}; + validating_nontrivial narr2[1]{}; + + (void) uninitialized_default_construct(varr, varr); + (void) uninitialized_default_construct(varr); + (void) uninitialized_default_construct(narr, narr); + (void) uninitialized_default_construct(narr); + + (void) uninitialized_default_construct_n(varr, 0); + (void) uninitialized_default_construct_n(narr, 0); + + (void) uninitialized_value_construct(varr, varr); + (void) uninitialized_value_construct(varr); + (void) uninitialized_value_construct(narr, narr); + (void) uninitialized_value_construct(narr); + + (void) uninitialized_value_construct_n(varr, 0); + (void) uninitialized_value_construct_n(narr, 0); + + (void) uninitialized_copy(varr, varr, varr2, varr2); + (void) uninitialized_copy(narr, narr, narr2, narr2); + (void) uninitialized_copy(varr, varr2); + (void) uninitialized_copy(narr, narr2); + + (void) uninitialized_copy_n(varr, 0, varr2, varr2); + (void) uninitialized_copy_n(narr, 0, narr2, narr2); + + (void) uninitialized_move(varr, varr, varr2, varr2); + (void) uninitialized_move(narr, narr, narr2, narr2); + (void) uninitialized_move(varr, varr2); + (void) uninitialized_move(narr, narr2); + + (void) uninitialized_move_n(varr, 0, varr2, varr2); + (void) uninitialized_move_n(narr, 0, narr2, narr2); + + (void) uninitialized_fill(varr, varr, validator{}); + (void) uninitialized_fill(varr, validator{}); + (void) uninitialized_fill(narr, narr, validating_nontrivial{}); + (void) uninitialized_fill(narr, validating_nontrivial{}); + + (void) uninitialized_fill_n(varr, 0, validator{}); + (void) uninitialized_fill_n(narr, 0, validating_nontrivial{}); + + { + alignas(validator) unsigned char buf[sizeof(validator)]; + const auto pv = construct_at(reinterpret_cast(buf)); + destroy_at(pv); + } + { + alignas(validating_nontrivial) unsigned char buf[sizeof(validating_nontrivial)]; + const auto pn = construct_at(reinterpret_cast(buf)); + destroy_at(pn); + } + + { + alignas(validator[1]) unsigned char buf[sizeof(validator[1])]; + ::new (buf) validator[1]; + auto& arr = *std::launder(reinterpret_cast(buf)); + destroy(arr, arr); + destroy(arr); + } + { + alignas(validating_nontrivial[1]) unsigned char buf[sizeof(validating_nontrivial[1])]; + ::new (buf) validating_nontrivial[1]; + auto& arr = *std::launder(reinterpret_cast(buf)); + destroy(arr, arr); + destroy(arr); + } + + (void) destroy_n(varr, 0); + (void) destroy_n(narr, 0); } #endif // _HAS_CXX20 #endif // ^^^ no workaround ^^^ From 27db1a6a655b62ecdc16c751a6b748d19b1de5e2 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Thu, 8 Feb 2024 11:50:57 -0800 Subject: [PATCH 6/9] Drop repeated lines. --- .../tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/tests/std/tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp b/tests/std/tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp index 61930b3b940..20454468b7d 100644 --- a/tests/std/tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp +++ b/tests/std/tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp @@ -466,9 +466,6 @@ void test_algorithms() { (void) std::uninitialized_fill_n(varr, 0, validator{}); (void) std::uninitialized_fill_n(narr, 0, validating_nontrivial{}); - std::uninitialized_fill(varr, varr, validator{}); - std::uninitialized_fill(narr, narr, validating_nontrivial{}); - #if _HAS_CXX20 { validator vx{}; From 51310b3c44ea9cfacc82d2ab275878ccc81fd40b Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Thu, 8 Feb 2024 11:52:02 -0800 Subject: [PATCH 7/9] Also test ends_with. --- .../tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp b/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp index c76a3fe19fb..3d0b35ac3c8 100644 --- a/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp +++ b/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp @@ -268,6 +268,7 @@ void test_ranges_algorithms() { (void) ends_with(varr, varr); (void) ends_with(iarr, iarr, iarr, iarr, validating_equal{}); (void) ends_with(iarr, iarr, validating_equal{}); + (void) ends_with(dptr, bptr, dptr, bptr, validating_true_comparator{}); #endif // _HAS_CXX23 int iarr2[1]{}; From b8d71b4801b746fd92abcb9b247b6ccb7235fa7b Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Thu, 8 Feb 2024 11:54:24 -0800 Subject: [PATCH 8/9] Cite DevCom-10581519 with "no workaround" comment. --- .../P2538R1_adl_proof_std_projected/test.compile.pass.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp b/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp index 3d0b35ac3c8..7e5dd31a397 100644 --- a/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp +++ b/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp @@ -104,9 +104,9 @@ using validating_derived = tagged_derived>; using validating_base = tagged_base>; static_assert(std::sentinel_for); -#ifndef __EDG__ +#ifndef __EDG__ // TRANSITION, DevCom-10581519 static_assert(!std::sized_sentinel_for); -#endif // !defined(__EDG__) +#endif // ^^^ no workaround ^^^ template bool less_function(T lhs, T rhs) { From 881f11d138a98bca02f0772df7bea637e725961b Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Thu, 8 Feb 2024 11:58:05 -0800 Subject: [PATCH 9/9] Guard the `__builtin_launder` workaround for MSVC only. --- stl/inc/new | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/stl/inc/new b/stl/inc/new index 850df643737..035add36166 100644 --- a/stl/inc/new +++ b/stl/inc/new @@ -94,7 +94,11 @@ _EXPORT_STD template _NODISCARD_LAUNDER constexpr _Ty* launder(_Ty* _Ptr) noexcept { static_assert(!is_function_v<_Ty> && !is_void_v<_Ty>, "N4950 [ptr.launder]/1: Mandates: !is_function_v && !is_void_v is true."); - return ::__builtin_launder(_Ptr); // TRANSITION, DevCom-10456452, should not be qualified +#if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-10456452 + return __builtin_launder(_Ptr); +#else // ^^^ no workaround / workaround vvv + return ::__builtin_launder(_Ptr); +#endif // ^^^ workaround ^^^ } #if defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM) || defined(_M_ARM64)