From 904a5d700752b19fec363f4bf8d00d5eef2c7efd Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sun, 24 Jul 2016 05:51:11 +0000
Subject: [PATCH] Make pair/tuples assignment operators SFINAE properly.

llvm-svn: 276548
---
 libcxx/include/tuple                               | 22 ++++++
 libcxx/include/utility                             | 21 +++--
 .../tuple/tuple.tuple/tuple.assign/copy.pass.cpp   | 49 ++++++++++++
 .../tuple/tuple.tuple/tuple.assign/move.pass.cpp   | 69 +++++++++++++++++
 .../utility/pairs/pairs.pair/assign_pair.pass.cpp  | 90 ++++++++++++++++++++++
 .../pairs/pairs.pair/assign_rv_pair.pass.cpp       | 68 +++++++++++++++-
 6 files changed, 312 insertions(+), 7 deletions(-)
 create mode 100644 libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp

diff --git a/libcxx/include/tuple b/libcxx/include/tuple
index 31613d2..a68f115 100644
--- a/libcxx/include/tuple
+++ b/libcxx/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
                       <
diff --git a/libcxx/include/utility b/libcxx/include/utility
index fd8a7f2..74a28d8f 100644
--- a/libcxx/include/utility
+++ b/libcxx/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)
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
index d5d0207..6a24c278 100644
--- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
+++ b/libcxx/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, "");
+    }
 }
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
index fc5e41a..210f14b 100644
--- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
+++ b/libcxx/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);
+    }
 }
diff --git a/libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp b/libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp
new file mode 100644
index 0000000..d75b6a5
--- /dev/null
+++ b/libcxx/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, "");
+    }
+}
diff --git a/libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp b/libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp
index a753ee5..3808920 100644
--- a/libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp
+++ b/libcxx/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);
+    }
 }
-- 
2.7.4