diff --git a/libcxx/include/__tuple b/libcxx/include/__tuple
--- a/libcxx/include/__tuple
+++ b/libcxx/include/__tuple
@@ -485,6 +485,10 @@
     template <class ...>
     static constexpr bool __enable_implicit() { return false; }
     template <class ...>
+    static constexpr bool __delete_explicit() { return false; }
+    template <class ...>
+    static constexpr bool __delete_implicit() { return false; }
+    template <class ...>
     static constexpr bool __enable_assign() { return false; }
 };
 #endif // !defined(_LIBCPP_CXX03_LANG)
@@ -546,6 +550,15 @@
 };
 #endif // _LIBCPP_STD_VER > 14
 
+template <class _Dest, class _Src>
+struct reference_constructs_from_temporary
+#if __has_keyword(__reference_binds_to_temporary)
+    : integral_constant<bool, __reference_binds_to_temporary(_Dest, _Src)>
+#else
+    : false_type
+#endif
+{};
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TUPLE
diff --git a/libcxx/include/__utility/pair.h b/libcxx/include/__utility/pair.h
--- a/libcxx/include/__utility/pair.h
+++ b/libcxx/include/__utility/pair.h
@@ -88,7 +88,7 @@
       }
 
       template <class _U1, class _U2>
-      static constexpr bool __enable_explicit() {
+      static constexpr bool __enable_explicit_base() {
           return is_constructible<first_type, _U1>::value
               && is_constructible<second_type, _U2>::value
               && (!is_convertible<_U1, first_type>::value
@@ -96,12 +96,36 @@
       }
 
       template <class _U1, class _U2>
-      static constexpr bool __enable_implicit() {
+      static constexpr bool __binds_to_temporary() {
+          return reference_constructs_from_temporary<first_type, _U1&&>::value
+              || reference_constructs_from_temporary<second_type, _U2&&>::value;
+      }
+
+      template <class _U1, class _U2>
+      static constexpr bool __enable_explicit() {
+          return __enable_explicit_base<_U1, _U2>() && !__binds_to_temporary<_U1, _U2>();
+      }
+
+      template <class _U1, class _U2>
+      static constexpr bool __delete_explicit() {
+          return __enable_explicit_base<_U1, _U2>() && __binds_to_temporary<_U1, _U2>();
+      }
+      template <class _U1, class _U2>
+      static constexpr bool __enable_implicit_base() {
           return is_constructible<first_type, _U1>::value
               && is_constructible<second_type, _U2>::value
               && is_convertible<_U1, first_type>::value
               && is_convertible<_U2, second_type>::value;
       }
+      template <class _U1, class _U2>
+      static constexpr bool __enable_implicit() {
+          return __enable_implicit_base<_U1, _U2>() && !__binds_to_temporary<_U1, _U2>();
+      }
+
+      template <class _U1, class _U2>
+      static constexpr bool __delete_implicit() {
+          return __enable_implicit_base<_U1, _U2>() && __binds_to_temporary<_U1, _U2>();
+      }
     };
 
     template <bool _MaybeEnable>
@@ -182,6 +206,16 @@
                     is_nothrow_constructible<second_type, _U2>::value))
         : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
 
+    template <
+#if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951
+        class _U1 = _T1, class _U2 = _T2,
+#else
+        class _U1, class _U2,
+#endif
+        typename enable_if<_CheckArgs::template __delete_explicit<_U1, _U2>()>::type* = nullptr
+    >
+    explicit pair(_U1&&, _U2&&) = delete;
+
     template <
 #if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951
         class _U1 = _T1, class _U2 = _T2,
@@ -196,35 +230,88 @@
                     is_nothrow_constructible<second_type, _U2>::value))
         : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
 
+    template <
+#if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951
+        class _U1 = _T1, class _U2 = _T2,
+#else
+        class _U1, class _U2,
+#endif
+        typename enable_if<_CheckArgs::template __delete_implicit<_U1, _U2>()>::type* = nullptr
+    >
+    pair(_U1&&, _U2&&) = delete;
+
+    template<class _U1, class _U2, typename enable_if<
+            _CheckArgs::template __enable_explicit<_U1&, _U2&>()
+    >::type* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    explicit pair(pair<_U1, _U2>& __p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&>::value &&
+                    is_nothrow_constructible<second_type, _U2&>::value))
+        : first(__p.first), second(__p.second) {}
+
     template<class _U1, class _U2, typename enable_if<
-            _CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>()
+            _CheckArgs::template __delete_explicit<_U1&, _U2&>()
+    >::type* = nullptr>
+    explicit pair(pair<_U1, _U2>& __p) = delete;
+
+    template<class _U1, class _U2, typename enable_if<
+            _CheckArgs::template __enable_implicit<_U1&, _U2&>()
     >::type* = nullptr>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-    explicit pair(pair<_U1, _U2> const& __p)
-        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
-                    is_nothrow_constructible<second_type, _U2 const&>::value))
+    pair(pair<_U1, _U2>& __p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&>::value &&
+                    is_nothrow_constructible<second_type, _U2&>::value))
         : first(__p.first), second(__p.second) {}
 
     template<class _U1, class _U2, typename enable_if<
