[libc++][P2321R2] Add specializations of basic_common_reference and common_type for pair

[philnik]

Summary

Add specializations of basic_common_reference and common_type for pair

[• Quuxplusone]

Looks good to me, modulo some nits and scope-creep followup ideas.

libcxx/include/__utility/pair.h

323

Let's make this easy to compare to lines 320-321 at a glance.

333–336

Let's keep the deduction guide for pair located right after class pair; both because it's more tightly "related" to the class than these partial specializations, and so that the library additions remain in chronological order (C++03, then C++17 deduction guide, then C++2b specializations).

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_reference.compile.pass.cpp

204–205

Let's pick one style and be consistent here: either one-line all of these like lines 202, 203, etc; or two-line them all like lines 204-205, 206-207, etc.

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp

363–376

Should this say common_type_t instead of common_reference_t? or what's this line doing here? Ditto below.
And/or, should this line be moved to common_reference.compile.pass.cpp?

Orthogonally, and probably in a separate NFC commit, can common_type.pass.cpp be renamed to common_type.compile.pass.cpp (and eliminate its main)?

[philnik]

• Address comments

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp

363–376

I already thought about making this .compile.pass.cpp. That's why I put the static_asserts originally below the main in D116538. I'll make a follow-up PR.

[philnik]

ping

[Mordante]

LGTM, modulo one small issue. Please rebase to make sure the CI becomes green.

libcxx/include/__utility/pair.h

392

Please update the synopsis in <utility>.

[philnik]

• Rebased
• Add synopsis

libcxx/docs/Status/ZipProjects.csv

 Section,Description,Dependencies,Assignee,Complete
-| `[tuple.syn] <https://wg21.link/tuple.syn>`_, "`[tuple] basic_common_reference, common_type <https://reviews.llvm.org/D116538>`_", None, Nikolas Klauser, |In Progress|
+| `[tuple.syn] <https://wg21.link/tuple.syn>`_, "`[tuple] basic_common_reference, common_type <https://reviews.llvm.org/D116538>`_", None, Nikolas Klauser, |Complete|
 | `[tuple.tuple] <https://wg21.link/tuple.tuple>`_, "`[tuple] constructor, assignment and swap overloads <https://reviews.llvm.org/D116621>`_", None, Nikolas Klauser, |In Progress|
-| `[utility.syn] <https://wg21.link/utility.syn>`_, "[pair] basic_common_reference, common_type", None, Nikolas Klauser, |Not Started|
+| `[utility.syn] <https://wg21.link/utility.syn>`_, "[pair] basic_common_reference, common_type", None, Nikolas Klauser, |Complete|
 | `[pairs.pair] <https://wg21.link/pairs.pair>`_, "[pair] constructor, assignment and swap overloads", None, Nikolas Klauser, |Not Started|
 "| `[memory.syn] <https://wg21.link/memory.syn>`_
 | `[allocator.uses.construction] <https://wg21.link/allocator.uses.construction>`_", "[pair] uses_allocator_construction_args overloads", None, Unassigned, |Not Started|
 | `[vector.bool] <https://wg21.link/vector.bool>`_, "[vector<bool>::reference] add const operator= overload", None, Nikolas Klauser, |Not Started|
 | `[iterator.concept.winc] <https://wg21.link/iterator.concept.winc>`_, "Update weakly_comparable", None, Unassigned, |Not Started|
 | `[range.zip] <https://wg21.link/ranges.syn>`_, "zip_view", "| `zip_view::iterator`
 | `zip_view::sentinel`", Unassigned, |Not Started|
 | `[range.zip.iterator] <https://wg21.link/range.zip.transform>`_, "zip_view::iterator", None, Unassigned, |Not Started|

libcxx/include/__utility/pair.h

#ifndef _LIBCPP_CXX03_LANG
     template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     pair(piecewise_construct_t,
          tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
          __tuple_indices<_I1...>, __tuple_indices<_I2...>);
 #endif
 };
 
