Fix uninitialized_meow memcopy optimization

Author: miscco

stl/inc/memory

@@ -108,7 +108,7 @@ namespace ranges {
             _STL_INTERNAL_STATIC_ASSERT(constructible_from<iter_value_t<_Out>, iter_reference_t<_It>>);
 
             if constexpr (is_same_v<_Se, _It> && _Ptr_copy_cat<_It, _Out>::_Really_trivial) {
-                return _Copy_memcpy_common(_IFirst, _ILast, _OFirst, _OLast);
+                return {_STD move(_ILast), _Copy_memcpy_common(_IFirst, _ILast, _OFirst, _OLast)};
             } else {
                 _Uninitialized_backout _Backout{_STD move(_OFirst)};
 
@@ -265,7 +265,7 @@ namespace ranges {
             _STL_INTERNAL_STATIC_ASSERT(constructible_from<iter_value_t<_Out>, iter_rvalue_reference_t<_It>>);
 
             if constexpr (is_same_v<_Se, _It> && _Ptr_move_cat<_It, _Out>::_Really_trivial) {
-                return _Copy_memcpy_common(_IFirst, _ILast, _OFirst, _OLast);
+                return {_STD move(_ILast), _Copy_memcpy_common(_IFirst, _ILast, _OFirst, _OLast)};
             } else {
                 _Uninitialized_backout _Backout{_STD move(_OFirst)};
 

tests/std/tests/P0896R4_ranges_alg_uninitialized_copy/test.cpp

@@ -160,6 +160,21 @@ struct throwing_test {
     }
 };
 
+struct memcopy_test {
+    static constexpr int expected_output[] = {13, 55, 12345};
+    static constexpr int expected_input[]  = {13, 55, 12345};
+
+    static void call() {
+        // Validate only range overload (one is plenty since they both use the same backend)
+        int input[]  = {13, 55, 12345};
+        int output[] = {-1, -1, -1};
+
+        ranges::uninitialized_copy(input, output);
+        assert(ranges::equal(input, expected_input));
+        assert(ranges::equal(output, expected_output));
+    }
+};
+
 template <test::ProxyRef IsProxy>
 using test_input  = test::range<test::input, int_wrapper, test::Sized::no, test::CanDifference::no, test::Common::no,
     test::CanCompare::yes, IsProxy>;
@@ -174,4 +189,5 @@ int main() {
     instantiator::call<test_input<test::ProxyRef::yes>, test_output>();
     throwing_test::call<test_input<test::ProxyRef::no>, test_output>();
     throwing_test::call<test_input<test::ProxyRef::yes>, test_output>();
+    memcopy_test::call();
 }

tests/std/tests/P0896R4_ranges_alg_uninitialized_copy_n/test.cpp

@@ -126,6 +126,21 @@ struct throwing_test {
     }
 };
 
+struct memcopy_test {
+    static constexpr int expected_output[] = {13, 55, 12345, -1};
+    static constexpr int expected_input[]  = {13, 55, 12345, 42};
+
+    static void call() {
+        // Validate only range overload (one is plenty since they both use the same backend)
+        int input[]  = {13, 55, 12345, 42};
+        int output[] = {-1, -1, -1, -1};
+
+        ranges::uninitialized_copy_n(input, 3, output, output + 4);
+        assert(ranges::equal(input, expected_input));
+        assert(ranges::equal(output, expected_output));
+    }
+};
+
 template <test::ProxyRef IsProxy>
 using test_input  = test::range<test::input, int_wrapper, test::Sized::no, test::CanDifference::no, test::Common::no,
     test::CanCompare::yes, IsProxy>;
@@ -140,4 +155,5 @@ int main() {
     instantiator::call<test_input<test::ProxyRef::yes>, test_output>();
     throwing_test::call<test_input<test::ProxyRef::no>, test_output>();
     throwing_test::call<test_input<test::ProxyRef::yes>, test_output>();
+    memcopy_test::call();
 }

tests/std/tests/P0896R4_ranges_alg_uninitialized_move/test.cpp

@@ -154,6 +154,21 @@ struct throwing_test {
     }
 };
 
+struct memcopy_test {
+    static constexpr int expected_output[] = {13, 55, 12345};
+    static constexpr int expected_input[]  = {13, 55, 12345};
+
+    static void call() {
+        // Validate only range overload (one is plenty since they both use the same backend)
+        int input[]  = {13, 55, 12345};
+        int output[] = {-1, -1, -1};
+
+        ranges::uninitialized_move(input, output);
+        assert(ranges::equal(input, expected_input));
+        assert(ranges::equal(output, expected_output));
+    }
+};
+
 template <test::ProxyRef IsProxy>
 using test_input  = test::range<test::input, int_wrapper, test::Sized::no, test::CanDifference::no, test::Common::no,
     test::CanCompare::yes, IsProxy>;
@@ -168,4 +183,5 @@ int main() {
     instantiator::call<test_input<test::ProxyRef::yes>, test_output>();
     throwing_test::call<test_input<test::ProxyRef::no>, test_output>();
     throwing_test::call<test_input<test::ProxyRef::yes>, test_output>();
+    memcopy_test::call();
 }

tests/std/tests/P0896R4_ranges_alg_uninitialized_move_n/test.cpp

@@ -128,6 +128,21 @@ struct throwing_test {
     }
 };
 
+struct memcopy_test {
+    static constexpr int expected_output[] = {13, 55, 12345, -1};
+    static constexpr int expected_input[]  = {13, 55, 12345, 42};
+
+    static void call() {
+        // Validate only range overload (one is plenty since they both use the same backend)
+        int input[]  = {13, 55, 12345, 42};
+        int output[] = {-1, -1, -1, -1};
+
+        ranges::uninitialized_move_n(input, 3, output, output + 4);
+        assert(ranges::equal(input, expected_input));
+        assert(ranges::equal(output, expected_output));
+    }
+};
+
 template <test::ProxyRef IsProxy>
 using test_input  = test::range<test::input, int_wrapper, test::Sized::no, test::CanDifference::no, test::Common::no,
     test::CanCompare::yes, IsProxy>;
@@ -142,4 +157,5 @@ int main() {
     instantiator::call<test_input<test::ProxyRef::yes>, test_output>();
     throwing_test::call<test_input<test::ProxyRef::no>, test_output>();
     throwing_test::call<test_input<test::ProxyRef::yes>, test_output>();
+    memcopy_test::call();
 }