-            _CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>()
+            _CheckArgs::template __delete_implicit<_U1&, _U2&>()
+    >::type* = nullptr>
+    pair(pair<_U1, _U2>&) = delete;
+
+        template<class _U1, class _U2, typename enable_if<
+            _CheckArgs::template __enable_explicit<const _U1&, const _U2&>()
     >::type* = nullptr>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-    pair(pair<_U1, _U2> const& __p)
-        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
-                    is_nothrow_constructible<second_type, _U2 const&>::value))
+    explicit pair(const pair<_U1, _U2>& __p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, const _U1&>::value &&
+                    is_nothrow_constructible<second_type, const _U2&>::value))
         : first(__p.first), second(__p.second) {}
 
     template<class _U1, class _U2, typename enable_if<
-            _CheckArgs::template __enable_explicit<_U1, _U2>()
+            _CheckArgs::template __delete_explicit<const _U1&, const _U2&>()
+    >::type* = nullptr>
+    explicit pair(const pair<_U1, _U2>& __p) = delete;
+
+    template<class _U1, class _U2, typename enable_if<
+            _CheckArgs::template __enable_implicit<const _U1&, const _U2&>()
     >::type* = nullptr>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-    explicit pair(pair<_U1, _U2>&&__p)
+    pair(const pair<_U1, _U2>& __p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, const _U1&>::value &&
+                    is_nothrow_constructible<second_type, const _U2&>::value))
+        : first(__p.first), second(__p.second) {}
+
+    template<class _U1, class _U2, typename enable_if<
+            _CheckArgs::template __delete_implicit<const _U1&, const _U2&>()
+    >::type* = nullptr>
+    pair(const pair<_U1, _U2>&) = delete;
+
+    template<class _U1, class _U2, typename enable_if<
+            _CheckArgs::template __enable_explicit<_U1&&, _U2&&>()
+    >::type* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    explicit pair(pair<_U1, _U2>&& __p)
         _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
                     is_nothrow_constructible<second_type, _U2&&>::value))
         : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
 
     template<class _U1, class _U2, typename enable_if<
-            _CheckArgs::template __enable_implicit<_U1, _U2>()
+            _CheckArgs::template __delete_explicit<_U1&&, _U2&&>()
+    >::type* = nullptr>
+    explicit pair(pair<_U1, _U2>&& __p) = delete;
+
+    template<class _U1, class _U2, typename enable_if<
+            _CheckArgs::template __enable_implicit<_U1&&, _U2&&>()
     >::type* = nullptr>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     pair(pair<_U1, _U2>&& __p)
@@ -232,6 +319,39 @@
                     is_nothrow_constructible<second_type, _U2&&>::value))
         : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
 
+    template<class _U1, class _U2, typename enable_if<
+            _CheckArgs::template __delete_implicit<_U1&&, _U2&&>()
+    >::type* = nullptr>
+    pair(pair<_U1, _U2>&&) = delete;
+
+    template<class _U1, class _U2, typename enable_if<
+            _CheckArgs::template __enable_explicit<const _U1&&, const _U2&&>()
+    >::type* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    explicit pair(const pair<_U1, _U2>&& __p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, const _U1&&>::value &&
+                    is_nothrow_constructible<second_type, const _U2&&>::value))
+        : first(_VSTD::forward<const _U1>(__p.first)), second(_VSTD::forward<const _U2>(__p.second)) {}
+
+    template<class _U1, class _U2, typename enable_if<
+            _CheckArgs::template __delete_explicit<const _U1&&, const _U2&&>()
+    >::type* = nullptr>
+    explicit pair(const pair<_U1, _U2>&& __p) = delete;
+
+    template<class _U1, class _U2, typename enable_if<
+            _CheckArgs::template __enable_implicit<const _U1&&, const _U2&&>()
+    >::type* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    pair(const pair<_U1, _U2>&& __p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, const _U1&&>::value &&
+                    is_nothrow_constructible<second_type, const _U2&&>::value))
+        : first(_VSTD::forward<const _U1>(__p.first)), second(_VSTD::forward<const _U2>(__p.second)) {}
+
+    template<class _U1, class _U2, typename enable_if<
+            _CheckArgs::template __delete_implicit<const _U1&&, const _U2&&>()
+    >::type* = nullptr>
+    pair(const pair<_U1, _U2>&&) = delete;
+
     template<class _Tuple, typename enable_if<
             _CheckTLC<_Tuple>::template __enable_explicit<_Tuple>()
     >::type* = nullptr>
diff --git a/libcxx/include/tuple b/libcxx/include/tuple
--- a/libcxx/include/tuple
+++ b/libcxx/include/tuple
@@ -594,17 +594,33 @@
     template <class ..._Up> struct _IsThisTuple : false_type { };
     template <class _Up> struct _IsThisTuple<_Up> : is_same<__uncvref_t<_Up>, tuple> { };
 
