[libc++] Fix incorrect forwarding in tuple's assignment operator

[ldionne]

Summary

Also, add a bunch of tests for tuple and pair's assignment operators
involving reference types.

libcxx/include/tuple

 void __memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) {
     _VSTD::__swallow(((_VSTD::get<_Np>(__dest) = _VSTD::get<_Np>(__source)), void(), 0)...);
 }
 
 template<class _Dest, class _Source, class ..._Up, size_t ..._Np>
 _LIBCPP_INLINE_VISIBILITY
 void __memberwise_forward_assign(_Dest& __dest, _Source&& __source, __tuple_types<_Up...>, __tuple_indices<_Np...>) {
     _VSTD::__swallow(((
-        _VSTD::get<_Np>(__dest) = _VSTD::forward<_Up>(_VSTD::get<_Np>(_VSTD::forward<_Source>(__source)))
+        _VSTD::get<_Np>(__dest) = _VSTD::forward<_Up>(_VSTD::get<_Np>(__source))
     ), void(), 0)...);
 }
 
 template <class ..._Tp>
 class _LIBCPP_TEMPLATE_VIS tuple
 {
     typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;
 
public:
     ,int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     tuple& operator=(pair<_Up1, _Up2>&& __pair)
         _NOEXCEPT_((_And<
             is_nothrow_assignable<_FirstType<_Tp...>&, _Up1>,
             is_nothrow_assignable<_SecondType<_Tp...>&, _Up2>
         >::value))
     {
-        _VSTD::get<0>(*this) = _VSTD::move(__pair.first);
-        _VSTD::get<1>(*this) = _VSTD::move(__pair.second);
+        _VSTD::get<0>(*this) = _VSTD::forward<_Up1>(__pair.first);
+        _VSTD::get<1>(*this) = _VSTD::forward<_Up2>(__pair.second);
         return *this;
     }
 
     // EXTENSION
     template<class _Up, size_t _Np, class = _EnableIf<
         _And<
             _BoolConstant<_Np == sizeof...(_Tp)>,
             is_assignable<_Tp&, _Up const&>...

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp

 
 struct E {
   E() = default;
   E& operator=(int) {
       return *this;
   }
 };
 
+struct NothrowMoveAssignable {
+    NothrowMoveAssignable& operator=(NothrowMoveAssignable&&) noexcept { return *this; }
+};
+
+struct PotentiallyThrowingMoveAssignable {
+    PotentiallyThrowingMoveAssignable& operator=(PotentiallyThrowingMoveAssignable&&) { return *this; }
+};
+
 struct NonAssignable {
   NonAssignable& operator=(NonAssignable const&) = delete;
   NonAssignable& operator=(NonAssignable&&) = delete;
 };
 
-struct NothrowMoveAssignable
-{
-    NothrowMoveAssignable& operator=(NothrowMoveAssignable&&) noexcept { return *this; }
+struct MoveAssignable {
+  MoveAssignable& operator=(MoveAssignable const&) = delete;
+  MoveAssignable& operator=(MoveAssignable&&) = default;
+};
+
+struct CopyAssignable {
+  CopyAssignable& operator=(CopyAssignable const&) = default;
+  CopyAssignable& operator=(CopyAssignable&&) = delete;
 };
 
-struct PotentiallyThrowingMoveAssignable
+struct TrackMove
 {
-    PotentiallyThrowingMoveAssignable& operator=(PotentiallyThrowingMoveAssignable&&) { return *this; }
+    TrackMove() : value(0), moved_from(false) { }
+    explicit TrackMove(int v) : value(v), moved_from(false) { }
+    TrackMove(TrackMove const& other) : value(other.value), moved_from(false) { }
+    TrackMove(TrackMove&& other) : value(other.value), moved_from(false) {
+        other.moved_from = true;
+    }
+    TrackMove& operator=(TrackMove const& other) {
+        value = other.value;
+        moved_from = false;
+        return *this;
+    }
+    TrackMove& operator=(TrackMove&& other) {
+        value = other.value;
+        moved_from = false;
+        other.moved_from = true;
+        return *this;
+    }
+
+    int value;
+    bool moved_from;
 };
 
 int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
         typedef std::tuple<long long> T1;
         T0 t0(2);
int main(int, char**)
         typedef std::tuple<NothrowMoveAssignable, int> T1;
         static_assert(std::is_nothrow_assignable<T0&, T1&&>::value, "");
     }
     {
         typedef std::tuple<PotentiallyThrowingMoveAssignable, long> T0;
         typedef std::tuple<PotentiallyThrowingMoveAssignable, int> T1;
         static_assert(!std::is_nothrow_assignable<T0&, T1&&>::value, "");
     }
+    {
+        // We assign through the reference and don't move out of the incoming ref,
+        // so this doesn't work (but would if the type were CopyAssignable).
+        {
+            using T1 = std::tuple<MoveAssignable&, long>;
+            using T2 = std::tuple<MoveAssignable&, int>;
+            static_assert(!std::is_assignable<T1&, T2&&>::value, "");
+        }
+
+        // ... works if it's CopyAssignable
+        {
+            using T1 = std::tuple<CopyAssignable&, long>;
+            using T2 = std::tuple<CopyAssignable&, int>;
+            static_assert(std::is_assignable<T1&, T2&&>::value, "");
+        }
+
+        // For rvalue-references, we can move-assign if the type is MoveAssignable
+        // or CopyAssignable (since in the worst case the move will decay into a copy).
+        {
+            using T1 = std::tuple<MoveAssignable&&, long>;
+            using T2 = std::tuple<MoveAssignable&&, int>;
+            static_assert(std::is_assignable<T1&, T2&&>::value, "");
+
+            using T3 = std::tuple<CopyAssignable&&, long>;
+            using T4 = std::tuple<CopyAssignable&&, int>;
+            static_assert(std::is_assignable<T3&, T4&&>::value, "");
+        }
+
+        // In all cases, we can't move-assign if the types are not assignable,
+        // since we assign through the reference.
+        {
+            using T1 = std::tuple<NonAssignable&, long>;
+            using T2 = std::tuple<NonAssignable&, int>;
+            static_assert(!std::is_assignable<T1&, T2&&>::value, "");
+
+            using T3 = std::tuple<NonAssignable&&, long>;
+            using T4 = std::tuple<NonAssignable&&, int>;
+            static_assert(!std::is_assignable<T3&, T4&&>::value, "");
+        }
+    }
+    {
+        // Make sure that we don't incorrectly move out of the source's reference.
+        using Dest = std::tuple<TrackMove, long>;
+        using Source = std::tuple<TrackMove&, int>;
+        TrackMove track{3};
+        Source src(track, 4);
+        assert(!track.moved_from);
+
+        Dest dst;
+        dst = std::move(src); // here we should make a copy
+        assert(!track.moved_from);
+        assert(std::get<0>(dst).value == 3);
+    }
+    {
+        // But we do move out of the source's reference if it's a rvalue ref
+        using Dest = std::tuple<TrackMove, long>;
+        using Source = std::tuple<TrackMove&&, int>;
+        TrackMove track{3};
+        Source src(std::move(track), 4);
+        assert(!track.moved_from); // we just took a reference
+
+        Dest dst;
+        dst = std::move(src);
+        assert(track.moved_from);
+        assert(std::get<0>(dst).value == 3);
+    }
+    {
+        // If the source holds a value, then we move out of it too
+        using Dest = std::tuple<TrackMove, long>;
+        using Source = std::tuple<TrackMove, int>;
+        Source src(TrackMove{3}, 4);
+        Dest dst;
+        dst = std::move(src);
+        assert(std::get<0>(src).moved_from);
+        assert(std::get<0>(dst).value == 3);
+    }
 
     return 0;
 }

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

