[libcxx] Fix PR29123 - std::tuple compilation errors with implicit constructors

[EricWF]

Summary

I have no idea *why* this patch fixes the compilation error but it does.

[mclow.lists]

I have no idea *why* this patch fixes the compilation error but it does.

This fills me with unease.

[rsmith]

See https://reviews.llvm.org/D23999 for my thoughts on this.

include/__tuple

 template <class _Tuple, size_t _ExpectedSize,
           class _RawTuple = typename __uncvref<_Tuple>::type>
 using __tuple_like_with_size = __tuple_like_with_size_imp<
                                    __tuple_like<_RawTuple>::value,
                                    tuple_size<_RawTuple>, _ExpectedSize
                               >;
 
 struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
-    template <class ...>
-    static constexpr bool __enable_default() { return false; }
-    template <class ...>
-    static constexpr bool __enable_explicit() { return false; }
-    template <class ...>
-    static constexpr bool __enable_implicit() { return false; }
-    template <class ...>
-    static constexpr bool __enable_assign() { return false; }
+    template <class ...> using __enable_default = false_type;
+    template <class ...> using __enable_explicit = false_type;
+    template <class ...> using __enable_implicit = false_type;
+    template <class ...> using __enable_assign = false_type;
 };
 #endif
 
 #if _LIBCPP_STD_VER > 14
 
 template <bool _CanCopy, bool _CanMove>
 struct __sfinae_ctor_base {};
 template <>

include/tuple

class _LIBCPP_TYPE_VIS_ONLY tuple
 
     template <bool _MaybeEnable, class _Dummy = void>
     struct _CheckArgsConstructor : __check_tuple_constructor_fail {};
 
     template <class _Dummy>
     struct _CheckArgsConstructor<true, _Dummy>
     {
         template <class ..._Args>
-        static constexpr bool __enable_default() {
-            return __all<is_default_constructible<_Args>::value...>::value;
-        }
+        using __enable_default = __all<is_default_constructible<_Args>::value...>;
 
         template <class ..._Args>
-        static constexpr bool __enable_explicit() {
-            return
+        using __enable_explicit = integral_constant<bool,
                 __tuple_constructible<
                     tuple<_Args...>,
                     typename __make_tuple_types<tuple,
                              sizeof...(_Args) < sizeof...(_Tp) ?
                                  sizeof...(_Args) :
                                  sizeof...(_Tp)>::type
                 >::value &&
                 !__tuple_convertible<
                     tuple<_Args...>,
                     typename __make_tuple_types<tuple,
                              sizeof...(_Args) < sizeof...(_Tp) ?
                                  sizeof...(_Args) :
                                  sizeof...(_Tp)>::type
                 >::value &&
                 __all_default_constructible<
                     typename __make_tuple_types<tuple, sizeof...(_Tp),
                              sizeof...(_Args) < sizeof...(_Tp) ?
                                  sizeof...(_Args) :
                                  sizeof...(_Tp)>::type
-                >::value;
-        }
+                >::value
+        >;
 
         template <class ..._Args>
-        static constexpr bool __enable_implicit() {
-            return
+        using __enable_implicit = integral_constant<bool,
                 __tuple_convertible<
                     tuple<_Args...>,
                     typename __make_tuple_types<tuple,
                              sizeof...(_Args) < sizeof...(_Tp) ?
                                  sizeof...(_Args) :
                                  sizeof...(_Tp)>::type
                 >::value &&
                 __all_default_constructible<
                     typename __make_tuple_types<tuple, sizeof...(_Tp),
                              sizeof...(_Args) < sizeof...(_Tp) ?
                                  sizeof...(_Args) :
                                  sizeof...(_Tp)>::type
-                >::value;
-        }
+                >::value
+        >;
     };
 
     template <bool _MaybeEnable,
               bool = sizeof...(_Tp) == 1,
               class _Dummy = void>
     struct _CheckTupleLikeConstructor : __check_tuple_constructor_fail {};
 
     template <class _Dummy>
     struct _CheckTupleLikeConstructor<true, false, _Dummy>
     {
         template <class _Tuple>
-        static constexpr bool __enable_implicit() {
-            return __tuple_convertible<_Tuple, tuple>::value;
-        }
+        using __enable_implicit = __tuple_convertible<_Tuple, tuple>;
 
         template <class _Tuple>
-        static constexpr bool __enable_explicit() {
-            return __tuple_constructible<_Tuple, tuple>::value
-               && !__tuple_convertible<_Tuple, tuple>::value;
-        }
+        using __enable_explicit = integral_constant<bool,
+                  __tuple_constructible<_Tuple, tuple>::value
+               && !__tuple_convertible<_Tuple, tuple>::value>;
     };
 
     template <class _Dummy>
     struct _CheckTupleLikeConstructor<true, true, _Dummy>
     {
         // This trait is used to disable the tuple-like constructor when
         // the UTypes... constructor should be selected instead.
         // See LWG issue #2549.
         template <class _Tuple>
         using _PreferTupleLikeConstructor = __lazy_or<
             // Don't attempt the two checks below if the tuple we are given
             // has the same type as this tuple.
             is_same<typename __uncvref<_Tuple>::type, tuple>,
             __lazy_and<
                 __lazy_not<is_constructible<_Tp..., _Tuple>>,
                 __lazy_not<is_convertible<_Tuple, _Tp...>>
             >
         >;
 
         template <class _Tuple>
-        static constexpr bool __enable_implicit() {
-            return __lazy_and<
+        using __enable_implicit =
+            __lazy_and<
                 __tuple_convertible<_Tuple, tuple>,
                 _PreferTupleLikeConstructor<_Tuple>
-            >::value;
-        }
+            >;
 
         template <class _Tuple>
-        static constexpr bool __enable_explicit() {
-            return __lazy_and<
+        using __enable_explicit = __lazy_and<
                 __tuple_constructible<_Tuple, tuple>,
                 _PreferTupleLikeConstructor<_Tuple>,
                 __lazy_not<__tuple_convertible<_Tuple, tuple>>
-            >::value;
-        }
+            >;
     };
 
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         const typename tuple_element<_Jp, tuple<_Up...> >::type&& get(const tuple<_Up...>&&) _NOEXCEPT;
 public:
 
     template <bool _Dummy = true, class = typename enable_if<
