Implement LWG-3918

Author: frederick-vs-ja

stl/inc/execution

@@ -137,11 +137,6 @@ template <>
 struct is_execution_policy<execution::unsequenced_policy> : true_type {};
 #endif // _HAS_CXX20
 
-template <class _Ty, class _FwdIt>
-void _Construct_in_place_by_deref(_Ty& _Val, const _FwdIt& _Iter) {
-    ::new (static_cast<void*>(_STD addressof(_Val))) _Ty(*_Iter);
-}
-
 template <class _Ty, class _UnaryOp, class _FwdIt>
 void _Construct_in_place_by_transform_deref(_Ty& _Val, _UnaryOp _Transform_op, const _FwdIt& _Iter) {
     ::new (static_cast<void*>(_STD addressof(_Val))) _Ty(_Transform_op(*_Iter));

stl/inc/memory

@@ -141,7 +141,7 @@ _NoThrowFwdIt uninitialized_copy_n(const _InIt _First, const _Diff _Count_raw, _
         _Uninitialized_backout<decltype(_UDest)> _Backout{_UDest};
 
         for (; _Count > 0; --_Count, (void) ++_UFirst) {
-            _Backout._Emplace_back(*_UFirst);
+            _Backout._Emplace_back_deref(_UFirst);
         }
 
         _UDest = _Backout._Release();
@@ -294,7 +294,7 @@ pair<_InIt, _NoThrowFwdIt> uninitialized_move_n(_InIt _First, const _Diff _Count
         _Uninitialized_backout<decltype(_UDest)> _Backout{_UDest};
 
         for (; _Count > 0; --_Count, (void) ++_UFirst) {
-            _Backout._Emplace_back(_STD move(*_UFirst));
+            _Backout._Emplace_back_deref_move(_UFirst);
         }
 
         _UDest = _Backout._Release();

stl/inc/xmemory

@@ -1601,6 +1601,11 @@ void _Return_temporary_buffer(_Ty* const _Pbuf) noexcept {
     }
 }
 
+template <class _Ty, class _InIt>
+void _Construct_in_place_by_deref(_Ty& _Val, const _InIt& _Iter) {
+    ::new (static_cast<void*>(_STD addressof(_Val))) _Ty(*_Iter);
+}
+
 template <class _NoThrowFwdIt>
 struct _NODISCARD _Uninitialized_backout {
     // struct to undo partially constructed ranges in _Uninitialized_xxx algorithms
@@ -1625,6 +1630,29 @@ struct _NODISCARD _Uninitialized_backout {
         ++_Last;
     }
 
+    template <class _InIt>
+    _CONSTEXPR20 void _Emplace_back_deref(const _InIt& _Iter) {
+        // construct a new element at *_Last from the result of dereferencing _Iter and increment.
+        if constexpr (is_reference_v<decltype(*_Iter)>) {
+            _STD _Construct_in_place(*_Last, *_Iter);
+        } else {
+            _STD _Construct_in_place_by_deref(*_Last, _Iter);
+        }
+        ++_Last;
+    }
+
+    template <class _InIt>
+    _CONSTEXPR20 void _Emplace_back_deref_move(const _InIt& _Iter) {
+        // construct a new element at *_Last from the result of dereferencing _Iter and increment,
+        // with lvalue cast to xvalue if necessary for uninitialized_move(_n).
+        if constexpr (is_reference_v<decltype(*_Iter)>) {
+            _STD _Construct_in_place(*_Last, _STD move(*_Iter));
+        } else {
+            _STD _Construct_in_place_by_deref(*_Last, _Iter);
+        }
+        ++_Last;
+    }
+
     constexpr _NoThrowFwdIt _Release() { // suppress any exception handling backout and return _Last
         _First = _Last;
         return _Last;
@@ -1644,7 +1672,7 @@ _CONSTEXPR20 _NoThrowFwdIt _Uninitialized_move_unchecked(_InIt _First, const _In
     }
     _Uninitialized_backout<_NoThrowFwdIt> _Backout{_Dest};
     for (; _First != _Last; ++_First) {
-        _Backout._Emplace_back(_STD move(*_First));
+        _Backout._Emplace_back_deref_move(_First);
     }
 
     return _Backout._Release();
@@ -1918,7 +1946,7 @@ _CONSTEXPR20 _NoThrowFwdIt _Uninitialized_copy_unchecked(_InIt _First, const _In
 
     _Uninitialized_backout<_NoThrowFwdIt> _Backout{_Dest};
     for (; _First != _Last; ++_First) {
-        _Backout._Emplace_back(*_First);
+        _Backout._Emplace_back_deref(_First);
     }
 
     return _Backout._Release();

tests/std/tests/P0040R3_extending_memory_management_tools/test.cpp

@@ -196,6 +196,120 @@ void test_destroy_n() {
     assert(g_alive == 0);
 }
 
+struct copy_elision_dest;
+
+class pinned {
+public:
+    explicit pinned(int n) : n_{n} {}
+
+    pinned(const pinned&)            = delete;
+    pinned& operator=(const pinned&) = delete;
+
+private:
+    friend copy_elision_dest;
+
+    int n_;
+};
+
+class pinned_ioterator {
+private:
+    struct arrow_proxy {
+        pinned val_;
+
+        pinned* operator->() {
+            return &val_;
+        }
+    };
+
+public:
+    using value_type        = pinned;
+    using difference_type   = int;
+    using reference         = pinned;
+    using pointer           = arrow_proxy;
+    using iterator_category = std::input_iterator_tag;
+
+    explicit pinned_ioterator(int n) : n_{n} {}
+
+    pinned operator*() const {
+        return pinned{n_};
+    }
+    pinned_ioterator& operator++() {
+        ++n_;
+        return *this;
+    }
+    pinned_ioterator operator++(int) {
+        auto old = *this;
+        ++*this;
+        return old;
+    }
+
+    arrow_proxy operator->() const {
+        return arrow_proxy{pinned{n_}};
+    }
+
+    friend bool operator==(pinned_ioterator i, pinned_ioterator j) {
+        return i.n_ == j.n_;
+    }
+#if !_HAS_CXX20
+    friend bool operator!=(pinned_ioterator i, pinned_ioterator j) {
+        return !(i == j);
+    }
+#endif // !_HAS_CXX20
+
+private:
+    int n_;
+};
+
+struct copy_elision_dest {
+public:
+    copy_elision_dest() = default;
+    explicit copy_elision_dest(pinned x) : n_{x.n_} {}
+
+    int n_;
+};
+
+// std::uninitialized_copy/_n are required to perform guaranteed copy elision since C++17.
+void test_guaranteed_copy_elision_uninitialized_copy() {
+    constexpr int len = 42;
+
+    copy_elision_dest d[len];
+    uninitialized_copy(pinned_ioterator{0}, pinned_ioterator{len}, d);
+    for (int i = 0; i != len; ++i) {
+        assert(d[i].n_ == i);
+    }
+}
+
+void test_guaranteed_copy_elision_uninitialized_copy_n() {
+    constexpr int len = 42;
+
+    copy_elision_dest d[len];
+    uninitialized_copy_n(pinned_ioterator{0}, len, d);
+    for (int i = 0; i != len; ++i) {
+        assert(d[i].n_ == i);
+    }
+}
+
+// Also test LWG-3918 "std::uninitialized_move/_n and guaranteed copy elision".
+void test_guaranteed_copy_elision_uninitialized_move() {
+    constexpr int len = 42;
+
+    copy_elision_dest d[len];
+    uninitialized_move(pinned_ioterator{0}, pinned_ioterator{len}, d);
+    for (int i = 0; i != len; ++i) {
+        assert(d[i].n_ == i);
+    }
+}
+
+void test_guaranteed_copy_elision_uninitialized_move_n() {
+    constexpr int len = 42;
+
+    copy_elision_dest d[len];
+    uninitialized_move_n(pinned_ioterator{0}, len, d);
+    for (int i = 0; i != len; ++i) {
+        assert(d[i].n_ == i);
+    }
+}
+
 int main() {
     test_uninitialized_move();
     test_uninitialized_move_n();
@@ -206,4 +320,9 @@ int main() {
     test_destroy_at();
     test_destroy();
     test_destroy_n();
+
+    test_guaranteed_copy_elision_uninitialized_copy();
+    test_guaranteed_copy_elision_uninitialized_copy_n();
+    test_guaranteed_copy_elision_uninitialized_move();
+    test_guaranteed_copy_elision_uninitialized_move_n();
 }