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/tuple

void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
     swap(__x.get(), __y.get());
 }
 
 template <size_t _Ip, class _Hp, bool>
 class __tuple_leaf
 {
     _Hp value;
 
-    __tuple_leaf& operator=(const __tuple_leaf&);
 public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
              _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : value()
        {static_assert(!is_reference<_Hp>::value,
               "Attempted to default construct a reference element in a tuple");}
 
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
template <class _Alloc>
         __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
             : value(__a)
         {static_assert(!is_reference<_Hp>::value,
               "Attempted to default construct a reference element in a tuple");}
 
     template <class _Tp,
               class = typename enable_if<
                   __lazy_and<
-                      __lazy_not<is_same<typename decay<_Tp>::type, __tuple_leaf>>
+                      __lazy_not<is_same<_Tp&&, __tuple_leaf const&>>,
+                      __lazy_not<is_same<_Tp&&, __tuple_leaf&&>>
+
                     , is_constructible<_Hp, _Tp>
                     >::value
                 >::type
             >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
             : value(_VSTD::forward<_Tp>(__t))
         {static_assert(!is_reference<_Hp>::value ||
template <class _Tp, class _Alloc>
                         (is_lvalue_reference<_Tp>::value ||
                          is_same<typename remove_reference<_Tp>::type,
                                  reference_wrapper<
                                     typename remove_reference<_Hp>::type
                                  >
                                 >::value)),
        "Attempted to construct a reference element in a tuple with an rvalue");}
 
-    __tuple_leaf(const __tuple_leaf& __t) = default;
-    __tuple_leaf(__tuple_leaf&& __t) = default;
+    using _HpUnref = typename remove_reference<_Hp>::type;
+    using _CanCopyAssign = integral_constant<bool,
+         __lazy_and<is_reference<_Hp>, is_copy_assignable<_HpUnref>>::value>;
+    using _CanMoveAssign = integral_constant<bool,
+        __lazy_and<is_reference<_Hp>, is_move_assignable<_HpUnref>>::value>;
+
+  constexpr __tuple_leaf(typename conditional<is_reference<_Hp>::value, __tuple_leaf, __nat>::type const& __other)
+      : value(_VSTD::forward<decltype(__other.value)>(__other.value)) {}
+
+    __tuple_leaf&
+    operator=(typename conditional<_CanCopyAssign::value, __tuple_leaf, __nat>::type const& __v) {
+        value = __v.value;
+        return *this;
+    }
+
+     __tuple_leaf&
+    operator=(typename conditional<_CanMoveAssign::value, __tuple_leaf, __nat>::type&& __v) {
+        value = _VSTD::move(__v.value);
+        return *this;
+    }
 
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
-        __tuple_leaf&
+        typename enable_if<__lazy_and<
+            integral_constant<bool,
+                 !is_same<_Tp&&, __tuple_leaf const&>::value
+              && !is_same<_Tp&&, __tuple_leaf&&>::value>,
+            is_assignable<_Hp&, _Tp&&>>::value,
+          __tuple_leaf&>::type
         operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
         {
             value = _VSTD::forward<_Tp>(__t);
             return *this;
         }
 
     _LIBCPP_INLINE_VISIBILITY
     int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
     {
         _VSTD::swap(*this, __t);
         return 0;
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11       _Hp& get()       _NOEXCEPT {return value;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return value;}
 };
 
 template <size_t _Ip, class _Hp>
 class __tuple_leaf<_Ip, _Hp, true>
-    : private _Hp
+    :  _Hp
 {
 
-    __tuple_leaf& operator=(const __tuple_leaf&);
 public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
              _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}
 
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
 
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
             : _Hp(allocator_arg_t(), __a) {}
 
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
             : _Hp(__a) {}
 
     template <class _Tp,
               class = typename enable_if<
                   __lazy_and<
-                        __lazy_not<is_same<typename decay<_Tp>::type, __tuple_leaf>>
+                        __lazy_not<is_same<_Tp&&, __tuple_leaf const&>>,
+                        __lazy_not<is_same<_Tp&&, __tuple_leaf &&>>
+
                       , is_constructible<_Hp, _Tp>
                     >::value
                 >::type
             >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
             : _Hp(_VSTD::forward<_Tp>(__t)) {}
 
     template <class _Tp, class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
             : _Hp(_VSTD::forward<_Tp>(__t)) {}
 
     template <class _Tp, class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
             : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
 
     template <class _Tp, class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
             : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
 
-    __tuple_leaf(__tuple_leaf const &) = default;
-    __tuple_leaf(__tuple_leaf &&) = default;
-
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
-        __tuple_leaf&
+        typename enable_if<is_assignable<_Hp&, _Tp&&>::value, __tuple_leaf&>::type
         operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
         {
             _Hp::operator=(_VSTD::forward<_Tp>(__t));
             return *this;
         }
 
     _LIBCPP_INLINE_VISIBILITY
     int
template <class _Tuple>
         operator=(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_assignable<_Tp&, typename tuple_element<_Indx,
                                        typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
         {
             __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
                                        typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
             return *this;
         }
 
-    __tuple_impl(const __tuple_impl&) = default;
-    __tuple_impl(__tuple_impl&&) = default;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __tuple_impl&
-    operator=(const __tuple_impl& __t) _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
-    {
-        __swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...);
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __tuple_impl&
-    operator=(__tuple_impl&& __t) _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
-    {
-        __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<_Tp>(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t).get()))...);
-        return *this;
-    }
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(__tuple_impl& __t)
         _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
     {
         __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
     }
 };

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;
template<class _U1, class _U2>
         pair(const pair<_U1, _U2>& __p
 #ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
                  ,typename enable_if<is_convertible<const _U1&, _T1>::value &&
                                     is_convertible<const _U2&, _T2>::value>::type* = 0
 #endif
                                       )
             : first(__p.first), second(__p.second) {}
 
-#if !defined(_LIBCPP_CXX03_LANG)
-    _LIBCPP_INLINE_VISIBILITY pair(const pair& __p) = default;
-    _LIBCPP_INLINE_VISIBILITY pair(pair&& __p) = default;
-#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, __nat>::type const& __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
 
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template<class _U1, class _U2>
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         pair(pair<_U1, _U2>&& __p,
                  typename enable_if<is_convertible<_U1, _T1>::value &&
                                     is_convertible<_U2, _T2>::value>::type* = 0)
             : first(_VSTD::forward<_U1>(__p.first)),
               second(_VSTD::forward<_U2>(__p.second)) {}
 
+    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>
+
+#include "test_macros.h"
+
+struct NonAssignable {
+private:
+  NonAssignable& operator=(NonAssignable const&) _LIBCPP_EQUAL_DELETE;
+#if TEST_STD_VER >= 11
+  NonAssignable& operator=(NonAssignable&&) _LIBCPP_EQUAL_DELETE;
+#endif
+};
+
+int main() {
+    typedef std::unique_ptr<int> Ptr;
+    typedef NonAssignable NA;
+    {
+        typedef std::pair<int, int> T;
+        const T x(1, 2);
+        T y;
+        y = x;
+        static_assert(std::is_copy_assignable<T>::value, "");
+        static_assert(std::is_move_assignable<T>::value, "");
+    }
+#if TEST_STD_VER >= 11
+    {
+        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, "");
+    }
+#endif
+}