-        _CheckArgsConstructor<_Dummy>::template __enable_default<_Tp...>()
+        _CheckArgsConstructor<_Dummy>::template __enable_default<_Tp...>::value
     >::type>
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR tuple()
         _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
 
     tuple(tuple const&) = default;
     tuple(tuple&&) = default;
 
tuple(_AllocArgT, _Alloc const& __a)
                     typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
                     __tuple_types<_Tp...>()) {}
 
     template <bool _Dummy = true,
               typename enable_if
                       <
                          _CheckArgsConstructor<
                             _Dummy
-                         >::template __enable_implicit<_Tp...>(),
+                         >::template __enable_implicit<_Tp...>::value,
                          bool
                       >::type = false
         >
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
         : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
                 typename __make_tuple_types<tuple, 0>::type(),
                 __t...
                ) {}
 
     template <bool _Dummy = true,
               typename enable_if
                       <
                          _CheckArgsConstructor<
                             _Dummy
-                         >::template __enable_explicit<_Tp...>(),
+                         >::template __enable_explicit<_Tp...>::value,
                          bool
                       >::type = false
         >
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
         : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
                 typename __make_tuple_types<tuple, 0>::type(),
                 __t...
                ) {}
 
     template <class _Alloc, bool _Dummy = true,
               typename enable_if
                       <
                          _CheckArgsConstructor<
                             _Dummy
-                         >::template __enable_implicit<_Tp...>(),
+                         >::template __enable_implicit<_Tp...>::value,
                          bool
                       >::type = false
         >
       _LIBCPP_INLINE_VISIBILITY
       tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
         : base_(allocator_arg_t(), __a,
                 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
                 typename __make_tuple_types<tuple, 0>::type(),
                 __t...
                ) {}
 
     template <class _Alloc, bool _Dummy = true,
               typename enable_if
                       <
                          _CheckArgsConstructor<
                             _Dummy
-                         >::template __enable_explicit<_Tp...>(),
+                         >::template __enable_explicit<_Tp...>::value,
                          bool
                       >::type = false
         >
       _LIBCPP_INLINE_VISIBILITY
       explicit
       tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
         : base_(allocator_arg_t(), __a,
                 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
                 typename __make_tuple_types<tuple, 0>::type(),
                 __t...
                ) {}
 
     template <class ..._Up,
               typename enable_if
                       <
                          _CheckArgsConstructor<
                              sizeof...(_Up) <= sizeof...(_Tp)
                              && !_PackExpandsToThisTuple<_Up...>::value