+    template <class _Self, class ..._Up> struct _CheckAllocatorArg : false_type { };
+    template <class _T0, class... _Stail, class _U0, class ..._Tail>
+    struct _CheckAllocatorArg<tuple<_T0, _Stail...>, _U0, _Tail...>
+        : integral_constant<bool,
+            (sizeof...(_Tail) == 1 || sizeof...(_Tail) == 2) &&
+            is_same<__uncvref_t<_U0>, allocator_arg_t>::value &&
+            !is_same<__uncvref_t<_T0>, allocator_arg_t>::value>
+    { };
+
     template <class ..._Up>
     struct _EnableUTypesCtor : _And<
         _BoolConstant<sizeof...(_Tp) >= 1>,
         _Not<_IsThisTuple<_Up...> >, // extension to allow mis-behaved user constructors
+        _Not<_CheckAllocatorArg<tuple, _Up...>>,
         is_constructible<_Tp, _Up>...
     > { };
 
+    template <class ..._Up>
+    struct _BindsReferenceToTemporary :
+        _Not<_And<_Not<reference_constructs_from_temporary<_Tp, _Up>>...>>
+    { };
+
     template <class ..._Up, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
             _EnableUTypesCtor<_Up...>,
+            _Not<_BindsReferenceToTemporary<_Up...>>,
             is_convertible<_Up, _Tp>... // explicit check
         >::value
     , int> = 0>
@@ -621,6 +637,17 @@
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
             _EnableUTypesCtor<_Up...>,
+            _BindsReferenceToTemporary<_Up...>,
+            is_convertible<_Up, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(_Up&&...) = delete;
+
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableUTypesCtor<_Up...>,
+            _Not<_BindsReferenceToTemporary<_Up...>>,
             _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
         >::value
     , int> = 0>
@@ -633,10 +660,21 @@
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
                     _VSTD::forward<_Up>(__u)...) {}
 
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableUTypesCtor<_Up...>,
+            _BindsReferenceToTemporary<_Up...>,
+            _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(_Up&&...) = delete;
+
     template <class _Alloc, class ..._Up, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
             _EnableUTypesCtor<_Up...>,
+            _Not<_BindsReferenceToTemporary<_Up...>>,
             is_convertible<_Up, _Tp>... // explicit check
         >::value
     , int> = 0>
@@ -653,6 +691,17 @@
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
             _EnableUTypesCtor<_Up...>,
+            _BindsReferenceToTemporary<_Up...>,
+            is_convertible<_Up, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(allocator_arg_t, const _Alloc&, _Up&&...) = delete;
+
+    template <class _Alloc, class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableUTypesCtor<_Up...>,
+            _Not<_BindsReferenceToTemporary<_Up...>>,
             _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
         >::value
     , int> = 0>
@@ -665,6 +714,16 @@
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
                     _VSTD::forward<_Up>(__u)...) {}
 
+    template <class _Alloc, class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableUTypesCtor<_Up...>,
+            _BindsReferenceToTemporary<_Up...>,
+            _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(allocator_arg_t, const _Alloc&, _Up&&...) = delete;
+
     // Copy and move constructors (including the allocator_arg_t variants)
     tuple(const tuple&) = default;
     tuple(tuple&&) = default;
@@ -683,26 +742,128 @@
         : __base_(allocator_arg_t(), __alloc, _VSTD::move(__t))
     { }
 
-    // tuple(const tuple<U...>&) constructors (including allocator_arg_t variants)
-    template <class ..._Up>
-    struct _EnableCopyFromOtherTuple : _And<
+    template<class _Up> using _Lref = _Up&;
+    template<class _Up> using _Rref = _Up&&;
+    template<class _Up> using _Clref = _Up const&;
+    template<class _Up> using _Crref = _Up const&&;
+
+    // tuple(tuple<U...>&) constructors (including allocator_arg_t variants)
+    template <template<class> class _Ref, class ..._Up>
+    struct _EnableConstructFromOtherTuple : _And<
         _Not<is_same<tuple<_Tp...>, tuple<_Up...> > >,
         _Lazy<_Or,
             _BoolConstant<sizeof...(_Tp) != 1>,
             // _Tp and _Up are 1-element packs - the pack expansions look
             // weird to avoid tripping up the type traits in degenerate cases
             _Lazy<_And,
-                _Not<is_convertible<const tuple<_Up>&, _Tp> >...,
-                _Not<is_constructible<_Tp, const tuple<_Up>&> >...
+                _Not<is_convertible<_Ref<tuple<_Up>>, _Tp> >...,
+                _Not<is_constructible<_Tp, _Ref<tuple<_Up>>> >...
             >
         >,
-        is_constructible<_Tp, const _Up&>...
+        is_constructible<_Tp, _Ref<_Up>>...
     > { };
 
     template <class ..._Up, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableCopyFromOtherTuple<_Up...>,
