Fix compile error for Visual Studio 2015 / cl compiler.

[halyavin]

Summary

Fix compile error for Visual Studio 2015 / cl compiler.
Visual Studio doesn't work well with constexpr function calls inside template arguments.

Add test for _PackExpandsToThisTuple check present in reduced arity constructors to improve their test coverage.

[EricWF]

Test please.

[halyavin]

Ah, I see - there is no mistake here. It is Visual Studio 2015 cl compiler that doesn't have full support for constexpr function calls inside template arguments. I have substantially changed tuple header to avoid such calls and your revision just introduced another one.

Anyway, we should still apply this change for symmetry reasons, at least. What do you think?

[EricWF]

The change is correct. It just needs a test.

[halyavin]

Since there is no mistake here, I can't make the test to fail before the change. Or do you just need a test that invokes this code path? It looks like test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp already does the job. If I replace !_PackExpandsToThisTuple<_Up...>() with false, it fails.

BTW, do I understand correctly, that this condition can't be true anyway since sizeof...(_Up) < sizeof...(_Tp)? I am now thinking about removing it altogether.

[halyavin]

*this condition -> _PackExpandsToThisTuple<_Up...>

[EricWF]

You're right. Sorry for being stupid.

[EricWF]

BTW, do I understand correctly, that this condition can't be true anyway since sizeof...(_Up) < sizeof...(_Tp)? I am now thinking about removing it altogether.

What about for a tuple of 1 element?

Nevermind again.

[halyavin]

Add test for _PackExpandsToThisTuple in reduce arity constructor.

[halyavin]

Ah, I misunderstood what _PackExpandsToThisTuple does. I added test that excises the case where it is needed.

[halyavin]

If you are satisfied with the test too, could you please commit this change for me?

[EricWF]

The test looks great but I was mistaken about it being needed. We should already have the required tests. I incorrectly assumed that the bug caused that constructor to always drop out of overload resolution, so I thought it was untested. However this is not the case.

I'll commit the change to <tuple> but leave the test out. Sorry for the confusion and thanks for the patch.

[EricWF]

Committed in r294106.

include/tuple

template <class ..._Up,
                       <
                          _CheckArgsConstructor<
                              sizeof...(_Up) <= sizeof...(_Tp)
                              && !_PackExpandsToThisTuple<_Up...>::value
                          >::template __enable_explicit<_Up...>() ||
                          _CheckArgsConstructor<
                             !_EnableImplicitReducedArityExtension
                             && sizeof...(_Up) < sizeof...(_Tp)
-                            && !_PackExpandsToThisTuple<_Up...>()
+                            && !_PackExpandsToThisTuple<_Up...>::value
                          >::template __enable_implicit<_Up...>(),
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit
         tuple(_Up&&... __u)
             _NOEXCEPT_((

test/std/utilities/tuple/tuple.tuple/tuple.cnstr/reduce_arity_confusion.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;
+
+// tuple(tuple const&);
+// tuple(tuple&&);
+// template <class... UTypes>
+//   tuple(UTypes&&... u);
+// Check that there is no confusion between reduced arity constructors and
+// copy/move constructors.
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+#include <cassert>
+
+struct Empty {};
+
+struct TupleConvertible {
+    TupleConvertible() : value(0) {}
+    TupleConvertible(const std::tuple<TupleConvertible, Empty>&) : value(1) {}
+    TupleConvertible(std::tuple<TupleConvertible, Empty>&&) : value(1) {}
+    TupleConvertible(const TupleConvertible&) : value(2) {}
+    TupleConvertible(TupleConvertible&&) : value(3) {}
+    int value;
+};
+
+int main() {
+    using Tuple = std::tuple<TupleConvertible, Empty>;
+    Tuple x{TupleConvertible(), Empty()};
+    // Test that move constructor is preferred to reduced arity constructor
+    Tuple y(std::move(x));
+    assert(std::get<0>(y).value == 3);
+    // Test that copy constructor is preferred to reduced arity constructor
+    Tuple z1((const Tuple&)y);
+    assert(std::get<0>(z1).value == 2);
+    Tuple z2((Tuple&)y);
+    assert(std::get<0>(z2).value == 2);
+    Tuple z3((const Tuple)y);
+    assert(std::get<0>(z3).value == 2);
+    Tuple z4(y);
+    assert(std::get<0>(z4).value == 2);
+}