-                         >::template __enable_implicit<_Up...>(),
+                         >::template __enable_implicit<_Up...>::value,
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         tuple(_Up&&... __u)
             _NOEXCEPT_((
                 is_nothrow_constructible<base,
                     typename __make_tuple_indices<sizeof...(_Up)>::type,
template <class ..._Up,
                     _VSTD::forward<_Up>(__u)...) {}
 
     template <class ..._Up,
               typename enable_if
                       <
                          _CheckArgsConstructor<
                              sizeof...(_Up) <= sizeof...(_Tp)
                              && !_PackExpandsToThisTuple<_Up...>::value
-                         >::template __enable_explicit<_Up...>(),
+                         >::template __enable_explicit<_Up...>::value,
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit
         tuple(_Up&&... __u)
             _NOEXCEPT_((
                 is_nothrow_constructible<base,
template <class ..._Up,
                     _VSTD::forward<_Up>(__u)...) {}
 
     template <class _Alloc, class ..._Up,
               typename enable_if
                       <
                          _CheckArgsConstructor<
                              sizeof...(_Up) == sizeof...(_Tp) &&
                              !_PackExpandsToThisTuple<_Up...>::value
-                         >::template __enable_implicit<_Up...>(),
+                         >::template __enable_implicit<_Up...>::value,
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY
         tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
             : base_(allocator_arg_t(), __a,
                     typename __make_tuple_indices<sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
                     _VSTD::forward<_Up>(__u)...) {}
 
     template <class _Alloc, class ..._Up,
               typename enable_if
                       <
                          _CheckArgsConstructor<
                              sizeof...(_Up) == sizeof...(_Tp) &&
                              !_PackExpandsToThisTuple<_Up...>::value
-                         >::template __enable_explicit<_Up...>(),
+                         >::template __enable_explicit<_Up...>::value,
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY
         explicit
         tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
             : base_(allocator_arg_t(), __a,
                     typename __make_tuple_indices<sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
                     _VSTD::forward<_Up>(__u)...) {}
 
     template <class _Tuple,
               typename enable_if
                       <
                          _CheckTupleLikeConstructor<
                              __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
                              && !_PackExpandsToThisTuple<_Tuple>::value
-                         >::template __enable_implicit<_Tuple>(),
+                         >::template __enable_implicit<_Tuple>::value,
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
             : base_(_VSTD::forward<_Tuple>(__t)) {}
 
     template <class _Tuple,
               typename enable_if
                       <
                          _CheckTupleLikeConstructor<
                              __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
                              && !_PackExpandsToThisTuple<_Tuple>::value
-                         >::template __enable_explicit<_Tuple>(),
+                         >::template __enable_explicit<_Tuple>::value,
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit
         tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
             : base_(_VSTD::forward<_Tuple>(__t)) {}
 
     template <class _Alloc, class _Tuple,
               typename enable_if
                       <
                          _CheckTupleLikeConstructor<
                              __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
-                         >::template __enable_implicit<_Tuple>(),
+                         >::template __enable_implicit<_Tuple>::value,
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY
         tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
 
     template <class _Alloc, class _Tuple,
               typename enable_if
                       <
                          _CheckTupleLikeConstructor<
                              __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
-                         >::template __enable_explicit<_Tuple>(),
+                         >::template __enable_explicit<_Tuple>::value,
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY
         explicit
         tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
 

include/utility

pair& operator=(pair const& __p) {
         return *this;
     }
 #else
     template <bool _Val>
     using _EnableB = typename enable_if<_Val, bool>::type;
 
     struct _CheckArgs {
       template <class _U1, class _U2>
-      static constexpr bool __enable_default() {
-          return is_default_constructible<_U1>::value
-              && is_default_constructible<_U2>::value;
-      }
+      using __enable_default = integral_constant<bool,
+          is_default_constructible<_U1>::value
+       && is_default_constructible<_U2>::value>;
 
       template <class _U1, class _U2>
-      static constexpr bool __enable_explicit() {
-          return is_constructible<first_type, _U1>::value
+      using __enable_explicit = integral_constant<bool,
+                 is_constructible<first_type, _U1>::value
               && is_constructible<second_type, _U2>::value
               && (!is_convertible<_U1, first_type>::value
-                  || !is_convertible<_U2, second_type>::value);
-      }
+                  || !is_convertible<_U2, second_type>::value)>;
 
       template <class _U1, class _U2>
-      static constexpr bool __enable_implicit() {
-          return is_constructible<first_type, _U1>::value
+      using __enable_implicit = integral_constant<bool,
+                 is_constructible<first_type, _U1>::value
               && is_constructible<second_type, _U2>::value
               && is_convertible<_U1, first_type>::value
-              && is_convertible<_U2, second_type>::value;
-      }
+              && is_convertible<_U2, second_type>::value>;
     };
 
     template <bool _MaybeEnable>
     using _CheckArgsDep = typename conditional<
       _MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;
 
     struct _CheckTupleLikeConstructor {
         template <class _Tuple>
-        static constexpr bool __enable_implicit() {
-            return __tuple_convertible<_Tuple, pair>::value;
-        }
+        using __enable_implicit =  __tuple_convertible<_Tuple, pair>;
 
         template <class _Tuple>
-        static constexpr bool __enable_explicit() {
-            return __tuple_constructible<_Tuple, pair>::value
-               && !__tuple_convertible<_Tuple, pair>::value;
-        }
+        using __enable_explicit = integral_constant<bool,
+                   __tuple_constructible<_Tuple, pair>::value
+               && !__tuple_convertible<_Tuple, pair>::value>;
 
         template <class _Tuple>
-        static constexpr bool __enable_assign() {
-            return __tuple_assignable<_Tuple, pair>::value;
-        }
+        using __enable_assign =  __tuple_assignable<_Tuple, pair>;
     };
 
     template <class _Tuple>
     using _CheckTLC = typename conditional<
         __tuple_like_with_size<_Tuple, 2>::value
             && !is_same<typename decay<_Tuple>::type, pair>::value,
         _CheckTupleLikeConstructor,
         __check_tuple_constructor_fail
     >::type;
 
     template<bool _Dummy = true, _EnableB<
-            _CheckArgsDep<_Dummy>::template __enable_default<_T1, _T2>()
+            _CheckArgsDep<_Dummy>::template __enable_default<_T1, _T2>::value
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     pair() : first(), second() {}
 
     template <bool _Dummy = true, _EnableB<
-             _CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>()
+             _CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>::value
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit pair(_T1 const& __t1, _T2 const& __t2)
         : first(__t1), second(__t2) {}
 
     template<bool _Dummy = true, _EnableB<
-            _CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>()
+            _CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>::value
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     pair(_T1 const& __t1, _T2 const& __t2)
         : first(__t1), second(__t2) {}
 
     template<class _U1, class _U2, _EnableB<
-             _CheckArgs::template __enable_explicit<_U1, _U2>()
+             _CheckArgs::template __enable_explicit<_U1, _U2>::value
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit pair(_U1&& __u1, _U2&& __u2)
         : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
 
     template<class _U1, class _U2, _EnableB<
-            _CheckArgs::template __enable_implicit<_U1, _U2>()
+            _CheckArgs::template __enable_implicit<_U1, _U2>::value
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     pair(_U1&& __u1, _U2&& __u2)
         : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
 
     template<class _U1, class _U2, _EnableB<
-            _CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>()
+            _CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>::value
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit pair(pair<_U1, _U2> const& __p)
         : first(__p.first), second(__p.second) {}
 
     template<class _U1, class _U2, _EnableB<
-            _CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>()
+            _CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>::value
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     pair(pair<_U1, _U2> const& __p)
         : first(__p.first), second(__p.second) {}
 
     template<class _U1, class _U2, _EnableB<
-            _CheckArgs::template __enable_explicit<_U1, _U2>()
+            _CheckArgs::template __enable_explicit<_U1, _U2>::value
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit pair(pair<_U1, _U2>&&__p)
         : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
 
     template<class _U1, class _U2, _EnableB<
-            _CheckArgs::template __enable_implicit<_U1, _U2>()
+            _CheckArgs::template __enable_implicit<_U1, _U2>::value
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     pair(pair<_U1, _U2>&& __p)
         : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
 
     template<class _Tuple, _EnableB<
-            _CheckTLC<_Tuple>::template __enable_explicit<_Tuple>()
+            _CheckTLC<_Tuple>::template __enable_explicit<_Tuple>::value
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit pair(_Tuple&& __p)
         : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
           second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
 
     template<class _Tuple, _EnableB<
-            _CheckTLC<_Tuple>::template __enable_implicit<_Tuple>()
+            _CheckTLC<_Tuple>::template __enable_implicit<_Tuple>::value
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     pair(_Tuple&& __p)
         : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
           second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
 
     template <class... _Args1, class... _Args2>
     _LIBCPP_INLINE_VISIBILITY
pair& operator=(typename conditional<
                    is_nothrow_move_assignable<second_type>::value)
     {
         first = _VSTD::forward<first_type>(__p.first);
         second = _VSTD::forward<second_type>(__p.second);
         return *this;
     }
 
     template <class _Tuple, _EnableB<
-            _CheckTLC<_Tuple>::template __enable_assign()
+            _CheckTLC<_Tuple>::template __enable_assign<_Tuple>::value
      > = false>
     _LIBCPP_INLINE_VISIBILITY
     pair& operator=(_Tuple&& __p) {
         first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p));
         second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p));
         return *this;
     }
 #endif

test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR29123_implicit_ctor_accepted.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class ...Up>
+//   tuple(Up&&...);
+
+// See PR29123.
+
+
+#include <tuple>
+#include <memory>
+#include <cassert>
+// repro.cpp
+// this is minimized code from folly library
+#include<tuple>
+template<class Value>
+struct Optional {
+  // implicit
+  Optional() {}
+  Optional(const Value& newValue) {}
+};
+
+struct dynamic {
+  // implicit
+  template<class T> dynamic(T t);
+};
+
+using Tup = std::tuple<dynamic>;
+using Opt = Optional<Tup>;
+
+Opt get() { return {}; }
+
+int main() {
+    Optional<Tup> x = get();
+}