+            _EnableConstructFromOtherTuple<_Lref, _Up...>,
+            _Not<_BindsReferenceToTemporary<_Up&...>>,
+            is_convertible<_Up&, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    tuple(tuple<_Up...>& __t)
+        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up&>...>::value))
+        : __base_(__t)
+    { }
+
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Lref, _Up...>,
+            _BindsReferenceToTemporary<_Up&...>,
+            is_convertible<_Up&, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(tuple<_Up...>&) = delete;
+
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Lref, _Up...>,
+            _Not<_BindsReferenceToTemporary<_Up&...>>,
+            _Not<_Lazy<_And, is_convertible<_Up&, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    explicit tuple(tuple<_Up...>& __t)
+        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up&>...>::value))
+        : __base_(__t)
+    { }
+
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Lref, _Up...>,
+            _BindsReferenceToTemporary<_Up&...>,
+            _Not<_Lazy<_And, is_convertible<_Up&, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(tuple<_Up...>&) = delete;
+
+    template <class ..._Up, class _Alloc, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Lref, _Up...>,
+            _Not<_BindsReferenceToTemporary<_Up&...>>,
+            is_convertible<_Up&, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>& __t)
+        : __base_(allocator_arg_t(), __a, __t)
+    { }
+
+    template <class ..._Up, class _Alloc, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Lref, _Up...>,
+            _BindsReferenceToTemporary< _Up&...>,
+            is_convertible<_Up&, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(allocator_arg_t, const _Alloc&, const tuple<_Up...>&) = delete;
+
+    template <class ..._Up, class _Alloc, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Lref, _Up...>,
+            _Not<_BindsReferenceToTemporary<_Up&...>>,
+            _Not<_Lazy<_And, is_convertible<_Up&, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>& __t)
+        : __base_(allocator_arg_t(), __a, __t)
+    { }
+
+    template <class ..._Up, class _Alloc, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Lref, _Up...>,
+            _BindsReferenceToTemporary<_Up&...>,
+            _Not<_Lazy<_And, is_convertible<_Up&, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(allocator_arg_t, const _Alloc&, tuple<_Up...>&) = delete;
+
+    // tuple(const tuple<U...>&) constructors (including allocator_arg_t variants)
+
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Clref, _Up...>,
+            _Not<_BindsReferenceToTemporary<const _Up&...>>,
             is_convertible<const _Up&, _Tp>... // explicit check
         >::value
     , int> = 0>
@@ -715,7 +876,18 @@
     template <class ..._Up, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableCopyFromOtherTuple<_Up...>,
+            _EnableConstructFromOtherTuple<_Clref, _Up...>,
+            _BindsReferenceToTemporary<const _Up&...>,
+            is_convertible<const _Up&, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(const tuple<_Up...>&) = delete;
+
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Clref, _Up...>,
+            _Not<_BindsReferenceToTemporary<const _Up&...>>,
             _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
         >::value
     , int> = 0>
@@ -725,10 +897,21 @@
         : __base_(__t)
     { }
 
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Clref, _Up...>,
+            _BindsReferenceToTemporary<const _Up&...>,
+            _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(const tuple<_Up...>&) = delete;
+
     template <class ..._Up, class _Alloc, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableCopyFromOtherTuple<_Up...>,
+            _EnableConstructFromOtherTuple<_Clref, _Up...>,
+            _Not<_BindsReferenceToTemporary<const _Up&...>>,
             is_convertible<const _Up&, _Tp>... // explicit check
         >::value
     , int> = 0>
@@ -740,7 +923,18 @@
     template <class ..._Up, class _Alloc, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableCopyFromOtherTuple<_Up...>,
+            _EnableConstructFromOtherTuple<_Clref, _Up...>,
+            _BindsReferenceToTemporary<const _Up&...>,
+            is_convertible<const _Up&, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(allocator_arg_t, const _Alloc&, const tuple<_Up...>&) = delete;
+
+    template <class ..._Up, class _Alloc, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Clref, _Up...>,
+            _Not<_BindsReferenceToTemporary<const _Up&...>>,
             _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
         >::value
     , int> = 0>
@@ -749,26 +943,22 @@
         : __base_(allocator_arg_t(), __a, __t)
     { }
 
-    // tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
-    template <class ..._Up>
-    struct _EnableMoveFromOtherTuple : _And<
-        _Not<is_same<tuple<_Tp...>, tuple<_Up...> > >,
-        _Lazy<_Or,
-            _BoolConstant<sizeof...(_Tp) != 1>,
-            // _Tp and _Up are 1-element packs - the pack expansions look
-            // weird to avoid tripping up the type traits in degenerate cases
-            _Lazy<_And,
-                _Not<is_convertible<tuple<_Up>, _Tp> >...,
-                _Not<is_constructible<_Tp, tuple<_Up> > >...
-            >
-        >,
-        is_constructible<_Tp, _Up>...
-    > { };
+    template <class ..._Up, class _Alloc, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Clref, _Up...>,
+            _BindsReferenceToTemporary<const _Up&...>,
+            _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(allocator_arg_t, const _Alloc&, const tuple<_Up...>&) = delete;
 
+    // tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
     template <class ..._Up, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableMoveFromOtherTuple<_Up...>,
+            _EnableConstructFromOtherTuple<_Rref, _Up...>,
+            _Not<_BindsReferenceToTemporary<_Up&&...>>,
             is_convertible<_Up, _Tp>... // explicit check
         >::value
     , int> = 0>
@@ -781,7 +971,18 @@
     template <class ..._Up, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableMoveFromOtherTuple<_Up...>,
+            _EnableConstructFromOtherTuple<_Rref, _Up...>,
+            _BindsReferenceToTemporary<_Up&&...>,
+            is_convertible<_Up, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(tuple<_Up...>&&) = delete;
+
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Rref, _Up...>,
+            _Not<_BindsReferenceToTemporary<_Up&&...>>,
             _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
         >::value
     , int> = 0>
