From 8a9af811fe1d6ee81dd6e551ad32b03209832e22 Mon Sep 17 00:00:00 2001 From: "A. Jiang" Date: Fri, 9 Feb 2024 22:34:27 +0800 Subject: [PATCH 1/4] `_STD`-qualify UDT-related internal function calls for searchers --- stl/inc/functional | 76 +++++++++++++++++++++++----------------------- 1 file changed, 38 insertions(+), 38 deletions(-) diff --git a/stl/inc/functional b/stl/inc/functional index 3fe6623df3..d96a0c1e9d 100644 --- a/stl/inc/functional +++ b/stl/inc/functional @@ -2484,21 +2484,21 @@ public: _CONSTEXPR20 default_searcher(_FwdItPat _First, _FwdItPat _Last, _Pred_eq _Eq = _Pred_eq()) : _Data{_One_then_variadic_args_t{}, _STD move(_Eq), pair<_FwdItPat, _FwdItPat>{_First, _Last}} { const auto& _Pat = _Data._Myval2; - _Adl_verify_range(_Pat.first, _Pat.second); + _STD _Adl_verify_range(_Pat.first, _Pat.second); } template _NODISCARD _CONSTEXPR20 pair<_FwdItHaystack, _FwdItHaystack> operator()( _FwdItHaystack _First, _FwdItHaystack _Last) const { // search [_First, _Last) for the searcher's pattern - _Adl_verify_range(_First, _Last); + _STD _Adl_verify_range(_First, _Last); const auto& _Eq = _Data._Get_first(); const auto& _Pat = _Data._Myval2; - _Adl_verify_range(_Pat.first, _Pat.second); // check again to ensure container is not destroyed - const auto _Result = _Search_pair_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), - _Get_unwrapped(_Pat.first), _Get_unwrapped(_Pat.second), _Eq); - _Seek_wrapped(_Last, _Result.second); - _Seek_wrapped(_First, _Result.first); + _STD _Adl_verify_range(_Pat.first, _Pat.second); // check again to ensure container is not destroyed + const auto _Result = _STD _Search_pair_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), + _STD _Get_unwrapped(_Pat.first), _STD _Get_unwrapped(_Pat.second), _Eq); + _STD _Seek_wrapped(_Last, _Result.second); + _STD _Seek_wrapped(_First, _Result.first); return {_First, _Last}; } @@ -2678,15 +2678,15 @@ pair<_RanItHaystack, _RanItHaystack> _Boyer_moore_search( static_assert(is_same_v>, "boyer_moore_searcher requires matching iterator value types"); using _Diff = typename _Delta1_t::_Diff; - _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); const auto _Pat_size = _Delta1._Pat_size; if (_Pat_size == 0) { return {_First, _First}; } - const auto _UPat_first = _Get_unwrapped_n(_Delta1._Pat_first, _Pat_size); + const auto _UPat_first = _STD _Get_unwrapped_n(_Delta1._Pat_first, _Pat_size); const auto _Eq = _Delta1._Get_eq(); _Diff _Shift = _Pat_size - 1; while (_Shift < _ULast - _UFirst) { @@ -2696,8 +2696,8 @@ pair<_RanItHaystack, _RanItHaystack> _Boyer_moore_search( _Diff _Idx = _Pat_size - 1; do { if (_Idx == 0) { - _Seek_wrapped(_Last, _UFirst + _Pat_size); - _Seek_wrapped(_First, _UFirst); + _STD _Seek_wrapped(_Last, _UFirst + _Pat_size); + _STD _Seek_wrapped(_First, _UFirst); return {_First, _Last}; } @@ -2708,8 +2708,8 @@ pair<_RanItHaystack, _RanItHaystack> _Boyer_moore_search( } } - _Seek_wrapped(_Last, _ULast); - _Seek_wrapped(_First, _ULast); + _STD _Seek_wrapped(_Last, _ULast); + _STD _Seek_wrapped(_First, _ULast); return {_First, _Last}; } @@ -2719,15 +2719,15 @@ pair<_RanItHaystack, _RanItHaystack> _Boyer_moore_horspool_search( static_assert(is_same_v>, "boyer_moore_horspool_searcher requires matching iterator value types"); using _Diff = typename _Delta1_t::_Diff; - _Adl_verify_range(_First, _Last); + _STD _Adl_verify_range(_First, _Last); const auto _Pat_size = _Delta1._Pat_size; if (_Pat_size == 0) { return {_First, _First}; } - auto _UFirst = _Get_unwrapped(_First); - const auto _ULast = _Get_unwrapped(_Last); - const auto _UPat_first = _Get_unwrapped_n(_Delta1._Pat_first, _Pat_size); + auto _UFirst = _STD _Get_unwrapped(_First); + const auto _ULast = _STD _Get_unwrapped(_Last); + const auto _UPat_first = _STD _Get_unwrapped_n(_Delta1._Pat_first, _Pat_size); const auto _Eq = _Delta1._Get_eq(); _Diff _Shift = _Pat_size - 1; while (_Shift < _ULast - _UFirst) { @@ -2735,9 +2735,9 @@ pair<_RanItHaystack, _RanItHaystack> _Boyer_moore_horspool_search( _Shift = _Delta1._Lookup(*_UFirst); if (_Shift == 0) { // that is, *_UFirst == "_Pat.back()" const auto _Candidate = _UFirst - (_Pat_size - 1); - if (_STD equal(_UPat_first, _UPat_first + (_Pat_size - 1), _Candidate, _Pass_fn(_Eq))) { - _Seek_wrapped(_Last, _Candidate + _Pat_size); - _Seek_wrapped(_First, _Candidate); + if (_STD equal(_UPat_first, _UPat_first + (_Pat_size - 1), _Candidate, _STD _Pass_fn(_Eq))) { + _STD _Seek_wrapped(_Last, _Candidate + _Pat_size); + _STD _Seek_wrapped(_First, _Candidate); return {_First, _Last}; } @@ -2745,8 +2745,8 @@ pair<_RanItHaystack, _RanItHaystack> _Boyer_moore_horspool_search( } } - _Seek_wrapped(_Last, _ULast); - _Seek_wrapped(_First, _ULast); + _STD _Seek_wrapped(_Last, _ULast); + _STD _Seek_wrapped(_First, _ULast); return {_First, _Last}; } @@ -2763,9 +2763,9 @@ struct _Single_delta1_type_boyer_moore_traits { template static void* _Build_boyer_moore(_RanItPat _First, _RanItPat _Last, _Hash_ty _Hash_fn, _Pred_eq _Eq) { // builds data tables for the Boyer-Moore string search algorithm - _Adl_verify_range(_First, _Last); - const auto _UFirst = _Get_unwrapped(_First); - const auto _Pat_size_raw = _Get_unwrapped(_Last) - _UFirst; + _STD _Adl_verify_range(_First, _Last); + const auto _UFirst = _STD _Get_unwrapped(_First); + const auto _Pat_size_raw = _STD _Get_unwrapped(_Last) - _UFirst; using _CT = common_type_t<_Iter_diff_t<_RanItPat>, size_t>; if (static_cast<_CT>(_Pat_size_raw) > static_cast<_CT>(SIZE_MAX)) { _Xbad_alloc(); @@ -2784,7 +2784,7 @@ struct _Single_delta1_type_boyer_moore_traits { *_Decode_aligned_block<_Atomic_counter_t>(_Buf) = 1; void* const _Delta1 = _Decode_aligned_block<_Delta1_t>(_Buf); if (_Build_delta2) { - _Build_boyer_moore_delta_2_table( + _STD _Build_boyer_moore_delta_2_table( _Decode_aligned_block<_Diff>(_Buf, _Pat_size), _UFirst, _Pat_size_raw, _Eq); } @@ -2799,7 +2799,7 @@ struct _Single_delta1_type_boyer_moore_traits { (void) _Decode_aligned_block<_Atomic_counter_t>(_Data); const auto _Delta1 = _Decode_aligned_block<_Delta1_t>(_Data); const auto _Delta2 = _Decode_aligned_block<_Diff>(_Data, static_cast(_Delta1->_Pat_size)); - return _Boyer_moore_search(*_Delta1, _Delta2, _First, _Last); + return _STD _Boyer_moore_search(*_Delta1, _Delta2, _First, _Last); } template @@ -2808,7 +2808,7 @@ struct _Single_delta1_type_boyer_moore_traits { // decodes data tables for the Boyer-Moore string search algorithm (void) _Decode_aligned_block<_Atomic_counter_t>(_Data); const auto _Delta1 = _Decode_aligned_block<_Delta1_t>(_Data); - return _Boyer_moore_horspool_search(*_Delta1, _First, _Last); + return _STD _Boyer_moore_horspool_search(*_Delta1, _First, _Last); } static void _Destroy(void* const _Base) noexcept { @@ -2841,9 +2841,9 @@ struct _Boyer_moore_traits_wchar_t_mode { template static void* _Build_boyer_moore(_RanItPat _First, _RanItPat _Last, _Unused_parameter, _Unused_parameter) { // builds data tables for the Boyer-Moore string search algorithm - _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); const auto _Pat_size_raw = _ULast - _UFirst; using _CT = common_type_t<_Iter_diff_t<_RanItPat>, size_t>; if (static_cast<_CT>(_Pat_size_raw) > static_cast<_CT>(SIZE_MAX)) { @@ -2889,7 +2889,7 @@ struct _Boyer_moore_traits_wchar_t_mode { if (_Build_delta2) { equal_to<> _Eq; - _Build_boyer_moore_delta_2_table( + _STD _Build_boyer_moore_delta_2_table( _Decode_aligned_block<_Diff>(_Buf, _Pat_size), _UFirst, _Pat_size_raw, _Eq); } @@ -2904,11 +2904,11 @@ struct _Boyer_moore_traits_wchar_t_mode { if (*_Decode_aligned_block(_Data)) { const auto _Delta1 = _Decode_aligned_block<_Big_table_t>(_Data); const auto _Delta2 = _Decode_aligned_block<_Diff>(_Data, static_cast(_Delta1->_Pat_size)); - return _Boyer_moore_search(*_Delta1, _Delta2, _First, _Last); + return _STD _Boyer_moore_search(*_Delta1, _Delta2, _First, _Last); } else { const auto _Delta1 = _Decode_aligned_block<_Small_table_t>(_Data); const auto _Delta2 = _Decode_aligned_block<_Diff>(_Data, static_cast(_Delta1->_Pat_size)); - return _Boyer_moore_search(*_Delta1, _Delta2, _First, _Last); + return _STD _Boyer_moore_search(*_Delta1, _Delta2, _First, _Last); } } @@ -2919,10 +2919,10 @@ struct _Boyer_moore_traits_wchar_t_mode { (void) _Decode_aligned_block<_Atomic_counter_t>(_Data); if (*_Decode_aligned_block(_Data)) { const auto _Delta1 = _Decode_aligned_block<_Big_table_t>(_Data); - return _Boyer_moore_horspool_search(*_Delta1, _First, _Last); + return _STD _Boyer_moore_horspool_search(*_Delta1, _First, _Last); } else { const auto _Delta1 = _Decode_aligned_block<_Small_table_t>(_Data); - return _Boyer_moore_horspool_search(*_Delta1, _First, _Last); + return _STD _Boyer_moore_horspool_search(*_Delta1, _First, _Last); } } From 2fb1e261a9bca5fa346042f44e0078c48ee10472 Mon Sep 17 00:00:00 2001 From: "A. Jiang" Date: Fri, 9 Feb 2024 22:34:44 +0800 Subject: [PATCH 2/4] `_STD`-qualify `std::swap` --- stl/inc/functional | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/stl/inc/functional b/stl/inc/functional index d96a0c1e9d..380ec6ea74 100644 --- a/stl/inc/functional +++ b/stl/inc/functional @@ -2977,7 +2977,7 @@ public: boyer_moore_searcher& operator=(const boyer_moore_searcher& _Other) noexcept /* strengthened */ { boyer_moore_searcher _Cpy(_Other); - swap(_Data, _Cpy._Data); + _STD swap(_Data, _Cpy._Data); return *this; } @@ -3015,7 +3015,7 @@ public: boyer_moore_horspool_searcher& operator=(const boyer_moore_horspool_searcher& _Other) noexcept /* strengthened */ { boyer_moore_horspool_searcher _Cpy(_Other); - swap(_Data, _Cpy._Data); + _STD swap(_Data, _Cpy._Data); return *this; } From 4646cb1f292bce9fe3b7d1a02feca70f216555a6 Mon Sep 17 00:00:00 2001 From: "A. Jiang" Date: Fri, 9 Feb 2024 22:35:04 +0800 Subject: [PATCH 3/4] Test coverage - ADL-incompatible functors for all searchers, and - ADL-incompatible value type for `default_searcher`. --- tests/std/tests/P0220R1_searchers/test.cpp | 64 ++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/tests/std/tests/P0220R1_searchers/test.cpp b/tests/std/tests/P0220R1_searchers/test.cpp index b2ae5aa387..2c9fe972c4 100644 --- a/tests/std/tests/P0220R1_searchers/test.cpp +++ b/tests/std/tests/P0220R1_searchers/test.cpp @@ -437,6 +437,70 @@ void test_case_randomized_cases() { } } +#ifndef _M_CEE // TRANSITION, VSO-1659496 +template +struct tagged_hash { + std::size_t operator()(const T& t) const { + return std::hash{}(t); + } +}; + +template +struct tagged_equal { + template + constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) == std::forward(u)) { + return std::forward(t) == std::forward(u); + } +}; + +template +struct holder { + T t; +}; + +struct incomplete; + +template +using validating_hash = tagged_hash, T>; + +using validating_equal = tagged_equal>; + +void test_adl_proof_default_searcher_on_iterators() { + using validator = holder*; + validator varr[1]{}; + (void) std::search(varr, varr + 1, default_searcher{varr, varr + 1}); +} + +void test_adl_proof_default_searcher_on_functors() { + char carr[1]{}; + (void) std::search(carr, carr + 1, default_searcher{carr, carr + 1}); + + wchar_t wcarr[1]{}; + (void) std::search(wcarr, wcarr + 1, default_searcher{wcarr, wcarr + 1}); + + int iarr[1]{}; + (void) std::search(iarr, iarr + 1, default_searcher{iarr, iarr + 1}); +} + +template