Fix infinite ranges and prepare LWG issue

Author: miscco

stl/inc/algorithm

@@ -2226,13 +2226,13 @@ namespace ranges {
         // clang-format off
         template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
             class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
-            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+            requires (indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2> // Per LWG-issue unnumbered as of 17.09.2021
+                  && !(same_as<_Se1, unreachable_sentinel_t> && same_as<_Se2, unreachable_sentinel_t>))
         _NODISCARD constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {},
             _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
             // clang-format on
             _Adl_verify_range(_First1, _Last1);
             _Adl_verify_range(_First2, _Last2);
-
             if constexpr (same_as<_Se2, unreachable_sentinel_t>) {
                 return false;
             }
@@ -2261,7 +2261,9 @@ namespace ranges {
         // clang-format off
         template <input_range _Rng1, input_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
             class _Pj2 = identity>
-            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+            requires (indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+                  && !(same_as<sentinel_t<_Rng1>, unreachable_sentinel_t>
+                    && same_as<sentinel_t<_Rng2>, unreachable_sentinel_t>)) // Per LWG-issue unnumbered as of 17.09.2021
         _NODISCARD constexpr bool operator()(
                 _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
             // clang-format on
@@ -2301,74 +2303,67 @@ namespace ranges {
             requires (forward_iterator<_It1> || sized_sentinel_for<_Se1, _It1>)
                   && (forward_iterator<_It2> || sized_sentinel_for<_Se2, _It2>)
                   && indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+                  && (!same_as<_Se1, unreachable_sentinel_t>) // Per LWG-issue unnumbered as of 17.09.2021
         _NODISCARD constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {},
             _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
             // clang-format on
             _Adl_verify_range(_First1, _Last1);
             _Adl_verify_range(_First2, _Last2);
+            if constexpr (same_as<_Se2, unreachable_sentinel_t>) {
+                return false;
+            }
 
             auto _UFirst1 = _Get_unwrapped(_STD move(_First1));
             auto _ULast1  = _Get_unwrapped(_STD move(_Last1));
             auto _UFirst2 = _Get_unwrapped(_STD move(_First2));
             auto _ULast2  = _Get_unwrapped(_STD move(_Last2));
-            if constexpr (same_as<_Se1, unreachable_sentinel_t> && same_as<_Se2, unreachable_sentinel_t>) {
-                return _Equal_4(_STD move(_UFirst1), _STD move(_ULast1), _STD move(_UFirst2), _STD move(_ULast2),
-                    _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
-            } else if constexpr (same_as<_Se1, unreachable_sentinel_t> || same_as<_Se2, unreachable_sentinel_t>) {
-                return false;
-            } else {
-                iter_difference_t<_It1> _Count1;
-                if constexpr (sized_sentinel_for<_Se1, _It1>) { // TRANSITION, LWG-3392
-                    _Count1 = _ULast1 - _UFirst1;
-                } else {
-                    _Count1 = _RANGES distance(_UFirst1, _ULast1);
-                }
 
-                iter_difference_t<_It2> _Count2;
-                if constexpr (sized_sentinel_for<_Se2, _It2>) { // TRANSITION, LWG-3392
-                    _Count2 = _ULast2 - _UFirst2;
-                } else {
-                    _Count2 = _RANGES distance(_UFirst2, _ULast2);
-                }
+            iter_difference_t<_It1> _Count1;
+            if constexpr (sized_sentinel_for<_Se1, _It1>) { // TRANSITION, LWG-3392
+                _Count1 = _ULast1 - _UFirst1;
+            } else {
+                _Count1 = _RANGES distance(_UFirst1, _ULast1);
+            }
 
-                if (_Count2 > _Count1) {
-                    return false;
-                }
+            iter_difference_t<_It2> _Count2;
+            if constexpr (sized_sentinel_for<_Se2, _It2>) { // TRANSITION, LWG-3392
+                _Count2 = _ULast2 - _UFirst2;
+            } else {
+                _Count2 = _RANGES distance(_UFirst2, _ULast2);
+            }
 
-                _RANGES advance(_UFirst1, static_cast<iter_difference_t<_It1>>(_Count1 - _Count2));
-                return _RANGES _Equal_count(_STD move(_UFirst1), _STD move(_UFirst2),
-                    static_cast<iter_difference_t<_It1>>(_Count2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
+            if (_Count2 > _Count1) {
+                return false;
             }
+
+            _RANGES advance(_UFirst1, static_cast<iter_difference_t<_It1>>(_Count1 - _Count2));
+            return _RANGES _Equal_count(_STD move(_UFirst1), _STD move(_UFirst2),
+                static_cast<iter_difference_t<_It1>>(_Count2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
         }
 
         // clang-format off
         template <input_range _Rng1, input_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
             class _Pj2 = identity>
             requires (forward_range<_Rng1> || sized_range<_Rng1>) && (forward_range<_Rng2> || sized_range<_Rng2>)
                   && indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+                  && (!same_as<sentinel_t<_Rng1>, unreachable_sentinel_t>) // Per LWG-issue unnumbered as of 17.09.2021
         _NODISCARD constexpr bool operator()(
                 _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
             // clang-format on
-            if constexpr (same_as<sentinel_t<_Rng1>, unreachable_sentinel_t> //
-                          && same_as<sentinel_t<_Rng2>, unreachable_sentinel_t>)
-                return _Equal_4(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2), _Pass_fn(_Pred),
-                    _Pass_fn(_Proj1), _Pass_fn(_Proj2));
-            else if constexpr (same_as<sentinel_t<_Rng1>, unreachable_sentinel_t> //
-                               || same_as<sentinel_t<_Rng2>, unreachable_sentinel_t>) {
+            if constexpr (same_as<sentinel_t<_Rng2>, unreachable_sentinel_t>) {
                 return false;
-            } else {
-                const range_difference_t<_Rng1> _Count1 = _RANGES distance(_Range1);
-                const range_difference_t<_Rng2> _Count2 = _RANGES distance(_Range2);
-                if (_Count2 > _Count1) {
-                    return false;
-                }
+            }
 
-                auto _UFirst1 = _Ubegin(_Range1);
-                _RANGES advance(_UFirst1, static_cast<range_difference_t<_Rng1>>(_Count1 - _Count2));
-                return _RANGES _Equal_count(_STD move(_UFirst1), _Ubegin(_Range2),
-                    static_cast<range_difference_t<_Rng1>>(_Count2), _Pass_fn(_Pred), _Pass_fn(_Proj1),
-                    _Pass_fn(_Proj2));
+            const range_difference_t<_Rng1> _Count1 = _RANGES distance(_Range1);
+            const range_difference_t<_Rng2> _Count2 = _RANGES distance(_Range2);
+            if (_Count2 > _Count1) {
+                return false;
             }
+
+            auto _UFirst1 = _Ubegin(_Range1);
+            _RANGES advance(_UFirst1, static_cast<range_difference_t<_Rng1>>(_Count1 - _Count2));
+            return _RANGES _Equal_count(_STD move(_UFirst1), _Ubegin(_Range2),
+                static_cast<range_difference_t<_Rng1>>(_Count2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
         }
     };
 

tests/std/tests/P1659R3_ranges_alg_ends_with/test.cpp

@@ -31,9 +31,6 @@ constexpr void smoke_test() {
         assert(!no_match2);
     }
     { // Validate infinite ranges
-        const same_as<bool> auto infinite_haystack = ends_with(views::iota(0), views::iota(0, 5));
-        assert(!infinite_haystack);
-
         const same_as<bool> auto infinite_needle = ends_with(views::iota(0, 5), views::iota(0));
         assert(!infinite_needle);
     }
@@ -51,10 +48,6 @@ constexpr void smoke_test() {
         assert(!no_match2);
     }
     { // Validate unreachable sentinel
-        const same_as<bool> auto unreachable_haystack = ends_with(
-            haystack.begin(), unreachable_sentinel, needle.begin(), needle.end(), equal_to{}, get_first, get_second);
-        assert(!unreachable_haystack);
-
         const same_as<bool> auto unreachable_needle = ends_with(
             haystack.begin(), haystack.end(), needle.begin(), unreachable_sentinel, equal_to{}, get_first, get_second);
         assert(!unreachable_needle);