@@ -791,10 +992,21 @@
         : __base_(_VSTD::move(__t))
     { }
 
-    template <class _Alloc, class ..._Up, __enable_if_t<
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Rref, _Up...>,
+            _BindsReferenceToTemporary<_Up&&...>,
+            _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(tuple<_Up...>&&) = delete;
+
+    template <class ..._Up, class _Alloc, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableMoveFromOtherTuple<_Up...>,
+            _EnableConstructFromOtherTuple<_Rref, _Up...>,
+            _Not<_BindsReferenceToTemporary<_Up&&...>>,
             is_convertible<_Up, _Tp>... // explicit check
         >::value
     , int> = 0>
@@ -803,10 +1015,21 @@
         : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
     { }
 
-    template <class _Alloc, class ..._Up, __enable_if_t<
+    template <class ..._Up, class _Alloc, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableMoveFromOtherTuple<_Up...>,
+            _EnableConstructFromOtherTuple<_Rref, _Up...>,
+            _BindsReferenceToTemporary<_Up&&...>,
+            is_convertible<_Up, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(allocator_arg_t, const _Alloc&, const tuple<_Up...>&&) = delete;
+
+    template <class ..._Up, class _Alloc, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Rref, _Up...>,
+            _Not<_BindsReferenceToTemporary<_Up&&...>>,
             _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
         >::value
     , int> = 0>
@@ -815,27 +1038,226 @@
         : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
     { }
 
-    // tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
-    template <class _Up1, class _Up2, class ..._DependentTp>
-    struct _EnableImplicitCopyFromPair : _And<
-        is_constructible<_FirstType<_DependentTp...>, const _Up1&>,
-        is_constructible<_SecondType<_DependentTp...>, const _Up2&>,
-        is_convertible<const _Up1&, _FirstType<_DependentTp...> >, // explicit check
-        is_convertible<const _Up2&, _SecondType<_DependentTp...> >
+    template <class ..._Up, class _Alloc, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Rref, _Up...>,
+            _BindsReferenceToTemporary<_Up&&...>,
+            _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(allocator_arg_t, const _Alloc&, tuple<_Up...>&&) = delete;
+
+    // tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants)
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Crref, _Up...>,
+            _Not<_BindsReferenceToTemporary<const _Up&&...> >,
+            is_convertible<const _Up, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    tuple(const tuple<_Up...>&& __t)
+        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up>...>::value))
+        : __base_(_VSTD::move(__t))
+    { }
+
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Crref, _Up...>,
+            _BindsReferenceToTemporary<const _Up&&...>,
+            is_convertible<const _Up, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(const tuple<_Up...>&&) = delete;
+
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Crref, _Up...>,
+            _Not<_BindsReferenceToTemporary<const _Up&&...>>,
+            _Not<_Lazy<_And, is_convertible<const _Up, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    explicit tuple(const tuple<_Up...>&& __t)
+        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up>...>::value))
+        : __base_(_VSTD::move(__t))
+    { }
+
+    template <class ..._Up, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Crref, _Up...>,
+            _BindsReferenceToTemporary<const _Up&&...>,
+            _Not<_Lazy<_And, is_convertible<const _Up, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(const tuple<_Up...>&&) = delete;
+
+    template <class ..._Up, class _Alloc, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Crref, _Up...>,
+            _Not<_BindsReferenceToTemporary<const _Up&&...>>,
+            is_convertible<const _Up, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>&& __t)
+        : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
+    { }
+
+    template <class ..._Up, class _Alloc, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Crref, _Up...>,
+            _BindsReferenceToTemporary<const _Up&&...>,
+            is_convertible<const _Up, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(allocator_arg_t, const _Alloc&, const tuple<_Up...>&&) = delete;
+
+    template <class ..._Up, class _Alloc, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Crref, _Up...>,
+            _Not<_BindsReferenceToTemporary<const _Up&&...>>,
+            _Not<_Lazy<_And, is_convertible<const _Up, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>&& __t)
+        : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
+    { }
+
+    template <class ..._Up, class _Alloc, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableConstructFromOtherTuple<_Crref, _Up...>,
+            _BindsReferenceToTemporary<const _Up&&...>,
+            _Not<_Lazy<_And, is_convertible<const _Up, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(allocator_arg_t, const _Alloc&, const tuple<_Up...>&&) = delete;
+
+    // tuple(pair<U1, U2>&) constructors (including allocator_arg_t variants)
+    template <template<class> class _Ref, class _Up1, class _Up2, class ..._DependentTp>
+    struct _EnableImplicitConstructFromPair : _And<
+        is_constructible<_FirstType<_DependentTp...>, _Ref<_Up1> >,
+        is_constructible<_SecondType<_DependentTp...>, _Ref<_Up2> >,
+        is_convertible<_Ref<_Up1>, _FirstType<_DependentTp...> >, // explicit check
+        is_convertible<_Ref<_Up2>, _SecondType<_DependentTp...> >
     > { };
 
