Fix tuple<A> to A conversion in SFINAE for tuple(_Up...) constructor

[eugenis]

Summary

Partial fix for PR23256

https://llvm.org/bugs/show_bug.cgi?id=23256

[eugenis]

friendly ping

[EricWF]

Tuple is tricky. If there is a bug in tuple you can bet that SFINAE is both the problem and the solution. constexpr constructors are becoming a frequent problem in the tuple SFINAE because they tend to cause hard compile errors. The SFINAE you added could easily introduce an almost identical bug in a different scenario.

Another reason I'm so hesitant to move forward with this patch is because they essentially contradicts D8178.

The first step to solving both of these bugs is to drastically increase the test coverage of tuple. The tests need to cover a much wider range of types than they currently do. Until then I think both these patches will need to wait in limbo.

[EricWF]

Another possible fix up for review as D12502.

[EricWF]

Resigning as reviewer because this patch is no longer relevant.

I fixed the issues today in r266461.

include/tuple

template <class ..._Up,
             ))
             : base_(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 ..._Up,
-              typename enable_if
-                      <
-                         sizeof...(_Up) <= sizeof...(_Tp) &&
-                         __tuple_constructible
-                         <
-                            tuple<_Up...>,
-                            typename __make_tuple_types<tuple,
-                                     sizeof...(_Up) < sizeof...(_Tp) ?
-                                        sizeof...(_Up) :
-                                        sizeof...(_Tp)>::type
-                         >::value &&
-                         !__tuple_convertible
-                         <
-                            tuple<_Up...>,
-                            typename __make_tuple_types<tuple,
-                                     sizeof...(_Up) < sizeof...(_Tp) ?
-                                        sizeof...(_Up) :
-                                        sizeof...(_Tp)>::type
-                         >::value &&
-                         __all_default_constructible<
-                            typename __make_tuple_types<tuple, sizeof...(_Tp),
-                                sizeof...(_Up) < sizeof...(_Tp) ?
-                                    sizeof...(_Up) :
-                                    sizeof...(_Tp)>::type
-                         >::value,
-                         bool
-                      >::type =false
-             >
+              typename enable_if<
+                 __lazy_and<
+                    __lazy_not<
+                       __lazy_and<
+                          integral_constant<bool, sizeof...(_Up)==1>,
+                          is_convertible<_Up..., tuple>
+                       >
+                    >,
+                    integral_constant<bool, sizeof...(_Up) <= sizeof...(_Tp)>,
+                    __tuple_constructible<
+                    >,
+                    __lazy_not<
+                       __tuple_convertible<
+                       >
+                    >,
+                    >
+              >::type =false >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit
         tuple(_Up&&... __u)
             _NOEXCEPT_((
                 is_nothrow_constructible<base,
                     typename __make_tuple_indices<sizeof...(_Up)>::type,
                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,

test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy_UTypes.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class... UTypes>
+//   explicit tuple(UTypes&&... u);
+
+// PR23256: SFINAE on tuple(UTypes&&... u) erroneously calls UTypes(tuple<UTypes>) ctor.
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+
+struct A {
+  int value_;
+
+  template <typename T>
+  explicit constexpr A(T value)
+      : value_(static_cast<int>(value)) {}
+};
+
+static_assert(std::is_trivially_copy_constructible<std::tuple<A>>::value, "zz");
+
+int main() {}