int main(int, char**)
     {
         using T = std::tuple<NothrowMoveAssignable, int>;
         static_assert(std::is_nothrow_move_assignable<T>::value, "");
     }
     {
         using T = std::tuple<PotentiallyThrowingMoveAssignable, int>;
         static_assert(!std::is_nothrow_move_assignable<T>::value, "");
     }
+    {
+        // We assign through the reference and don't move out of the incoming ref,
+        // so this doesn't work (but would if the type were CopyAssignable).
+        using T1 = std::tuple<MoveAssignable&, int>;
+        static_assert(!std::is_move_assignable<T1>::value, "");
+
+        // ... works if it's CopyAssignable
+        using T2 = std::tuple<CopyAssignable&, int>;
+        static_assert(std::is_move_assignable<T2>::value, "");
+
+        // For rvalue-references, we can move-assign if the type is MoveAssignable
+        // or CopyAssignable (since in the worst case the move will decay into a copy).
+        using T3 = std::tuple<MoveAssignable&&, int>;
+        using T4 = std::tuple<CopyAssignable&&, int>;
+        static_assert(std::is_move_assignable<T3>::value, "");
+        static_assert(std::is_move_assignable<T4>::value, "");
+
+        // In all cases, we can't move-assign if the types are not assignable,
+        // since we assign through the reference.
+        using T5 = std::tuple<NonAssignable&, int>;
+        using T6 = std::tuple<NonAssignable&&, int>;
+        static_assert(!std::is_move_assignable<T5>::value, "");
+        static_assert(!std::is_move_assignable<T6>::value, "");
+    }
 
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp

 };
 
 struct D
     : B
 {
     explicit D(int i) : B(i) {}
 };
 
