Remove std::tuple's reduced-arity-extension on implicit constructors.

[EricWF]

Summary

The reduced-arity-extension on tuple's implicit constructors breaks conforming code. eg

#include <tuple>
#include <string>
using namespace std;
int count(tuple<string, string>) { return 2; }
int count(tuple<string, string, string>) { return 3; }

int main() {
  int c = count({"abc", "def"}); // expected-error {{call to 'count' is ambiguous}}
}

To fix this the I removed the reduced-arity-extension only on the implicit constructors. This breaks the following code:

std::tuple<int, int, int> foo() { return {1, 2}  }

But it still allows for

using Tup = std::tuple<int, int, int>;
Tup foo() { return Tup{1, 2}; }

@Marshall should we provide a way to turn this ctor back on in case in breaks a bunch of real-world code? Maybe deprecate it for a release?

See also:

• http://llvm.org/PR27374
• http://wg21.link/lwg2419

[EricWF]

Add missing test case.

[EricWF]

Another version of this has already been committed.

include/tuple

               typename enable_if
                       <
                          _CheckArgsConstructor<
-                             sizeof...(_Up) <= sizeof...(_Tp)
+                             sizeof...(_Up) == sizeof...(_Tp)
                              && !_PackExpandsToThisTuple<_Up...>::value
                          >::template __enable_implicit<_Up...>(),
                          bool

                          _CheckArgsConstructor<
                              sizeof...(_Up) <= sizeof...(_Tp)
                              && !_PackExpandsToThisTuple<_Up...>::value
-                         >::template __enable_explicit<_Up...>(),
+                         >::template __enable_explicit<_Up...>() ||
+                         _CheckArgsConstructor<
+                             sizeof...(_Up) < sizeof...(_Tp)
+                             && !_PackExpandsToThisTuple<_Up...>::value
+                         >::template __enable_implicit<_Up...>(),
                          bool
                       >::type = false
              >

test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27374_implicit_reduced_arity_extension_non_conforming.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;
+
+// Check that the reduced arity constructors are never implicit.
+// See also:
+//  http://llvm.org/PR27374
+//  http://wg21.link/lwg2419
+
+#include <tuple>
+#include <string>
+#include <cassert>
+
+bool eat_tuple(const std::tuple<char, char>& w) { return false; }
+template <class ...Args>
+auto eat_char(Args&&... args) -> decltype(eat_tuple(args...)) { return eat_tuple(args...); }
+bool eat_char(const char&) { return true; }
+
+int count(std::tuple<std::string, std::string>) {
+    return 2;
+}
+
+int count(std::tuple<std::string, std::string, std::string>) {
+   return 3;
+}
+
+using Tup = std::tuple<int, int, int>;
+Tup explicit_still_allowed() { return Tup{1, 2}; }
+
+int main() {
+    {
+        const char ch = 'a';
+        assert(eat_char(ch));
+    }
+    {
+        assert(count({ "hungry", "zombies" }) == 2);
+        assert(count({ "cute", "fluffy", "kittens" }) == 3);
+    }
+    {
+        explicit_still_allowed();
+    }
+}