Make pair/tuples assignment operators SFINAE properly.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@276548 91177308-0d34-0410-b5e6-96231b3b80d8

include/tuple

@@ -647,6 +647,9 @@ public:
     _LIBCPP_CONSTEXPR tuple()
         _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
 
+    tuple(tuple const&) = default;
+    tuple(tuple&&) = default;
+
     template <class _AllocArgT, class _Alloc, bool _Dummy = true, class = typename enable_if<
         __lazy_and<
             is_same<allocator_arg_t, _AllocArgT>,
@@ -885,6 +888,25 @@ public:
         tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
 
+    using _CanCopyAssign = __all<is_copy_assignable<_Tp>::value...>;
+    using _CanMoveAssign = __all<is_move_assignable<_Tp>::value...>;
+
+    _LIBCPP_INLINE_VISIBILITY
+    tuple& operator=(typename conditional<_CanCopyAssign::value, tuple, __nat>::type const& __t)
+        _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
+    {
+        base_.operator=(__t.base_);
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    tuple& operator=(typename conditional<_CanMoveAssign::value, tuple, __nat>::type&& __t)
+        _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
+    {
+        base_.operator=(static_cast<base&&>(__t.base_));
+        return *this;
+    }
+
     template <class _Tuple,
               class = typename enable_if
                       <

include/utility

@@ -348,8 +348,15 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
   // Use the implicitly declared copy constructor in C++03
 #endif
 
+    typedef typename remove_reference<_T1>::type _T1Unref;
+    typedef typename remove_reference<_T2>::type _T2Unref;
+
+    typedef integral_constant<bool,
+           is_copy_assignable<_T1>::value
+        && is_copy_assignable<_T2>::value> _CanCopyAssign;
+
     _LIBCPP_INLINE_VISIBILITY
-    pair& operator=(const pair& __p)
+    pair& operator=(typename conditional<_CanCopyAssign::value, pair, __nat>::type const& __p)
         _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
                    is_nothrow_copy_assignable<second_type>::value)
     {
@@ -377,10 +384,15 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
             : first(_VSTD::forward<_U1>(__p.first)),
               second(_VSTD::forward<_U2>(__p.second)) {}
 
+    typedef integral_constant<bool,
+           is_move_assignable<_T1>::value
+        && is_move_assignable<_T2>::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<first_type>::value &&
+                   is_nothrow_move_assignable<second_type>::value)
     {
         first = _VSTD::forward<first_type>(__p.first);
         second = _VSTD::forward<second_type>(__p.second);
@@ -388,7 +400,6 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
     }
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
-
     template<class _Tuple,
              class = typename enable_if<__tuple_convertible<_Tuple, pair>::value>::type>
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
@@ -411,7 +422,7 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
             {}
 
     template <class _Tuple,
-              class = typename enable_if<__tuple_assignable<_Tuple, pair>::value>::type>
+              class = typename enable_if<!is_same<typename decay<_Tuple>::type, pair>::value && __tuple_assignable<_Tuple, pair>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         pair&
         operator=(_Tuple&& __p)

test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp

