Add C++17 explicit deduction guides to std::pair.
This patch adds the newly standardized deduction guides
for std::pair, allowing it to work class template deduction.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@314864 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/tuple b/include/tuple
index a52b934..788fd75 100644
--- a/include/tuple
+++ b/include/tuple
@@ -929,7 +929,7 @@
void swap(tuple&) _NOEXCEPT {}
};
-#ifdef __cpp_deduction_guides
+#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"
diff --git a/include/utility b/include/utility
index 00e3cd2..288c6e8 100644
--- a/include/utility
+++ b/include/utility
@@ -545,6 +545,11 @@
#endif
};
+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
+template<class _T1, class _T2>
+pair(_T1, _T2) -> pair<_T1, _T2>;
+#endif // _LIBCPP_HAS_NO_DEDUCTION_GUIDES
+
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
index 7b9c061..85036b5 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
@@ -15,10 +15,11 @@
// against libstdc++.
// XFAIL: gcc
-// <string>
+// <tuple>
-// Test that the constructors offered by std::basic_string are formulated
-// so they're compatible with implicit deduction guides.
+// 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>
diff --git a/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
new file mode 100644
index 0000000..7933dd9
--- /dev/null
+++ b/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
@@ -0,0 +1,80 @@
+//===----------------------------------------------------------------------===//
+//
+// 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, 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
+
+// <utility>
+
+// Test that the constructors offered by std::pair 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 <utility>
+#include <memory>
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "archetypes.hpp"
+
+
+// Overloads
+// ---------------
+// (1) pair(const T1&, const T2&) -> pair<T1, T2>
+// (2) explicit pair(const T1&, const T2&) -> pair<T1, T2>
+// (3) pair(pair const& t) -> decltype(t)
+// (4) pair(pair&& t) -> decltype(t)
+// (5) pair(pair<U1, U2> const&) -> pair<U1, U2>
+// (6) explicit pair(pair<U1, U2> const&) -> pair<U1, U2>
+// (7) pair(pair<U1, U2> &&) -> pair<U1, U2>
+// (8) explicit pair(pair<U1, U2> &&) -> pair<U1, U2>
+int main()
+{
+ using E = ExplicitTestTypes::TestType;
+ static_assert(!std::is_convertible<E const&, E>::value, "");
+ { // Testing (1)
+ int const x = 42;
+ std::pair t1("abc", x);
+ ASSERT_SAME_TYPE(decltype(t1), std::pair<const char*, int>);
+ }
+ { // Testing (2)
+ std::pair p1(E{}, 42);
+ ASSERT_SAME_TYPE(decltype(p1), std::pair<E, int>);
+
+ const E t{};
+ std::pair p2(t, E{});
+ ASSERT_SAME_TYPE(decltype(p2), std::pair<E, E>);
+ }
+ { // Testing (3, 5)
+ std::pair<double, decltype(nullptr)> const p(0.0, nullptr);
+ std::pair p1(p);
+ ASSERT_SAME_TYPE(decltype(p1), std::pair<double, decltype(nullptr)>);
+ }
+ { // Testing (3, 6)
+ std::pair<E, decltype(nullptr)> const p(E{}, nullptr);
+ std::pair p1(p);
+ ASSERT_SAME_TYPE(decltype(p1), std::pair<E, decltype(nullptr)>);
+ }
+ { // Testing (4, 7)
+ std::pair<std::string, void*> p("abc", nullptr);
+ std::pair p1(std::move(p));
+ ASSERT_SAME_TYPE(decltype(p1), std::pair<std::string, void*>);
+ }
+ { // Testing (4, 8)
+ std::pair<std::string, E> p("abc", E{});
+ std::pair p1(std::move(p));
+ ASSERT_SAME_TYPE(decltype(p1), std::pair<std::string, E>);
+ }
+}