+struct TrackMove
+{
+    TrackMove() : value(0), moved_from(false) { }
+    explicit TrackMove(int v) : value(v), moved_from(false) { }
+    TrackMove(TrackMove const& other) : value(other.value), moved_from(false) { }
+    TrackMove(TrackMove&& other) : value(other.value), moved_from(false) {
+        other.moved_from = true;
+    }
+    TrackMove& operator=(TrackMove const& other) {
+        value = other.value;
+        moved_from = false;
+        return *this;
+    }
+    TrackMove& operator=(TrackMove&& other) {
+        value = other.value;
+        moved_from = false;
+        other.moved_from = true;
+        return *this;
+    }
+
+    int value;
+    bool moved_from;
+};
+
 struct NonAssignable
 {
   NonAssignable& operator=(NonAssignable const&) = delete;
   NonAssignable& operator=(NonAssignable&&) = delete;
 };
 
+struct MoveAssignable
+{
+  MoveAssignable& operator=(MoveAssignable const&) = delete;
+  MoveAssignable& operator=(MoveAssignable&&) = default;
+};
+
+struct CopyAssignable
+{
+  CopyAssignable& operator=(CopyAssignable const&) = default;
+  CopyAssignable& operator=(CopyAssignable&&) = delete;
+};
+
 struct NothrowMoveAssignable
 {
     NothrowMoveAssignable& operator=(NothrowMoveAssignable&&) noexcept { return *this; }
 };
 
 struct PotentiallyThrowingMoveAssignable
 {
     PotentiallyThrowingMoveAssignable& operator=(PotentiallyThrowingMoveAssignable&&) { return *this; }
int main(int, char**)
     }
     {
         typedef std::tuple<PotentiallyThrowingMoveAssignable, long> Tuple;
         typedef std::pair<PotentiallyThrowingMoveAssignable, int> Pair;
         static_assert(std::is_assignable<Tuple&, Pair&&>::value, "");
         static_assert(!std::is_nothrow_assignable<Tuple&, Pair&&>::value, "");
         static_assert(!std::is_assignable<Tuple&, Pair const&&>::value, "");
     }
+    {
+        // We assign through the reference and don't move out of the incoming ref,
+        // so this doesn't work (but would if the type were CopyAssignable).
+        {
+            using T = std::tuple<MoveAssignable&, int>;
+            using P = std::pair<MoveAssignable&, int>;
+            static_assert(!std::is_assignable<T&, P&&>::value, "");
+        }
+
+        // ... works if it's CopyAssignable
+        {
+            using T = std::tuple<CopyAssignable&, int>;
+            using P = std::pair<CopyAssignable&, int>;
+            static_assert(std::is_assignable<T&, P&&>::value, "");
+        }
+
+        // For rvalue-references, we can move-assign if the type is MoveAssignable
+        // or CopyAssignable (since in the worst case the move will decay into a copy).
+        {
+            using T1 = std::tuple<MoveAssignable&&, int>;
+            using P1 = std::pair<MoveAssignable&&, int>;
+            static_assert(std::is_assignable<T1&, P1&&>::value, "");
+
+            using T2 = std::tuple<CopyAssignable&&, int>;
+            using P2 = std::pair<CopyAssignable&&, int>;
+            static_assert(std::is_assignable<T2&, P2&&>::value, "");
+        }
+
+        // In all cases, we can't move-assign if the types are not assignable,
+        // since we assign through the reference.
+        {
+            using T1 = std::tuple<NonAssignable&, int>;
+            using P1 = std::pair<NonAssignable&, int>;
+            static_assert(!std::is_assignable<T1&, P1&&>::value, "");
+
+            using T2 = std::tuple<NonAssignable&&, int>;
+            using P2 = std::pair<NonAssignable&&, int>;
+            static_assert(!std::is_assignable<T2&, P2&&>::value, "");
+        }
+    }
+    {
+        // Make sure that we don't incorrectly move out of the source's reference.
+        using Dest = std::tuple<TrackMove, int>;
+        using Source = std::pair<TrackMove&, int>;
+        TrackMove track{3};
+        Source src(track, 4);
+        assert(!track.moved_from);
+
+        Dest dst;
+        dst = std::move(src); // here we should make a copy
+        assert(!track.moved_from);
+        assert(std::get<0>(dst).value == 3);
+    }
+    {
+        // But we do move out of the source's reference if it's a rvalue ref
+        using Dest = std::tuple<TrackMove, int>;
+        using Source = std::pair<TrackMove&&, int>;
+        TrackMove track{3};
+        Source src(std::move(track), 4);
+        assert(!track.moved_from); // we just took a reference
+
+        Dest dst;
+        dst = std::move(src);
+        assert(track.moved_from);
+        assert(std::get<0>(dst).value == 3);
+    }
+    {
+        // If the pair holds a value, then we move out of it too
+        using Dest = std::tuple<TrackMove, int>;
+        using Source = std::pair<TrackMove, int>;
+        Source src(TrackMove{3}, 4);
+        Dest dst;
+        dst = std::move(src);
+        assert(src.first.moved_from);
+        assert(std::get<0>(dst).value == 3);
+    }
 
     return 0;
 }

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

