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.

llvm-svn: 314864

libcxx/include/tuple

@@ -929,7 +929,7 @@ public:
     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"

libcxx/include/utility

@@ -545,6 +545,11 @@ private:
 #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

libcxx/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>

libcxx/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>);
+  }
+}