-    template <class _Up1, class _Up2, class ..._DependentTp>
-    struct _EnableExplicitCopyFromPair : _And<
-        is_constructible<_FirstType<_DependentTp...>, const _Up1&>,
-        is_constructible<_SecondType<_DependentTp...>, const _Up2&>,
-        _Not<is_convertible<const _Up1&, _FirstType<_DependentTp...> > >, // explicit check
-        _Not<is_convertible<const _Up2&, _SecondType<_DependentTp...> > >
+    template <template<class> class _Ref, class _Up1, class _Up2, class ..._DependentTp>
+    struct _EnableExplicitConstructFromPair : _And<
+        is_constructible<_FirstType<_DependentTp...>, _Ref<_Up1> >,
+        is_constructible<_SecondType<_DependentTp...>, _Ref<_Up2> >,
+        _Not<is_convertible<_Ref<_Up1>, _FirstType<_DependentTp...> > >, // explicit check
+        _Not<is_convertible<_Ref<_Up2>, _SecondType<_DependentTp...> > >
     > { };
 
     template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableImplicitCopyFromPair<_Up1, _Up2, _Tp...>
+            _EnableImplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<_Up1&, _Up2&>>
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    tuple(pair<_Up1, _Up2>& __p)
+        _NOEXCEPT_((_And<
+            is_nothrow_constructible<_FirstType<_Tp...>, _Up1&>,
+            is_nothrow_constructible<_SecondType<_Tp...>, _Up2&>
+        >::value))
+        : __base_(__p)
+    { }
+
+    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableImplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<_Up1&, _Up2&>
+        >::value
+    , int> = 0>
+    tuple(pair<_Up1, _Up2>& __p) = delete;
+
+    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<_Up1&, _Up2&>>
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    explicit tuple(pair<_Up1, _Up2>& __p)
+        _NOEXCEPT_((_And<
+            is_nothrow_constructible<_FirstType<_Tp...>, _Up1&>,
+            is_nothrow_constructible<_SecondType<_Tp...>, _Up2&>
+        >::value))
+        : __base_(__p)
+    { }
+
+    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<_Up1&, _Up2&>
+        >::value
+    , int> = 0>
+    explicit tuple(pair<_Up1, _Up2>& __p) = delete;
+
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableImplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<_Up1&, _Up2&>>
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>& __p)
+        : __base_(allocator_arg_t(), __a, __p)
+    { }
+
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableImplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<_Up1&, _Up2&>
+        >::value
+    , int> = 0>
+    tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>& __p) = delete;
+
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<_Up1&, _Up2&>>
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>& __p)
+        : __base_(allocator_arg_t(), __a, __p)
+    { }
+
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<_Up1&, _Up2&>
+        >::value
+    , int> = 0>
+    explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>& __p) = delete;
+
+    // tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
+    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableImplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<const _Up1&, const _Up2&>>
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
@@ -850,7 +1272,17 @@
     template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableExplicitCopyFromPair<_Up1, _Up2, _Tp...>
+            _EnableImplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<const _Up1&, const _Up2&>
+        >::value
+    , int> = 0>
+    tuple(const pair<_Up1, _Up2>& __p) = delete;
+
+    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<const _Up1&, const _Up2&>>
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
@@ -862,10 +1294,20 @@
         : __base_(__p)
     { }
 
+    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<const _Up1&, const _Up2&>
+        >::value
+    , int> = 0>
+    explicit tuple(const pair<_Up1, _Up2>& __p) = delete;
+
     template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableImplicitCopyFromPair<_Up1, _Up2, _Tp...>
+            _EnableImplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<const _Up1&, const _Up2&>>
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
@@ -876,7 +1318,17 @@
     template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableExplicitCopyFromPair<_Up1, _Up2, _Tp...>
+            _EnableImplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<const _Up1&, const _Up2&>
+        >::value
+    , int> = 0>
+    tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p) = delete;
+
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<const _Up1&, const _Up2&>>
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
@@ -884,34 +1336,28 @@
         : __base_(allocator_arg_t(), __a, __p)
     { }
 
-    // tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants)
-    template <class _Up1, class _Up2, class ..._DependentTp>
-    struct _EnableImplicitMoveFromPair : _And<
-        is_constructible<_FirstType<_DependentTp...>, _Up1>,
-        is_constructible<_SecondType<_DependentTp...>, _Up2>,
-        is_convertible<_Up1, _FirstType<_DependentTp...> >, // explicit check
-        is_convertible<_Up2, _SecondType<_DependentTp...> >
-    > { };
-
-    template <class _Up1, class _Up2, class ..._DependentTp>
-    struct _EnableExplicitMoveFromPair : _And<
-        is_constructible<_FirstType<_DependentTp...>, _Up1>,
-        is_constructible<_SecondType<_DependentTp...>, _Up2>,
-        _Not<is_convertible<_Up1, _FirstType<_DependentTp...> > >, // explicit check
-        _Not<is_convertible<_Up2, _SecondType<_DependentTp...> > >
-    > { };
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<const _Up1&, const _Up2&>
+        >::value
+    , int> = 0>
+    explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p) = delete;
 
+    // tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants)
     template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableImplicitMoveFromPair<_Up1, _Up2, _Tp...>