struct CountAssign {
   }
 };
 
 struct NotAssignable {
   NotAssignable& operator=(NotAssignable const&) = delete;
   NotAssignable& operator=(NotAssignable&&) = delete;
 };
 
+struct MoveAssignable {
+  MoveAssignable& operator=(MoveAssignable const&) = delete;
+  MoveAssignable& operator=(MoveAssignable&&) = default;
+};
+
+struct CopyAssignable {
+  CopyAssignable& operator=(CopyAssignable const&) = default;
+  CopyAssignable& operator=(CopyAssignable&&) = delete;
+};
+
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef std::pair<ConstexprTestTypes::MoveOnly, int> P;
     P p1(3, 4);
     P p2;
     p2 = std::move(p1);
     assert(p2.first.value == 3);
     assert(p2.second == 4);
TEST_CONSTEXPR_CXX20 bool test() {
     P p2;
     p = std::move(p2);
     assert(p.first.moved == 1);
     assert(p.first.copied == 0);
     assert(p2.first.moved == 0);
     assert(p2.first.copied == 0);
   }
   {
-    using T = std::pair<int, NotAssignable>;
-    using P = std::pair<int, NotAssignable>;
-    static_assert(!std::is_assignable<T&, P&&>::value, "");
+    using P1 = std::pair<int, NotAssignable>;
+    using P2 = std::pair<NotAssignable, int>;
+    using P3 = std::pair<NotAssignable, NotAssignable>;
+    static_assert(!std::is_move_assignable<P1>::value, "");
+    static_assert(!std::is_move_assignable<P2>::value, "");
+    static_assert(!std::is_move_assignable<P3>::value, "");
+  }
+  {
+    // We assign through the reference and don't move out of the incoming ref,
+    // so this doesn't work (but would if the type were CopyAssignable).
+    using P1 = std::pair<MoveAssignable&, int>;
+    static_assert(!std::is_move_assignable<P1>::value, "");
+
+    // ... works if it's CopyAssignable
+    using P2 = std::pair<CopyAssignable&, int>;
+    static_assert(std::is_move_assignable<P2>::value, "");
+
+    // For rvalue-references, we can move-assign if the type is MoveAssignable
+    // or CopyAssignable (since in the worst case the move will decay into a copy).
+    using P3 = std::pair<MoveAssignable&&, int>;
+    using P4 = std::pair<CopyAssignable&&, int>;
+    static_assert(std::is_move_assignable<P3>::value, "");
+    static_assert(std::is_move_assignable<P4>::value, "");
+
+    // In all cases, we can't move-assign if the types are not assignable,
+    // since we assign through the reference.
+    using P5 = std::pair<NotAssignable&, int>;
+    using P6 = std::pair<NotAssignable&&, int>;
+    static_assert(!std::is_move_assignable<P5>::value, "");
+    static_assert(!std::is_move_assignable<P6>::value, "");
   }
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 20
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp

TEST_CONSTEXPR_CXX20 CountAssign& operator=(CountAssign&&) {
     return *this;
   }
 };
 
 struct CopyAssignableInt {
   CopyAssignableInt& operator=(int&) { return *this; }
 };
 
