[libc++] Implement CTAD for std::tuple

[ldionne]

Summary

Apparently all the tests were already there, but the actual deduction
guides weren't in place. The implicitly CTAD does the job given the
current set of constructors, however changing the constructors can
break that.

This commit adds the actual guides specified in the Standard to make
libc++ (1) closer to the Standard and (2) more resistent to changes
in std::tuple's constructors.

[ldionne]

Ping.

[• Quuxplusone]

Looks plausible to me, but:

IMHO, please rename std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp to std/utilities/tuple/tuple.tuple/tuple.cnstr/deduct.pass.cpp for consistency with the other CTAD tests.

The existing tests are completely missing any test cases for construction from pair, e.g. std::tuple t = std::make_pair(std::ref(i), 2); and std::tuple t = std::pair(std::ref(i), 2);; please add some tests involving pair.

The existing tests are missing any deduct.fail.cpp. I guess actually we don't expect std::tuple t(random, args...) to ever fail to compile; but maybe you can imagine a corner case that I haven't.

[ldionne]

Address Arthur's comments

[ldionne]

In D65225#1615460, @Quuxplusone wrote:

The existing tests are missing any deduct.fail.cpp. I guess actually we don't expect std::tuple t(random, args...) to ever fail to compile; but maybe you can imagine a corner case that I haven't.

I can't think of anything either.

[• Quuxplusone]

LGTM.

libcxx/trunk/include/tuple

public:
     template <class U1, class U2>
         tuple& operator=(const pair<U1, U2>&); // iff sizeof...(T) == 2
     template <class U1, class U2>
         tuple& operator=(pair<U1, U2>&&); // iff sizeof...(T) == 2
 
     void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));
 };
 
+template <class ...T>
+tuple(T...) -> tuple<T...>;                                         // since C++17
+template <class T1, class T2>
+tuple(pair<T1, T2>) -> tuple<T1, T2>;                               // since C++17
+template <class Alloc, class ...T>
+tuple(allocator_arg_t, Alloc, T...) -> tuple<T...>;                 // since C++17
+template <class Alloc, class T1, class T2>
+tuple(allocator_arg_t, Alloc, pair<T1, T2>) -> tuple<T1, T2>;       // since C++17
+template <class Alloc, class ...T>
+tuple(allocator_arg_t, Alloc, tuple<T...>) -> tuple<T...>;          // since C++17
+
 inline constexpr unspecified ignore;
 
 template <class... T> tuple<V...>  make_tuple(T&&...); // constexpr in C++14
 template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept; // constexpr in C++14
 template <class... T> tuple<T&...> tie(T&...) noexcept; // constexpr in C++14
 template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // constexpr in C++14
 
 // [tuple.apply], calling a function with a tuple of arguments:
