Fix ranges::uninitialized_meow_n algorithms

Author: miscco

stl/inc/memory

@@ -149,7 +149,9 @@ namespace ranges {
             auto _OFirst      = _Get_unwrapped(_STD move(_First2));
             const auto _OLast = _Get_unwrapped(_STD move(_Last2));
             if constexpr (_Ptr_copy_cat<_It, _Out>::_Really_trivial) {
-                return _Copy_memcpy_common(_IFirst, _IFirst + _Count, _OFirst, _OLast);
+                auto _UResult = _Copy_memcpy_common(_IFirst, _IFirst + _Count, _OFirst, _OLast);
+                _IFirst       = _UResult.in;
+                _OFirst       = _UResult.out;
             } else {
                 _Uninitialized_backout _Backout{_STD move(_OFirst)};
 
@@ -283,7 +285,9 @@ namespace ranges {
             auto _OFirst      = _Get_unwrapped(_STD move(_First2));
             const auto _OLast = _Get_unwrapped(_STD move(_Last2));
             if constexpr (_Ptr_move_cat<_It, _Out>::_Really_trivial) {
-                return _Copy_memcpy_common(_IFirst, _IFirst + _Count, _OFirst, _OLast);
+                auto _UResult = _Copy_memcpy_common(_IFirst, _IFirst + _Count, _OFirst, _OLast);
+                _IFirst       = _UResult.in;
+                _OFirst       = _UResult.out;
             } else {
                 _Uninitialized_backout _Backout{_STD move(_OFirst)};
 

tests/std/tests/P0896R4_ranges_alg_uninitialized_copy_n/test.cpp

@@ -172,31 +172,47 @@ struct memcopy_test {
     static constexpr int expected_input_long[]  = {13, 55, 12345, 42};
 
     static void call() {
+        using ranges::uninitialized_copy_n, ranges::uninitialized_copy_n_result, ranges::equal, ranges::iterator_t;
         { // Validate range overload
             int input[]  = {13, 55, 12345, 42};
             int output[] = {-1, -1, -1, -1};
-
-            ranges::uninitialized_copy_n(input, 3, begin(output), end(output));
-            assert(ranges::equal(input, expected_input));
-            assert(ranges::equal(output, expected_output));
+            span<int> wrapped_input{input};
+            span<int> wrapped_output{output};
+
+            const same_as<uninitialized_copy_n_result<iterator_t<span<int>>, iterator_t<span<int>>>> auto result =
+                uninitialized_copy_n(wrapped_input.begin(), 3, begin(wrapped_output), end(wrapped_output));
+            assert(next(result.in) == end(wrapped_input));
+            assert(next(result.out) == end(wrapped_output));
+            assert(equal(input, expected_input));
+            assert(equal(output, expected_output));
         }
 
         { // Validate shorter input
             int input[]  = {13, 55};
             int output[] = {-1, -1, -1, -1};
-
-            ranges::uninitialized_copy_n(input, 2, begin(output), end(output));
-            assert(ranges::equal(input, expected_input_short));
-            assert(ranges::equal(output, expected_output_long));
+            span<int> wrapped_input{input};
+            span<int> wrapped_output{output};
+
+            const same_as<uninitialized_copy_n_result<iterator_t<span<int>>, iterator_t<span<int>>>> auto result =
+                uninitialized_copy_n(wrapped_input.begin(), 2, begin(wrapped_output), end(wrapped_output));
+            assert(result.in == end(wrapped_input));
+            assert(next(result.out, 2) == end(wrapped_output));
+            assert(equal(input, expected_input_short));
+            assert(equal(output, expected_output_long));
         }
 
         { // Validate shorter output
             int input[]  = {13, 55, 12345, 42};
             int output[] = {-1, -1};
-
-            ranges::uninitialized_copy_n(input, 3, begin(output), end(output));
-            assert(ranges::equal(input, expected_input));
-            assert(ranges::equal(output, expected_input_short));
+            span<int> wrapped_input{input};
+            span<int> wrapped_output{output};
+
+            const same_as<uninitialized_copy_n_result<iterator_t<span<int>>, iterator_t<span<int>>>> auto result =
+                uninitialized_copy_n(wrapped_input.begin(), 2, begin(wrapped_output), end(wrapped_output));
+            assert(next(result.in, 2) == end(wrapped_input));
+            assert(result.out == end(wrapped_output));
+            assert(equal(input, expected_input));
+            assert(equal(output, expected_input_short));
         }
     }
 };

tests/std/tests/P0896R4_ranges_alg_uninitialized_move_n/test.cpp

@@ -173,31 +173,47 @@ struct memcopy_test {
     static constexpr int expected_input_long[]  = {13, 55, 12345, 42};
 
     static void call() {
+        using ranges::uninitialized_move_n, ranges::uninitialized_move_n_result, ranges::equal, ranges::iterator_t;
         { // Validate range overload
             int input[]  = {13, 55, 12345, 42};
             int output[] = {-1, -1, -1, -1};
-
-            ranges::uninitialized_move_n(input, 3, begin(output), end(output));
-            assert(ranges::equal(input, expected_input));
-            assert(ranges::equal(output, expected_output));
+            span<int> wrapped_input{input};
+            span<int> wrapped_output{output};
+
+            const same_as<uninitialized_move_n_result<iterator_t<span<int>>, iterator_t<span<int>>>> auto result =
+                uninitialized_move_n(wrapped_input.begin(), 3, begin(wrapped_output), end(wrapped_output));
+            assert(next(result.in) == end(wrapped_input));
+            assert(next(result.out) == end(wrapped_output));
+            assert(equal(input, expected_input));
+            assert(equal(output, expected_output));
         }
 
         { // Validate shorter input
             int input[]  = {13, 55};
             int output[] = {-1, -1, -1, -1};
-
-            ranges::uninitialized_move_n(input, 2, begin(output), end(output));
-            assert(ranges::equal(input, expected_input_short));
-            assert(ranges::equal(output, expected_output_long));
+            span<int> wrapped_input{input};
+            span<int> wrapped_output{output};
+
+            const same_as<uninitialized_move_n_result<iterator_t<span<int>>, iterator_t<span<int>>>> auto result =
+                uninitialized_move_n(wrapped_input.begin(), 2, begin(wrapped_output), end(wrapped_output));
+            assert(result.in == end(wrapped_input));
+            assert(next(result.out, 2) == end(wrapped_output));
+            assert(equal(input, expected_input_short));
+            assert(equal(output, expected_output_long));
         }
 
         { // Validate shorter output
             int input[]  = {13, 55, 12345, 42};
             int output[] = {-1, -1};
-
-            ranges::uninitialized_move_n(input, 3, begin(output), end(output));
-            assert(ranges::equal(input, expected_input));
-            assert(ranges::equal(output, expected_input_short));
+            span<int> wrapped_input{input};
+            span<int> wrapped_output{output};
+
+            const same_as<uninitialized_move_n_result<iterator_t<span<int>>, iterator_t<span<int>>>> auto result =
+                uninitialized_move_n(wrapped_input.begin(), 2, begin(wrapped_output), end(wrapped_output));
+            assert(next(result.in, 2) == end(wrapped_input));
+            assert(result.out == end(wrapped_output));
+            assert(equal(input, expected_input));
+            assert(equal(output, expected_input_short));
         }
     }
 };