-#if _LIBCPP_STD_VER >= 17
+#if _LIBCPP_STD_VER > 14
 template<class _T1, class _T2>
 pair(_T1, _T2) -> pair<_T1, _T2>;
 #endif
 
 // [pairs.spec], specialized algorithms
 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
 {
     return __x.first == __y.first && __x.second == __y.second;
 }
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 template <class _T1, class _T2>
 _LIBCPP_HIDE_FROM_ABI constexpr
 common_comparison_category_t<
         __synth_three_way_result<_T1>,
         __synth_three_way_result<_T2> >
 operator<=>(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
 {
     if (auto __c = _VSTD::__synth_three_way(__x.first, __y.first); __c != 0) {
       return __c;
     }

 bool
 operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
 {
     return !(__y < __x);
 }
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
+#if _LIBCPP_STD_VER > 20
+template <class _T1, class _T2, class _U1, class _U2, template<class> class _TQual, template<class> class _UQual>
+    requires requires { typename pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
+                                      common_reference_t<_TQual<_T2>, _UQual<_U2>>>; }
+struct basic_common_reference<pair<_T1, _T2>, pair<_U1, _U2>, _TQual, _UQual> {
+    using type = pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
+                      common_reference_t<_TQual<_T2>, _UQual<_U2>>>;
+};
+
+template <class _T1, class _T2, class _U1, class _U2>
+    requires requires { typename pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; }
+struct common_type<pair<_T1, _T2>, pair<_U1, _U2>> {
+    using type = pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>;
+};
+#endif
+
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     __is_swappable<_T1>::value &&
     __is_swappable<_T2>::value,
     void
 >::type

libcxx/include/utility

struct pair
     pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value &&
                                        is_nothrow_move_assignable<T2>::value);   // constexpr in C++20
     template <class U, class V> pair& operator=(pair<U, V>&& p);                 // constexpr in C++20
 
     void swap(pair& p) noexcept(is_nothrow_swappable_v<T1> &&
                                 is_nothrow_swappable_v<T2>);                     // constexpr in C++20
 };
 
+template<class T1, class T2, class U1, class U2, template<class> class TQual, template<class> class UQual>
+struct basic_common_reference<pair<T1, T2>, pair<U1, U2>, TQual, UQual>;         // since C++23
+
+template<class T1, class T2, class U1, class U2>
+struct common_type<pair<T1, T2>, pair<U1, U2>>;                                  // since C++23
+
 template<class T1, class T2> pair(T1, T2) -> pair<T1, T2>;
 
 template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
 template <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
 template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
 template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
 template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
 template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_reference.compile.pass.cpp

 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // type_traits
 // common_reference
 
 #include <tuple>
 #include <type_traits>
+#include <utility>
 
 #include "test_macros.h"
 
 template <class T>
 constexpr bool has_type = requires {
   typename T::type;
 };
 

 struct A {};
 template <template<class> class TQual, template<class> class UQual>
 struct std::basic_common_reference<A, std::tuple<B>, TQual, UQual> {
   using type = tuple<UQual<B>>;
 };
 
 static_assert(std::is_same_v<std::common_reference_t<A, std::tuple<B>,std::tuple<D>>, std::tuple<B>>);
 
+
+static_assert(std::is_same_v<std::common_reference_t<std::pair<int, int>>,
+                             std::pair<int, int>>);
+static_assert(std::is_same_v<std::common_reference_t<std::pair<int, long>, std::pair<long, int>>,
+                             std::pair<long, long>>);
+static_assert(std::is_same_v<std::common_reference_t<std::pair<int&, const int&>, std::pair<const int&, int>>,
+                             std::pair<const int&, int>>);
+static_assert(std::is_same_v<std::common_reference_t<std::pair<int&, volatile int&>, std::pair<volatile int&, int>>,
+                             std::pair<volatile int&, int>>);
+static_assert(std::is_same_v<std::common_reference_t<std::pair<int&, const volatile int&>, std::pair<const volatile int&, int>>,
+                             std::pair<const volatile int&, int>>);
+static_assert(!has_type<std::common_reference_t<std::pair<const int&, volatile int&>,
+                        std::pair<volatile int&, const int&>>>);
+
+static_assert(std::is_same_v<std::common_reference_t<std::pair<int, X2>, std::pair<int, Y2>>, std::pair<int, Z2>>);
+static_assert(std::is_same_v<std::common_reference_t<std::pair<int, X2>, std::pair<int, Y2>>, std::pair<int, Z2>>);
+static_assert(!has_type<std::common_reference<std::pair<int, const X2>, std::pair<float, const Z2>>>);
+static_assert(!has_type<std::common_reference<std::pair<int, X2>, std::pair<float, Z2>>>);
+static_assert(!has_type<std::common_reference<std::pair<int, X2>, int, X2>>);
 #endif
 
 int main(int, char**) { return 0; }

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // common_type
 
 #include <functional>
 #include <memory>
 #include <tuple>
 #include <type_traits>