public:
     template <class _Alloc, class _Up>
     _LIBCPP_INLINE_VISIBILITY
         tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
     _LIBCPP_INLINE_VISIBILITY
     void swap(tuple&) _NOEXCEPT {}
 };
 
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
-// NOTE: These are not yet standardized, but are required to simulate the
-// implicit deduction guide that should be generated had libc++ declared the
-// tuple-like constructors "correctly"
-template <class _Alloc, class ..._Args>
-tuple(allocator_arg_t, const _Alloc&, tuple<_Args...> const&) -> tuple<_Args...>;
-template <class _Alloc, class ..._Args>
-tuple(allocator_arg_t, const _Alloc&, tuple<_Args...>&&) -> tuple<_Args...>;
+template <class ..._Tp>
+tuple(_Tp...) -> tuple<_Tp...>;
+template <class _Tp1, class _Tp2>
+tuple(pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
+template <class _Alloc, class ..._Tp>
+tuple(allocator_arg_t, _Alloc, _Tp...) -> tuple<_Tp...>;
+template <class _Alloc, class _Tp1, class _Tp2>
+tuple(allocator_arg_t, _Alloc, pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
+template <class _Alloc, class ..._Tp>
+tuple(allocator_arg_t, _Alloc, tuple<_Tp...>) -> tuple<_Tp...>;
 #endif
 
 template <class ..._Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     __all<__is_swappable<_Tp>::value...>::value,
     void

libcxx/trunk/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/deduct.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+// GCC's implementation of class template deduction is still immature and runs
+// into issues with libc++. However GCC accepts this code when compiling
+// against libstdc++.
+// XFAIL: gcc
+
+// <tuple>
+
+// Test that the constructors offered by std::tuple are formulated
+// so they're compatible with implicit deduction guides, or if that's not
+// possible that they provide explicit guides to make it work.
+
+#include <tuple>
+#include <memory>
+#include <cassert>
+
+#include "test_macros.h"
+#include "archetypes.hpp"
+
+
+// Overloads
+//  using A = Allocator
+//  using AT = std::allocator_arg_t
+// ---------------
+// (1)  tuple(const Types&...) -> tuple<Types...>
+// (2)  tuple(pair<T1, T2>) -> tuple<T1, T2>;
+// (3)  explicit tuple(const Types&...) -> tuple<Types...>
+// (4)  tuple(AT, A const&, Types const&...) -> tuple<Types...>
+// (5)  explicit tuple(AT, A const&, Types const&...) -> tuple<Types...>
+// (6)  tuple(AT, A, pair<T1, T2>) -> tuple<T1, T2>
+// (7)  tuple(tuple const& t) -> decltype(t)
+// (8)  tuple(tuple&& t) -> decltype(t)
+// (9)  tuple(AT, A const&, tuple const& t) -> decltype(t)
+// (10) tuple(AT, A const&, tuple&& t) -> decltype(t)
+void test_primary_template()
+{
+  const std::allocator<int> A;
+  const auto AT = std::allocator_arg;
+  { // Testing (1)
+    int x = 101;
+    std::tuple t1(42);
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<int>);
+    std::tuple t2(x, 0.0, nullptr);
+    ASSERT_SAME_TYPE(decltype(t2), std::tuple<int, double, decltype(nullptr)>);
+  }
+  { // Testing (2)
+    std::pair<int, char> p1(1, 'c');
+    std::tuple t1(p1);
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<int, char>);
+
+    std::pair<int, std::tuple<char, long, void*>> p2(1, std::tuple<char, long, void*>('c', 3l, nullptr));
+    std::tuple t2(p2);
+    ASSERT_SAME_TYPE(decltype(t2), std::tuple<int, std::tuple<char, long, void*>>);
+
+    int i = 3;
+    std::pair<std::reference_wrapper<int>, char> p3(std::ref(i), 'c');
+    std::tuple t3(p3);
+    ASSERT_SAME_TYPE(decltype(t3), std::tuple<std::reference_wrapper<int>, char>);
+
+    std::pair<int&, char> p4(i, 'c');
+    std::tuple t4(p4);
+    ASSERT_SAME_TYPE(decltype(t4), std::tuple<int&, char>);
+
+    std::tuple t5(std::pair<int, char>(1, 'c'));
+    ASSERT_SAME_TYPE(decltype(t5), std::tuple<int, char>);
+  }
+  { // Testing (3)
+    using T = ExplicitTestTypes::TestType;
+    static_assert(!std::is_convertible<T const&, T>::value, "");
+
+    std::tuple t1(T{});
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<T>);
+
+    const T v{};
+    std::tuple t2(T{}, 101l, v);
+    ASSERT_SAME_TYPE(decltype(t2), std::tuple<T, long, T>);
+  }
+  { // Testing (4)
+    int x = 101;
+    std::tuple t1(AT, A, 42);
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<int>);
+
+    std::tuple t2(AT, A, 42, 0.0, x);
+    ASSERT_SAME_TYPE(decltype(t2), std::tuple<int, double, int>);
+  }
+  { // Testing (5)
+    using T = ExplicitTestTypes::TestType;
+    static_assert(!std::is_convertible<T const&, T>::value, "");
+
+    std::tuple t1(AT, A, T{});
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<T>);
+
+    const T v{};
+    std::tuple t2(AT, A, T{}, 101l, v);
+    ASSERT_SAME_TYPE(decltype(t2), std::tuple<T, long, T>);
+  }
+  { // Testing (6)
+    std::pair<int, char> p1(1, 'c');
+    std::tuple t1(AT, A, p1);
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<int, char>);
+
+    std::pair<int, std::tuple<char, long, void*>> p2(1, std::tuple<char, long, void*>('c', 3l, nullptr));
+    std::tuple t2(AT, A, p2);
+    ASSERT_SAME_TYPE(decltype(t2), std::tuple<int, std::tuple<char, long, void*>>);
+
+    int i = 3;
+    std::pair<std::reference_wrapper<int>, char> p3(std::ref(i), 'c');
+    std::tuple t3(AT, A, p3);
+    ASSERT_SAME_TYPE(decltype(t3), std::tuple<std::reference_wrapper<int>, char>);
+
+    std::pair<int&, char> p4(i, 'c');
+    std::tuple t4(AT, A, p4);
+    ASSERT_SAME_TYPE(decltype(t4), std::tuple<int&, char>);
+
+    std::tuple t5(AT, A, std::pair<int, char>(1, 'c'));
+    ASSERT_SAME_TYPE(decltype(t5), std::tuple<int, char>);
+  }
+  { // Testing (7)
+    using Tup = std::tuple<int, decltype(nullptr)>;
+    const Tup t(42, nullptr);
+
+    std::tuple t1(t);
+    ASSERT_SAME_TYPE(decltype(t1), Tup);
+  }
+  { // Testing (8)
+    using Tup = std::tuple<void*, unsigned, char>;
+    std::tuple t1(Tup(nullptr, 42, 'a'));
+    ASSERT_SAME_TYPE(decltype(t1), Tup);
+  }
+  { // Testing (9)
+    using Tup = std::tuple<int, decltype(nullptr)>;
+    const Tup t(42, nullptr);
+
+    std::tuple t1(AT, A, t);
+    ASSERT_SAME_TYPE(decltype(t1), Tup);
+  }
+  { // Testing (10)
+    using Tup = std::tuple<void*, unsigned, char>;
+    std::tuple t1(AT, A, Tup(nullptr, 42, 'a'));
+    ASSERT_SAME_TYPE(decltype(t1), Tup);
+  }
+}
+
+// Overloads
+//  using A = Allocator
+//  using AT = std::allocator_arg_t
+// ---------------
+// (1)  tuple() -> tuple<>
+// (2)  tuple(AT, A const&) -> tuple<>
+// (3)  tuple(tuple const&) -> tuple<>
+// (4)  tuple(tuple&&) -> tuple<>
+// (5)  tuple(AT, A const&, tuple const&) -> tuple<>
+// (6)  tuple(AT, A const&, tuple&&) -> tuple<>
+void test_empty_specialization()
+{
+  std::allocator<int> A;
+  const auto AT = std::allocator_arg;
+  { // Testing (1)
+    std::tuple t1{};
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
+  }
+  { // Testing (2)
+    std::tuple t1{AT, A};
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
+  }
+  { // Testing (3)
+    const std::tuple<> t{};
+    std::tuple t1(t);
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
+  }
+  { // Testing (4)
+    std::tuple t1(std::tuple<>{});
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
+  }
+  { // Testing (5)
+    const std::tuple<> t{};
+    std::tuple t1(AT, A, t);
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
+  }
+  { // Testing (6)
+    std::tuple t1(AT, A, std::tuple<>{});
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
+  }
+}
+
+int main(int, char**) {
+  test_primary_template();
+  test_empty_specialization();
+
+  return 0;
+}