+struct NotAssignable {
+  NotAssignable& operator=(NotAssignable const&) = delete;
+  NotAssignable& operator=(NotAssignable&&) = delete;
+};
+
+struct MoveAssignable {
+  MoveAssignable& operator=(MoveAssignable const&) = delete;
+  MoveAssignable& operator=(MoveAssignable&&) = default;
+};
+
+struct CopyAssignable {
+  CopyAssignable& operator=(CopyAssignable const&) = default;
+  CopyAssignable& operator=(CopyAssignable&&) = delete;
+};
+
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef std::pair<Derived, short> P1;
     typedef std::pair<ConstexprTestTypes::MoveOnly, long> P2;
     P1 p1(Derived(), static_cast<short>(4));
     P2 p2;
     p2 = std::move(p1);
     assert(p2.second == 4);
TEST_CONSTEXPR_CXX20 bool test() {
     assert(t.second.copied == 0);
   }
   { // test const requirement
     using T = std::pair<CopyAssignableInt, CopyAssignableInt>;
     using P = std::pair<int, int>;
     static_assert(!std::is_assignable<T&, P&&>::value, "");
     static_assert(!std::is_assignable<P&, T&&>::value, "");
   }
+  {
+    // Make sure we can't move-assign from a pair containing a reference
+    // if that type isn't copy-constructible (since otherwise we'd be
+    // stealing the object through the reference).
+    using P1 = std::pair<MoveAssignable, long>;
+    using P2 = std::pair<MoveAssignable&, int>;
+    static_assert(!std::is_assignable<P1&, P2&&>::value, "");
+
+    // ... but this should work since we're going to steal out of the
+    // incoming rvalue reference.
+    using P3 = std::pair<MoveAssignable, long>;
+    using P4 = std::pair<MoveAssignable&&, int>;
+    static_assert(std::is_assignable<P3&, P4&&>::value, "");
+  }
+  {
+    // We assign through the reference and don't move out of the incoming ref,
+    // so this doesn't work (but would if the type were CopyAssignable).
+    {
+      using P1 = std::pair<MoveAssignable&, long>;
+      using P2 = std::pair<MoveAssignable&, int>;
+      static_assert(!std::is_assignable<P1&, P2&&>::value, "");
+    }
+
+    // ... works if it's CopyAssignable
+    {
+      using P1 = std::pair<CopyAssignable&, long>;
+      using P2 = std::pair<CopyAssignable&, int>;
+      static_assert(std::is_assignable<P1&, P2&&>::value, "");
+    }
+
+    // For rvalue-references, we can move-assign if the type is MoveAssignable,
+    // or CopyAssignable (since in the worst case the move will decay into a copy).
+    {
+      using P1 = std::pair<MoveAssignable&&, long>;
+      using P2 = std::pair<MoveAssignable&&, int>;
+      static_assert(std::is_assignable<P1&, P2&&>::value, "");
+
+      using P3 = std::pair<CopyAssignable&&, long>;
+      using P4 = std::pair<CopyAssignable&&, int>;
+      static_assert(std::is_assignable<P3&, P4&&>::value, "");
+    }
+
+    // In all cases, we can't move-assign if the types are not assignable,
+    // since we assign through the reference.
+    {
+      using P1 = std::pair<NotAssignable&, long>;
+      using P2 = std::pair<NotAssignable&, int>;
+      static_assert(!std::is_assignable<P1&, P2&&>::value, "");
+
+      using P3 = std::pair<NotAssignable&&, long>;
+      using P4 = std::pair<NotAssignable&&, int>;
+      static_assert(!std::is_assignable<P3&, P4&&>::value, "");
+    }
+  }
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 20
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp

 
 #include "test_macros.h"
 
 struct Dummy {
   Dummy(Dummy const&) = delete;
   Dummy(Dummy &&) = default;
 };
 
+struct NotCopyOrMoveConstructible {
+  NotCopyOrMoveConstructible() = default;
+  NotCopyOrMoveConstructible(NotCopyOrMoveConstructible const&) = delete;
+  NotCopyOrMoveConstructible(NotCopyOrMoveConstructible&&) = delete;
+};
+
 int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
         static_assert(std::is_move_constructible<P1>::value, "");
         P1 p1(3, static_cast<short>(4));
         P1 p2 = std::move(p1);
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
     {
         using P = std::pair<Dummy, int>;
         static_assert(!std::is_copy_constructible<P>::value, "");
         static_assert(std::is_move_constructible<P>::value, "");
     }