@@ -19,6 +19,22 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
+struct NonAssignable {
+  NonAssignable& operator=(NonAssignable const&) = delete;
+  NonAssignable& operator=(NonAssignable&&) = delete;
+};
+struct CopyAssignable {
+  CopyAssignable& operator=(CopyAssignable const&) = default;
+  CopyAssignable& operator=(CopyAssignable &&) = delete;
+};
+static_assert(std::is_copy_assignable<CopyAssignable>::value, "");
+struct MoveAssignable {
+  MoveAssignable& operator=(MoveAssignable const&) = delete;
+  MoveAssignable& operator=(MoveAssignable&&) = default;
+};
+
 int main()
 {
     {
@@ -51,4 +67,37 @@ int main()
         assert(std::get<1>(t) == 'a');
         assert(std::get<2>(t) == "some text");
     }
+    {
+        // test reference assignment.
+        using T = std::tuple<int&, int&&>;
+        int x = 42;
+        int y = 100;
+        int x2 = -1;
+        int y2 = 500;
+        T t(x, std::move(y));
+        T t2(x2, std::move(y2));
+        t = t2;
+        assert(std::get<0>(t) == x2);
+        assert(&std::get<0>(t) == &x);
+        assert(std::get<1>(t) == y2);
+        assert(&std::get<1>(t) == &y);
+    }
+    {
+        // test that the implicitly generated copy assignment operator
+        // is properly deleted
+        using T = std::tuple<std::unique_ptr<int>>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<int, NonAssignable>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<int, CopyAssignable>;
+        static_assert(std::is_copy_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<int, MoveAssignable>;
+        static_assert(!std::is_copy_assignable<T>::value, "");
+    }
 }

test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp

@@ -21,6 +21,33 @@
 
 #include "MoveOnly.h"
 
+struct NonAssignable {
+  NonAssignable& operator=(NonAssignable const&) = delete;
+  NonAssignable& operator=(NonAssignable&&) = delete;
+};
+struct CopyAssignable {
+  CopyAssignable& operator=(CopyAssignable const&) = default;
+  CopyAssignable& operator=(CopyAssignable&&) = delete;
+};
+static_assert(std::is_copy_assignable<CopyAssignable>::value, "");
+struct MoveAssignable {
+  MoveAssignable& operator=(MoveAssignable const&) = delete;
+  MoveAssignable& operator=(MoveAssignable&&) = default;
+};
+
+
+struct CountAssign {
+  static int copied;
+  static int moved;
+  static void reset() { copied = moved = 0; }
+  CountAssign() = default;
+  CountAssign& operator=(CountAssign const&) { ++copied; return *this; }
+  CountAssign& operator=(CountAssign&&) { ++moved; return *this; }
+};
+int CountAssign::copied = 0;
+int CountAssign::moved = 0;
+
+
 int main()
 {
     {
@@ -53,4 +80,46 @@ int main()
         assert(std::get<1>(t) == 1);
         assert(std::get<2>(t) == 2);
     }
+    {
+        // test reference assignment.
+        using T = std::tuple<int&, int&&>;
+        int x = 42;
+        int y = 100;
+        int x2 = -1;
+        int y2 = 500;
+        T t(x, std::move(y));
+        T t2(x2, std::move(y2));
+        t = std::move(t2);
+        assert(std::get<0>(t) == x2);
+        assert(&std::get<0>(t) == &x);
+        assert(std::get<1>(t) == y2);
+        assert(&std::get<1>(t) == &y);
+    }
+    {
+        // test that the implicitly generated move assignment operator
+        // is properly deleted
+        using T = std::tuple<std::unique_ptr<int>>;
+        static_assert(std::is_move_assignable<T>::value, "");
+        static_assert(!std::is_copy_assignable<T>::value, "");
+
+    }
+    {
+        using T = std::tuple<int, NonAssignable>;
+        static_assert(!std::is_move_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<int, MoveAssignable>;
+        static_assert(std::is_move_assignable<T>::value, "");
+    }
+    {
+        // The move should decay to a copy.
+        CountAssign::reset();
+        using T = std::tuple<CountAssign, CopyAssignable>;
+        static_assert(std::is_move_assignable<T>::value, "");
+        T t1;
+        T t2;
+        t1 = std::move(t2);
+        assert(CountAssign::copied == 1);
+        assert(CountAssign::moved == 0);
+    }
 }

test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp

@@ -0,0 +1,90 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+
+// pair& operator=(pair const& p);
+
+#include <utility>
+#include <memory>
+#include <cassert>
+
+
+struct NonAssignable {
+  NonAssignable& operator=(NonAssignable const&) = delete;
+  NonAssignable& operator=(NonAssignable&&) = delete;
+};
+struct CopyAssignable {
+  CopyAssignable() = default;
+  CopyAssignable(CopyAssignable const&) = default;
+  CopyAssignable& operator=(CopyAssignable const&) = default;
+  CopyAssignable& operator=(CopyAssignable&&) = delete;
+};
+struct MoveAssignable {
+  MoveAssignable() = default;
+  MoveAssignable& operator=(MoveAssignable const&) = delete;
+  MoveAssignable& operator=(MoveAssignable&&) = default;
+};
+
+
+struct CountAssign {
+  static int copied;
+  static int moved;
+  static void reset() { copied = moved = 0; }
+  CountAssign() = default;
+  CountAssign& operator=(CountAssign const&) { ++copied; return *this; }
+  CountAssign& operator=(CountAssign&&) { ++moved; return *this; }
+};
+int CountAssign::copied = 0;
+int CountAssign::moved = 0;
+
+int main()
+{
+    {
+        typedef std::pair<CopyAssignable, short> P;
+        const P p1(CopyAssignable(), 4);
+        P p2;
+        p2 = p1;
+        assert(p2.second == 4);
+    }
+    {
+        using P = std::pair<int&, int&&>;
+        int x = 42;
+        int y = 101;
+        int x2 = -1;
+        int y2 = 300;
+        P p1(x, std::move(y));
+        P p2(x2, std::move(y2));
+        p1 = p2;
+        assert(p1.first == x2);
+        assert(p1.second == y2);
+    }
+    {
+        using P = std::pair<int, NonAssignable>;
+        static_assert(!std::is_copy_assignable<P>::value, "");
+    }
+    {
+        CountAssign::reset();
+        using P = std::pair<CountAssign, CopyAssignable>;
+        static_assert(std::is_copy_assignable<P>::value, "");
+        P p;
+        P p2;
+        p = p2;
+        assert(CountAssign::copied == 1);
+        assert(CountAssign::moved == 0);
+    }
+    {
+        using P = std::pair<int, MoveAssignable>;
+        static_assert(!std::is_copy_assignable<P>::value, "");
+    }
+}

test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp

@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <utility>
 
 // template <class T1, class T2> struct pair
@@ -17,9 +19,35 @@
 #include <memory>
 #include <cassert>
 
+
+struct NonAssignable {
+  NonAssignable& operator=(NonAssignable const&) = delete;
+  NonAssignable& operator=(NonAssignable&&) = delete;
+};
+struct CopyAssignable {
+  CopyAssignable() = default;
+  CopyAssignable& operator=(CopyAssignable const&) = default;
+  CopyAssignable& operator=(CopyAssignable&&) = delete;
+};
+struct MoveAssignable {
+  MoveAssignable() = default;
+  MoveAssignable& operator=(MoveAssignable const&) = delete;
+  MoveAssignable& operator=(MoveAssignable&&) = default;
+};
+
+struct CountAssign {
+  static int copied;
+  static int moved;
+  static void reset() { copied = moved = 0; }
+  CountAssign() = default;
+  CountAssign& operator=(CountAssign const&) { ++copied; return *this; }
+  CountAssign& operator=(CountAssign&&) { ++moved; return *this; }
+};
+int CountAssign::copied = 0;
+int CountAssign::moved = 0;
+
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::pair<std::unique_ptr<int>, short> P;
         P p1(std::unique_ptr<int>(new int(3)), 4);
@@ -28,5 +56,41 @@ int main()
         assert(*p2.first == 3);
         assert(p2.second == 4);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
+        using P = std::pair<int&, int&&>;
+        int x = 42;
+        int y = 101;
+        int x2 = -1;
+        int y2 = 300;
+        P p1(x, std::move(y));
+        P p2(x2, std::move(y2));
+        p1 = std::move(p2);
+        assert(p1.first == x2);
+        assert(p1.second == y2);
+    }
+    {
+        using P = std::pair<int, NonAssignable>;
+        static_assert(!std::is_move_assignable<P>::value, "");
+    }
+    {
+        // The move decays to the copy constructor
+        CountAssign::reset();
+        using P = std::pair<CountAssign, CopyAssignable>;
+        static_assert(std::is_move_assignable<P>::value, "");
+        P p;
+        P p2;
+        p = std::move(p2);
+        assert(CountAssign::moved == 0);
+        assert(CountAssign::copied == 1);
+    }
+    {
+        CountAssign::reset();
+        using P = std::pair<CountAssign, MoveAssignable>;
+        static_assert(std::is_move_assignable<P>::value, "");
+        P p;
+        P p2;
+        p = std::move(p2);
+        assert(CountAssign::moved == 1);
+        assert(CountAssign::copied == 0);
+    }
 }