libcxx/trunk/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-// UNSUPPORTED: libcpp-no-deduction-guides
-
-// GCC's implementation of class template deduction is still immature and runs
-// into issues with libc++. However GCC accepts this code when compiling
-// against libstdc++.
-// XFAIL: gcc
-
-// <tuple>
-
-// Test that the constructors offered by std::tuple are formulated
-// so they're compatible with implicit deduction guides, or if that's not
-// possible that they provide explicit guides to make it work.
-
-#include <tuple>
-#include <memory>
-#include <cassert>
-
-#include "test_macros.h"
-#include "archetypes.hpp"
-
-
-// Overloads
-//  using A = Allocator
-//  using AT = std::allocator_arg_t
-// ---------------
-// (1)  tuple(const Types&...) -> tuple<Types...>
-// (2)  explicit tuple(const Types&...) -> tuple<Types...>
-// (3)  tuple(AT, A const&, Types const&...) -> tuple<Types...>
-// (4)  explicit tuple(AT, A const&, Types const&...) -> tuple<Types...>
-// (5)  tuple(tuple const& t) -> decltype(t)
-// (6)  tuple(tuple&& t) -> decltype(t)
-// (7)  tuple(AT, A const&, tuple const& t) -> decltype(t)
-// (8)  tuple(AT, A const&, tuple&& t) -> decltype(t)
-void test_primary_template()
-{
-  const std::allocator<int> A;
-  const auto AT = std::allocator_arg;
-  { // Testing (1)
-    int x = 101;
-    std::tuple t1(42);
-    ASSERT_SAME_TYPE(decltype(t1), std::tuple<int>);
-    std::tuple t2(x, 0.0, nullptr);
-    ASSERT_SAME_TYPE(decltype(t2), std::tuple<int, double, decltype(nullptr)>);
-  }
-  { // Testing (2)
-    using T = ExplicitTestTypes::TestType;
-    static_assert(!std::is_convertible<T const&, T>::value, "");
-
-    std::tuple t1(T{});
-    ASSERT_SAME_TYPE(decltype(t1), std::tuple<T>);
-
-    const T v{};
-    std::tuple t2(T{}, 101l, v);
-    ASSERT_SAME_TYPE(decltype(t2), std::tuple<T, long, T>);
-  }
-  { // Testing (3)
-    int x = 101;
-    std::tuple t1(AT, A, 42);
-    ASSERT_SAME_TYPE(decltype(t1), std::tuple<int>);
-
-    std::tuple t2(AT, A, 42, 0.0, x);
-    ASSERT_SAME_TYPE(decltype(t2), std::tuple<int, double, int>);
-  }
-  { // Testing (4)
-    using T = ExplicitTestTypes::TestType;
-    static_assert(!std::is_convertible<T const&, T>::value, "");
-
-    std::tuple t1(AT, A, T{});
-    ASSERT_SAME_TYPE(decltype(t1), std::tuple<T>);
-
-    const T v{};
-    std::tuple t2(AT, A, T{}, 101l, v);
-    ASSERT_SAME_TYPE(decltype(t2), std::tuple<T, long, T>);
-  }
-  { // Testing (5)
-    using Tup = std::tuple<int, decltype(nullptr)>;
-    const Tup t(42, nullptr);
-
-    std::tuple t1(t);
-    ASSERT_SAME_TYPE(decltype(t1), Tup);
-  }
-  { // Testing (6)
-    using Tup = std::tuple<void*, unsigned, char>;
-    std::tuple t1(Tup(nullptr, 42, 'a'));
-    ASSERT_SAME_TYPE(decltype(t1), Tup);
-  }
-  { // Testing (7)
-    using Tup = std::tuple<int, decltype(nullptr)>;
-    const Tup t(42, nullptr);
-
-    std::tuple t1(AT, A, t);
-    ASSERT_SAME_TYPE(decltype(t1), Tup);
-  }
-  { // Testing (8)
-    using Tup = std::tuple<void*, unsigned, char>;
-    std::tuple t1(AT, A, Tup(nullptr, 42, 'a'));
-    ASSERT_SAME_TYPE(decltype(t1), Tup);
-  }
-}
-
-// Overloads
-//  using A = Allocator
-//  using AT = std::allocator_arg_t
-// ---------------
-// (1)  tuple() -> tuple<>
-// (2)  tuple(AT, A const&) -> tuple<>
-// (3)  tuple(tuple const&) -> tuple<>
-// (4)  tuple(tuple&&) -> tuple<>
-// (5)  tuple(AT, A const&, tuple const&) -> tuple<>
-// (6)  tuple(AT, A const&, tuple&&) -> tuple<>
-void test_empty_specialization()
-{
-  std::allocator<int> A;
-  const auto AT = std::allocator_arg;
-  { // Testing (1)
-    std::tuple t1{};
-    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
-  }
-  { // Testing (2)
-    std::tuple t1{AT, A};
-    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
-  }
-  { // Testing (3)
-    const std::tuple<> t{};
-    std::tuple t1(t);
-    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
-  }
-  { // Testing (4)
-    std::tuple t1(std::tuple<>{});
-    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
-  }
-  { // Testing (5)
-    const std::tuple<> t{};
-    std::tuple t1(AT, A, t);
-    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
-  }
-  { // Testing (6)
-    std::tuple t1(AT, A, std::tuple<>{});
-    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
-  }
-}
-
-int main(int, char**) {
-  test_primary_template();
-  test_empty_specialization();
-
-  return 0;
-}