+            _EnableImplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<_Up1&&, _Up2&&>>
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     tuple(pair<_Up1, _Up2>&& __p)
         _NOEXCEPT_((_And<
-            is_nothrow_constructible<_FirstType<_Tp...>, _Up1>,
-            is_nothrow_constructible<_SecondType<_Tp...>, _Up2>
+            is_nothrow_constructible<_FirstType<_Tp...>, _Up1&&>,
+            is_nothrow_constructible<_SecondType<_Tp...>, _Up2&&>
         >::value))
         : __base_(_VSTD::move(__p))
     { }
@@ -919,22 +1365,42 @@
     template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableExplicitMoveFromPair<_Up1, _Up2, _Tp...>
+            _EnableImplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<_Up1&&, _Up2&&>
+        >::value
+    , int> = 0>
+    tuple(pair<_Up1, _Up2>&&) = delete;
+
+    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<_Up1&&, _Up2&&>>
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit tuple(pair<_Up1, _Up2>&& __p)
         _NOEXCEPT_((_And<
-            is_nothrow_constructible<_FirstType<_Tp...>, _Up1>,
-            is_nothrow_constructible<_SecondType<_Tp...>, _Up2>
+            is_nothrow_constructible<_FirstType<_Tp...>, _Up1&&>,
+            is_nothrow_constructible<_SecondType<_Tp...>, _Up2&&>
         >::value))
         : __base_(_VSTD::move(__p))
     { }
 
+    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<_Up1&&, _Up2&&>
+        >::value
+    , int> = 0>
+    explicit tuple(pair<_Up1, _Up2>&&) = delete;
+
     template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableImplicitMoveFromPair<_Up1, _Up2, _Tp...>
+            _EnableImplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<_Up1&&, _Up2&&>>
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
@@ -945,7 +1411,17 @@
     template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableExplicitMoveFromPair<_Up1, _Up2, _Tp...>