+#include <utility>
 
 #include "test_macros.h"
 
 struct E {};
 
 template <class T>
 struct X { explicit X(T const&){} };
 

 //       denote the type decay_t<COND-RES(CREF(D1), CREF(D2))>.
 void test_bullet_three_four() {
 #if TEST_STD_VER >= 20
   static_assert(std::is_same_v<std::common_type_t<int, bad_reference_wrapper<int>>, int>, "");
   static_assert(std::is_same_v<std::common_type_t<bad_reference_wrapper<double>, double>, double>, "");
   static_assert(std::is_same_v<std::common_type_t<const bad_reference_wrapper<double>, double>, double>, "");
   static_assert(std::is_same_v<std::common_type_t<volatile bad_reference_wrapper<double>, double>, double>, "");
   static_assert(std::is_same_v<std::common_type_t<const volatile bad_reference_wrapper<double>, double>, double>, "");
-  
   static_assert(std::is_same_v<std::common_type_t<bad_reference_wrapper<double>, const double>, double>, "");
   static_assert(std::is_same_v<std::common_type_t<bad_reference_wrapper<double>, volatile double>, double>, "");
   static_assert(std::is_same_v<std::common_type_t<bad_reference_wrapper<double>, const volatile double>, double>, "");
-  
   static_assert(std::is_same_v<std::common_type_t<bad_reference_wrapper<double>&, double>, double>, "");
   static_assert(std::is_same_v<std::common_type_t<bad_reference_wrapper<double>, double&>, double>, "");
 #endif
 }
 
 // (4.4)
 // -- If sizeof...(T) is greater than two, let T1, T2, and R, respectively,
 // denote the first, second, and (pack of) remaining types constituting T.

 #if TEST_STD_VER > 20
     // P2321
     static_assert(std::is_same_v<std::common_type_t<std::tuple<int>>, std::tuple<int>>);
     static_assert(std::is_same_v<std::common_type_t<std::tuple<int>, std::tuple<long>>, std::tuple<long>>);
     static_assert(std::is_same_v<std::common_type_t<std::tuple<const int>, std::tuple<const int>>, std::tuple<int>>);
     static_assert(std::is_same_v<std::common_type_t<std::tuple<const int&>>, std::tuple<int>>);
     static_assert(std::is_same_v<std::common_type_t<std::tuple<const volatile int&>, std::tuple<const volatile long&>>, std::tuple<long>>);
 
-    static_assert(std::is_same_v<std::common_reference_t<A, std::tuple<B>,std::tuple<C>>, std::tuple<B>>);
+    static_assert(std::is_same_v<std::common_type_t<A, std::tuple<B>,std::tuple<C>>, std::tuple<B>>);
+
+    static_assert(std::is_same_v<std::common_type_t<std::pair<int, int>>, std::pair<int, int>>);
+    static_assert(std::is_same_v<std::common_type_t<std::pair<int, long>, std::pair<long, int>>, std::pair<long, long>>);
+    static_assert(std::is_same_v<std::common_type_t<std::pair<const int, const long>,
+                                                    std::pair<const int, const long>>,
+                                                    std::pair<int, long>>);
+
+    static_assert(std::is_same_v<std::common_type_t<std::pair<const int&, const long&>>, std::pair<int, long>>);
+    static_assert(std::is_same_v<std::common_type_t<std::pair<const volatile int&, const volatile long&>,
+                                                    std::pair<const volatile long&, const volatile int&>>,
+                                                    std::pair<long, long>>);
+
+    static_assert(std::is_same_v<std::common_type_t<A, std::tuple<B>,std::tuple<C>>, std::tuple<B>>);
 #endif
 
   return 0;
 }