Make pair and tuple respect is_copy_assignable and is_move_assignable

[EricWF]

Summary

This shows the basic jist of my proposed changes. I haven't tested them enough to ensure they are 100% correct.

Can anybody suggest a better solution?

[EricWF]

• Remove = default copy/move constructors in pair. Let the compiler implicitly mark them as default.
• Roughly implement the changes in <tuple> This still needs a ton more tests.

[EricWF]

Fix bad #ifdef change in pair.

[EricWF]

Get all but 1 test passing.

[EricWF]

All tests are now passing.

[EricWF]

Actually get all of the tests passing.

Sorry for the spam.

[EricWF]

Fix merge conflicts with master.

[EricWF]

Similar reversion committed as r276548.

include/utility

 
 struct _LIBCPP_TYPE_VIS_ONLY piecewise_construct_t { };
 #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_UTILITY)
 extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();
 #else
 constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 #endif
 
+
 template <class _T1, class _T2>
 struct _LIBCPP_TYPE_VIS_ONLY pair
 {
     typedef _T1 first_type;
     typedef _T2 second_type;
 
     _T1 first;
     _T2 second;
#elif !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) || !_LIBCPP_TRIVIAL_PAIR_COPY_CTOR
     pair(const pair& __p)
         _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
                    is_nothrow_copy_constructible<second_type>::value)
         : first(__p.first),
           second(__p.second)
     {
     }
 #endif
+    typedef typename remove_reference<_T1>::type _T1Unref;
+    typedef typename remove_reference<_T2>::type _T2Unref;
+
+    typedef integral_constant<bool,
+        (is_reference<_T1>::value || is_reference<_T2>::value)
+        && is_copy_assignable<_T1Unref>::value
+        && is_copy_assignable<_T2Unref>::value> _CanCopyAssign;
+
 
     _LIBCPP_INLINE_VISIBILITY
-    pair& operator=(const pair& __p)
-        _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
-                   is_nothrow_copy_assignable<second_type>::value)
+    pair&
+    operator=(typename conditional<_CanCopyAssign::value == true, pair const&, __nat&>::type __p)
+        _NOEXCEPT_(is_nothrow_copy_assignable<_T1Unref>::value &&
+                   is_nothrow_copy_assignable<_T2Unref>::value)
     {
         first = __p.first;
         second = __p.second;
         return *this;
     }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
#else
     _LIBCPP_INLINE_VISIBILITY
     pair(pair&& __p) _NOEXCEPT_(is_nothrow_move_constructible<first_type>::value &&
                                 is_nothrow_move_constructible<second_type>::value)
         : first(_VSTD::forward<first_type>(__p.first)),
           second(_VSTD::forward<second_type>(__p.second))
     {
     }
 #endif
+    typedef integral_constant<bool,
+        (is_reference<_T1>::value || is_reference<_T2>::value)
+        && is_move_assignable<_T1Unref>::value
+        && is_move_assignable<_T2Unref>::value> _CanMoveAssign;
 
     _LIBCPP_INLINE_VISIBILITY
     pair&
-    operator=(pair&& __p) _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
-                                     is_nothrow_move_assignable<second_type>::value)
+    operator=(typename conditional<_CanMoveAssign::value, pair&&, __nat&&>::type __p)
+                          _NOEXCEPT_(is_nothrow_move_assignable<_T1Unref>::value &&
+                                     is_nothrow_move_assignable<_T2Unref>::value)
     {
         first = _VSTD::forward<first_type>(__p.first);
         second = _VSTD::forward<second_type>(__p.second);
         return *this;
     }
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 

test/test.pass.cpp

+#include <utility>
+#include <tuple>
+#include <type_traits>
+#include <memory>
+
+struct NonAssignable {
+  NonAssignable& operator=(NonAssignable const&) = delete;
+  NonAssignable& operator=(NonAssignable&&) = delete;
+
+};
+
+int main() {
+    using Ptr = std::unique_ptr<int>;
+    using NA = NonAssignable;
+    {
+        using T = std::pair<int, Ptr>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+        static_assert(std::is_move_assignable<T>::value, "");
+    }
+    {
+        using T = std::pair<int, Ptr&>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+        static_assert(std::is_move_assignable<T>::value, "");
+    }
+    {
+        using T = std::pair<int, Ptr&&>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+        static_assert(std::is_move_assignable<T>::value, "");
+    }
+    {
+        using T = std::pair<int, Ptr const&>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+        static_assert(!std::is_move_assignable<T>::value, "");
+    }
+    {
+        using T = std::pair<int&, int&&>;
+        static_assert(std::is_copy_assignable<T>::value, "");
+        static_assert(std::is_move_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<int, Ptr>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+    }
+    {
+        using T = std::pair<int, NA>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+        static_assert(!std::is_move_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<int, NA>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+        static_assert(!std::is_move_assignable<T>::value, "");
+    }
+}
 No newline at end of file