+            _EnableImplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<_Up1&&, _Up2&&>
+        >::value
+    , int> = 0>
+    tuple(allocator_arg_t, const _Alloc&, pair<_Up1, _Up2>&&) = delete;
+
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<_Up1&&, _Up2&&>>
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
@@ -953,6 +1429,109 @@
         : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
     { }
 
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<_Up1&&, _Up2&&>
+        >::value
+    , int> = 0>
+    explicit tuple(allocator_arg_t, const _Alloc&, pair<_Up1, _Up2>&&) = delete;
+
+    // tuple(const pair<U1, U2>&&) constructors (including allocator_arg_t variants)
+
+        template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableImplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<const _Up1&&, const _Up2&&>>
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    tuple(const pair<_Up1, _Up2>&& __p)
+        _NOEXCEPT_((_And<
+            is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&&>,
+            is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&&>
+        >::value))
+        : __base_(_VSTD::move(__p))
+    { }
+
+    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableImplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<const _Up1&&, const _Up2&&>
+        >::value
+    , int> = 0>
+    tuple(const pair<_Up1, _Up2>&&) = delete;
+
+    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<const _Up1&&, const _Up2&&>>
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    explicit tuple(const pair<_Up1, _Up2>&& __p)
+        _NOEXCEPT_((_And<
+            is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&&>,
+            is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&&>
+        >::value))
+        : __base_(_VSTD::move(__p))
+    { }
+
+    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<const _Up1&&, const _Up2&&>
+        >::value
+    , int> = 0>
+    explicit tuple(const pair<_Up1, _Up2>&&) = delete;
+
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableImplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<const _Up1&&, const _Up2&&>>
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>&& __p)
+        : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
+    { }
+
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableImplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<const _Up1&&, const _Up2&&>
+        >::value
+    , int> = 0>
+    tuple(allocator_arg_t, const _Alloc&, const pair<_Up1, _Up2>&&) = delete;
+
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
+            _Not<_BindsReferenceToTemporary<const _Up1&&, const _Up2&&>>
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>&& __p)
+        : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
+    { }
+
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
+            _BindsReferenceToTemporary<const _Up1&&, const _Up2&&>
+        >::value
+    , int> = 0>
+    explicit tuple(allocator_arg_t, const _Alloc&, const pair<_Up1, _Up2>&&) = delete;
+
     // [tuple.assign]
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple)
diff --git a/libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp b/libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp
--- a/libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp
+++ b/libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp
@@ -44,37 +44,31 @@
 
 int main(int, char**) {
 #if TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary)
-  // Test that we emit our diagnostic from the library.
-  // expected-error@tuple:* 8 {{"Attempted construction of reference element binds to a temporary whose lifetime has ended"}}
-
-  // Good news everybody! Clang now diagnoses this for us!
-  // expected-error@tuple:* 0+ {{reference member '__value_' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
-
   {
-    F<int, const std::string&>(std::make_tuple(1, "abc")); // expected-note 1 {{requested here}}
+    F<int, const std::string&>(std::make_tuple(1, "abc")); // expected-error-re {{conversion function from {{.*}} invokes a deleted function}}
   }
   {
-    std::tuple<int, const std::string&> t(1, "a"); // expected-note 1 {{requested here}}
+    std::tuple<int, const std::string&> t(1, "a"); // expected-error {{call to deleted constructor}}
   }
   {
-    F<int, const std::string&>(std::tuple<int, const std::string&>(1, "abc")); // expected-note 1 {{requested here}}
+    F<int, const std::string&>(std::tuple<int, const std::string&>(1, "abc")); // expected-error {{call to deleted constructor}}
   }
   {
     ConvertsTo<int&> ct;
-    std::tuple<const long&, int> t(ct, 42); // expected-note {{requested here}}
+    std::tuple<const long&, int> t(ct, 42); // expected-error {{call to deleted constructor}}
   }
   {
     ConvertsTo<int> ct;
-    std::tuple<int const&, void*> t(ct, nullptr); // expected-note {{requested here}}
+    std::tuple<int const&, void*> t(ct, nullptr); // expected-error {{call to deleted constructor}}
   }
   {
     ConvertsTo<Derived> ct;
-    std::tuple<Base const&, int> t(ct, 42); // expected-note {{requested here}}
+    std::tuple<Base const&, int> t(ct, 42); // expected-error {{call to deleted constructor}}
   }
   {
     std::allocator<int> alloc;
-    std::tuple<std::string &&> t2("hello"); // expected-note {{requested here}}
-    std::tuple<std::string &&> t3(std::allocator_arg, alloc, "hello"); // expected-note {{requested here}}
+    std::tuple<std::string &&> t2("hello"); // expected-error {{call to deleted constructor}}
+    std::tuple<std::string &&> t3(std::allocator_arg, alloc, "hello"); // expected-error {{call to deleted constructor}}
   }
 #else
 #error force failure
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/binding_to_temporary.compile.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/binding_to_temporary.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/binding_to_temporary.compile.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// Verify that various attempts to bind a reference to temporary fail in a
+// trait-friendly manner
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+
+constexpr bool expecting_deleted = TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary);
+
+using std::tuple;
+using std::pair;
+
+struct ConvertsToInt { operator int() const; };
+
+static_assert(std::is_constructible<tuple<int>, ConvertsToInt>::value, "!");
+#define CHECK(X, tquals)                                                                                               \
+static_assert(std::is_constructible<tuple<int const&>, X>::value == !expecting_deleted, "!");                          \
+static_assert(std::is_constructible<tuple<int const&, int>, X, X>::value == !expecting_deleted, "!");                  \
+static_assert(std::is_constructible<tuple<int const&, int>, X, int>::value == !expecting_deleted, "!");                \
+static_assert(std::is_constructible<tuple<int>, tuple<X> tquals>::value, "!");                                         \
+static_assert(std::is_constructible<tuple<int const&>, tuple<X> tquals>::value == !expecting_deleted, "!");            \
+static_assert(std::is_constructible<tuple<int const&, int>, tuple<X, X> tquals>::value == !expecting_deleted, "!");    \
+static_assert(std::is_constructible<tuple<int const&, int>, tuple<X, int> tquals>::value == !expecting_deleted, "!");  \
+static_assert(std::is_constructible<tuple<int const&, int>, pair<X, X> tquals>::value == !expecting_deleted, "!");     \
+static_assert(std::is_constructible<tuple<int const&, int>, pair<X, int> tquals>::value == !expecting_deleted, "!");
+
+#define CHECK_ALL_TQUALS(X) CHECK(X, &) CHECK(X, const&) CHECK(X, &&) CHECK(X, const&&)
+#define CHECK_ALL(X) CHECK_ALL_TQUALS(X&) CHECK_ALL_TQUALS(X const&) CHECK_ALL_TQUALS(X&&) CHECK_ALL_TQUALS(X const&&)
+CHECK_ALL(ConvertsToInt);
diff --git a/libcxx/test/std/utilities/utility/pairs/pairs.pair/binding_to_temporary.compile.pass.cpp b/libcxx/test/std/utilities/utility/pairs/pairs.pair/binding_to_temporary.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/utility/pairs/pairs.pair/binding_to_temporary.compile.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// Verify that various attempts to bind a reference to temporary fail in a
+// trait-friendly manner
+
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+
+constexpr bool expecting_deleted = TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary);
+
+using std::pair;
+
+struct ConvertsToInt { operator int() const; };
+
+static_assert(std::is_constructible<pair<int, int>, ConvertsToInt, ConvertsToInt>::value, "!");
+#define CHECK(X, tquals)                                                                                             \
+static_assert(std::is_constructible<pair<int const&, int>, X, X>::value == !expecting_deleted, "!");                 \
+static_assert(std::is_constructible<pair<int const&, int>, X, int>::value == !expecting_deleted, "!");               \
+static_assert(std::is_constructible<pair<int const&, int>, pair<X, X> tquals>::value == !expecting_deleted, "!");    \
+static_assert(std::is_constructible<pair<int const&, int>, pair<X, int> tquals>::value == !expecting_deleted, "!");
+
+#define CHECK_ALL_TQUALS(X) CHECK(X, &) CHECK(X, const&) CHECK(X, &&) CHECK(X, const&&)
+#define CHECK_ALL(X) CHECK_ALL_TQUALS(X&) CHECK_ALL_TQUALS(X const&) CHECK_ALL_TQUALS(X&&) CHECK_ALL_TQUALS(X const&&)
+CHECK_ALL(ConvertsToInt);