[NFC][libc++] Add missing EXPLICIT to pair and tuple synopsis

The constructors for std::pair and std::tuple have been made conditionally
explicit, however the synopsis in the headers do not reflect that.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@366735 91177308-0d34-0410-b5e6-96231b3b80d8

include/tuple

@@ -20,39 +20,39 @@ template <class... T>
 class tuple {
 public:
     constexpr tuple();
-    explicit tuple(const T&...);  // constexpr in C++14
+    explicit(see-below) tuple(const T&...);  // constexpr in C++14
     template <class... U>
-        explicit tuple(U&&...);  // constexpr in C++14
+        explicit(see-below) tuple(U&&...);  // constexpr in C++14
     tuple(const tuple&) = default;
     tuple(tuple&&) = default;
     template <class... U>
-        tuple(const tuple<U...>&);  // constexpr in C++14
+        explicit(see-below) tuple(const tuple<U...>&);  // constexpr in C++14
     template <class... U>
-        tuple(tuple<U...>&&);  // constexpr in C++14
+        explicit(see-below) tuple(tuple<U...>&&);  // constexpr in C++14
     template <class U1, class U2>
-        tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
+        explicit(see-below) tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
     template <class U1, class U2>
-        tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2  // constexpr in C++14
+        explicit(see-below) tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2  // constexpr in C++14
 
     // allocator-extended constructors
     template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a);
     template <class Alloc>
-        tuple(allocator_arg_t, const Alloc& a, const T&...);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const T&...);
     template <class Alloc, class... U>
-        tuple(allocator_arg_t, const Alloc& a, U&&...);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, U&&...);
     template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a, const tuple&);
     template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a, tuple&&);
     template <class Alloc, class... U>
-        tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&);
     template <class Alloc, class... U>
-        tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&);
     template <class Alloc, class U1, class U2>
-        tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
     template <class Alloc, class U1, class U2>
-        tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
 
     tuple& operator=(const tuple&);
     tuple&

include/utility

@@ -70,10 +70,10 @@ struct pair
     pair(const pair&) = default;
     pair(pair&&) = default;
     constexpr pair();
-    pair(const T1& x, const T2& y);                          // constexpr in C++14
-    template <class U, class V> pair(U&& x, V&& y);          // constexpr in C++14
-    template <class U, class V> pair(const pair<U, V>& p);   // constexpr in C++14
-    template <class U, class V> pair(pair<U, V>&& p);        // constexpr in C++14
+    explicit(see-below) pair(const T1& x, const T2& y);                          // constexpr in C++14
+    template <class U, class V> explicit(see-below) pair(U&& x, V&& y);          // constexpr in C++14
+    template <class U, class V> explicit(see-below) pair(const pair<U, V>& p);   // constexpr in C++14
+    template <class U, class V> explicit(see-below) pair(pair<U, V>&& p);        // constexpr in C++14
     template <class... Args1, class... Args2>
         pair(piecewise_construct_t, tuple<Args1...> first_args,
              tuple<Args2...> second_args);