diff --git a/libcxx/include/tuple b/libcxx/include/tuple
--- a/libcxx/include/tuple
+++ b/libcxx/include/tuple
@@ -883,13 +883,13 @@
     template <class... _Up, enable_if_t<
         _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
     _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!(is_convertible_v<_Up&, _Tp> && ...))
+        explicit(!_Lazy<_And, is_convertible<_Up&, _Tp>...>::value)
     tuple(tuple<_Up...>& __t) : __base_(__t) {}
 
     template <class _Alloc, class... _Up, enable_if_t<
         _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
     _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!(is_convertible_v<_Up&, _Tp> && ...))
+        explicit(!_Lazy<_And, is_convertible<_Up&, _Tp>...>::value)
     tuple(allocator_arg_t, const _Alloc& __alloc, tuple<_Up...>& __t) : __base_(allocator_arg_t(), __alloc, __t) {}
 #endif // _LIBCPP_STD_VER >= 23
 
@@ -947,13 +947,13 @@
     template <class... _Up, enable_if_t<
         _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
     _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
+        explicit(!_Lazy<_And, is_convertible<const _Up&&, _Tp>...>::value)
     tuple(const tuple<_Up...>&& __t) : __base_(std::move(__t)) {}
 
     template <class _Alloc, class... _Up, enable_if_t<
         _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
     _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
+        explicit(!_Lazy<_And, is_convertible<const _Up&&, _Tp>...>::value)
     tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t)
         : __base_(allocator_arg_t(), __alloc, std::move(__t)) {}
 #endif // _LIBCPP_STD_VER >= 23
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/recursion_depth.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/recursion_depth.pass.cpp
--- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/recursion_depth.pass.cpp
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/recursion_depth.pass.cpp
@@ -9,21 +9,41 @@
 // UNSUPPORTED: c++03, c++11
 
 // Make sure that we don't blow up the template instantiation recursion depth
-// for tuples of size <= 1024.
+// for tuples of size <= 512.
 
 #include <tuple>
 #include <cassert>
 #include <utility>
 
+#include "test_macros.h"
+
 template <std::size_t... I>
 constexpr void CreateTuple(std::index_sequence<I...>) {
-  std::tuple<decltype(I)...> tuple(I...);
-  assert(std::get<0>(tuple) == 0);
-  assert(std::get<sizeof...(I)-1>(tuple) == sizeof...(I)-1);
+  using LargeTuple = std::tuple<std::integral_constant<std::size_t, I>...>;
+  using TargetTuple = std::tuple<decltype(I)...>;
+  LargeTuple tuple(std::integral_constant<std::size_t, I>{}...);
+  assert(std::get<0>(tuple).value == 0);
+  assert(std::get<sizeof...(I)-1>(tuple).value == sizeof...(I)-1);
+
+  TargetTuple t1 = tuple;                                  // converting copy constructor from &
+  TargetTuple t2 = static_cast<LargeTuple const&>(tuple);  // converting copy constructor from const&
+  TargetTuple t3 = std::move(tuple);                       // converting rvalue constructor
+  TargetTuple t4 = static_cast<LargeTuple const&&>(tuple); // converting const rvalue constructor
+  TargetTuple t5;                                          // default constructor
+  (void)t1; (void)t2; (void)t3; (void)t4; (void)t5;
+
+#if TEST_STD_VER >= 20
+  t1 = tuple;                                              // converting assignment from &
+  t1 = static_cast<LargeTuple const&>(tuple);              // converting assignment from const&
+  t1 = std::move(tuple);                                   // converting assignment from &&
+  t1 = static_cast<LargeTuple const&&>(tuple);             // converting assignment from const&&
+  swap(t1, t2);                                            // swap
+#endif
+  // t1 == tuple;                                          // comparison does not work yet (we blow the constexpr stack)
 }
 
 constexpr bool test() {
-  CreateTuple(std::make_index_sequence<1024>{});
+  CreateTuple(std::make_index_sequence<512>{});
   return true;
 }