+    {
+        // When constructing a pair containing a reference, we only bind the
+        // reference, so it doesn't matter whether the type is or isn't
+        // copy/move constructible.
+        {
+            using P = std::pair<NotCopyOrMoveConstructible&, int>;
+            static_assert(std::is_move_constructible<P>::value, "");
+
+            NotCopyOrMoveConstructible obj;
+            P p2{obj, 3};
+            P p1(std::move(p2));
+            assert(&p1.first == &obj);
+            assert(&p2.first == &obj);
+        }
+        {
+            using P = std::pair<NotCopyOrMoveConstructible&&, int>;
+            static_assert(std::is_move_constructible<P>::value, "");
+
+            NotCopyOrMoveConstructible obj;
+            P p2{std::move(obj), 3};
+            P p1(std::move(p2));
+            assert(&p1.first == &obj);
+            assert(&p2.first == &obj);
+        }
+    }
 
     return 0;
 }

libcxx/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp

struct ExplicitT {
   int value;
 };
 
 struct ImplicitT {
   constexpr ImplicitT(int x) : value(x) {}
   int value;
 };
 
+struct NotCopyOrMoveConstructible {
+  NotCopyOrMoveConstructible() = default;
+  NotCopyOrMoveConstructible(NotCopyOrMoveConstructible const&) = delete;
+  NotCopyOrMoveConstructible(NotCopyOrMoveConstructible&&) = delete;
+};
+
+struct NonCopyConstructible {
+    NonCopyConstructible(NonCopyConstructible const&) = delete;
+    NonCopyConstructible(NonCopyConstructible&&) = default;
+};
+
 int main(int, char**)
 {
     {
         typedef std::pair<std::unique_ptr<Derived>, int> P1;
         typedef std::pair<std::unique_ptr<Base>, long> P2;
         P1 p1(std::unique_ptr<Derived>(), 4);
         P2 p2 = std::move(p1);
         assert(p2.first == nullptr);
int main(int, char**)
         test_pair_rv<ExplicitTypes::ConvertingType, int&&, true, false>();
         test_pair_rv<ExplicitTypes::ConvertingType, const int&&, true, false>();
 
         test_pair_rv<ExplicitTypes::ConvertingType, ExplicitTypes::ConvertingType>();
         test_pair_rv<ExplicitTypes::ConvertingType, ExplicitTypes::ConvertingType const&, true, false>();
         test_pair_rv<ExplicitTypes::ConvertingType, ExplicitTypes::ConvertingType&, true, false>();
         test_pair_rv<ExplicitTypes::ConvertingType, ExplicitTypes::ConvertingType&&, true, false>();
     }
+    {
+        // When constructing a pair containing a reference, we only bind the
+        // reference, so it doesn't matter whether the type is or isn't
+        // copy/move constructible.
+        {
+            using P1 = std::pair<NotCopyOrMoveConstructible&, long>;
+            using P2 = std::pair<NotCopyOrMoveConstructible&, int>;
+            static_assert(std::is_constructible<P1, P2&&>::value, "");
+
+            NotCopyOrMoveConstructible obj;
+            P2 p2{obj, 3};
+            P1 p1(std::move(p2));
+            assert(&p1.first == &obj);
+            assert(&p2.first == &obj);
+        }
+        {
+            using P1 = std::pair<NotCopyOrMoveConstructible&&, long>;
+            using P2 = std::pair<NotCopyOrMoveConstructible&&, int>;
+            static_assert(std::is_constructible<P1, P2&&>::value, "");
+
+            NotCopyOrMoveConstructible obj;
+            P2 p2{std::move(obj), 3};
+            P1 p1(std::move(p2));
+            assert(&p1.first == &obj);
+            assert(&p2.first == &obj);
+        }
+    }
+    {
+        // Make sure we can't move-construct from a pair containing a reference
+        // if that type isn't copy-constructible (since otherwise we'd be stealing
+        // the object through the reference).
+        using P1 = std::pair<NonCopyConstructible, long>;
+        using P2 = std::pair<NonCopyConstructible&, int>;
+        static_assert(!std::is_constructible<P1, P2&&>::value, "");
+    }
 #if TEST_STD_VER > 11
     { // explicit constexpr test
         constexpr std::pair<int, int> p1(42, 43);
         constexpr std::pair<ExplicitT, ExplicitT> p2(std::move(p1));
         static_assert(p2.first.value == 42, "");
         static_assert(p2.second.value == 43, "");
     }
     { // implicit constexpr test