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

[philnik]

Summary

Add specializations of basic_common_reference and common_type for tuple

[Mordante]

Since std::basic_common_reference isn't exposition-only I would like an explicit test for it.

libcxx/include/tuple

77

Please add // since C++23 for both new entries.

1122

This suggestion is what the paper mandates and it matches the latest draft.

1127

Nit: I have a slight preference to use _Tp and _Up to match the other parts of the code.
(Since the previous function uses both Types and Qual I think the different naming there makes sense.)

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

179

Can you add some tests with volatile and const volatile?

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

355

I would prefer to use std::common_type<...>::type like the other test.
And likewise some volatile and const volatile.

[• Quuxplusone]

libcxx/include/tuple

1122

And if the existing tests didn't catch this (which I guess they must not have): please add a regression test that would have caught this.

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

18–21

If you want to make a preliminary NFC commit to eliminate all four of these using-declarations in favor of fully qualified names throughout, I'd approve it instantly. :)

47–56

While you're here, I suggest rewriting lines 54–63 to not reopen namespace std:

template<> struct std::common_type<X2, Y2> { using type = Z2; }
template<> struct std::common_type<Y2, X2> { using type = Z2; }

And please add some tests involving them, e.g. IIUC

static_assert(std::is_same_v<std::common_reference_t<std::tuple<int, X2>, std::tuple<int, Y2>>, std::tuple<int, Z2>>);
static_assert(std::is_same_v<std::common_reference_t<std::tuple<int, X2>, std::tuple<int, Y2>>, std::tuple<int, Z2>>);
static_assert(!has_type<std::common_reference<std::tuple<int, const X2>, std::tuple<float, const Y2>>);
static_assert(!has_type<std::common_reference<std::tuple<int, X2>, std::tuple<float, Y2>>);
static_assert(!has_type<std::common_reference<std::tuple<int, X2>, int, X2>);

or whatever the results are supposed to be.

I haven't thought much about this, but it would probably be good to add a couple more specializations involving tuple to this test, e.g.

template<> struct std::common_type<X3, std::tuple<X2>> { using type = Z3; }
template<> struct std::common_type<std::tuple<X2>, X3> { using type = Z3; }
template<> struct std::common_type<X3, std::tuple<Y2>> { using type = Z3; }
template<> struct std::common_type<std::tuple<Y2>, X3> { using type = Z3; }

and then test e.g. common_type_t<std::tuple<X2>, std::tuple<Y2>, X3> and common_type_t<std::tuple<X2>, std::tuple<Y2>, std::tuple<X3>>.

[Mordante]

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

38–39

I noticed this while reviewing D116744, should this be disabled in C++23?

[philnik]

• reabsed onto main
• Updated tests

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

38–39

Why?

47–56

I'll refactor lines 54-63 in another patch.
I understand what you want to achieve with the common_reference asserts, but I don't know your intention with the common_type specializations.

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

355

I wouldn't do that, because the asserts are already very long and I don't think using ::typeinstead of _t increases the readability in any way - the opposite even.

[• Quuxplusone]

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

38–39

should this be disabled in C++23?

AIUI: No, but it might be helpful to the reader if we s/Tuple/UserTuple/g. This is basically replicating in userspace (for Tuple) what P2321 is now doing in library-space (for std::tuple); even in C++23, we want to keep testing that the userspace version still works.

47–56

I'll refactor lines 54-63 in another patch.

OK. Please also hit line 37 in that same patch.

I understand what you want to achieve with the common_reference asserts, but I don't know your intention with the common_type specializations.

I don't know much about the mazey relationships between common_type, common_reference, basic_common_reference, so I might be asking for nonsense. :) Also I might have said "test common_type_t<..." when I meant "test common_reference_t<..."? But basically I'd like to see

• a test of variadic common_{type,reference}_t<A,B,C> where common_type<A,B> is due to the C++23-library-provided tuple specialization and common_type<B,C> is due to a user specialization
• a user specialization of common_type that involves std::tuple<SomeUserDefinedType>, proving that the C++23-library-provided partial specialization isn't interfering-with or ambiguating that user specialization

Does that make more sense?

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

355

I think these new static_asserts should go inside main just like lines 326–341; and they should be introduced with a comment // P2321 just like line 325. (Although I would not complain if you were to indent line 325 in a more natural way, as a drive-by.) We should basically never add code after the closing brace of main.

And then for consistency I can see a good rationale for using ::type and ::value and , ""); — although IMO that's less important than the other stuff I just mentioned, and I feel like @Mordante has asked to remove , "" from C++20 static_asserts in other places — anyway, count me as ambivalent on that.

[philnik]

• renamed Tuple to UserTuple
• Update test

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

47–56

Yep, makes much more sense! But I think the two things are impossible to test separately.

[philnik]

ping

[Mordante]

Thanks for the ping. It seems I missed the updates for this patch. LGTM!

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

38–39

Yes I initially was confused by the name and it's not a std::tuple.

[ldionne]

LGTM with minor comment.

libcxx/docs/Status/Cxx2bPapers.csv

36

I'd suggest not including 14.0 here. We could put a number only when we complete the feature.

libcxx/docs/Status/Cxx2bPapers.csv

 "`P0849R8 <https://wg21.link/P0849R8>`__","LWG","``auto(x)``: ``DECAY_COPY`` in the language","October 2021","|Complete|","14.0"
 "`P1072R10 <https://wg21.link/P1072R10>`__","LWG","``basic_string::resize_and_overwrite``","October 2021","|Complete|","14.0"
 "`P1147R1 <https://wg21.link/P1147R1>`__","LWG","Printing ``volatile`` Pointers","October 2021","|Complete|","14.0"
 "`P1272R4 <https://wg21.link/P1272R4>`__","LWG","Byteswapping for fun&&nuf","October 2021","|Complete|","14.0"
 "`P1675R2 <https://wg21.link/P1675R2>`__","LWG","``rethrow_exception`` must be allowed to copy","October 2021","",""
 "`P2077R3 <https://wg21.link/P2077R3>`__","LWG","Heterogeneous erasure overloads for associative containers","October 2021","",""
 "`P2251R1 <https://wg21.link/P2251R1>`__","LWG","Require ``span`` & ``basic_string_view`` to be Trivially Copyable","October 2021","|Complete|","14.0"
 "`P2301R1 <https://wg21.link/P2301R1>`__","LWG","Add a ``pmr`` alias for ``std::stacktrace``","October 2021","",""
-"`P2321R2 <https://wg21.link/P2321R2>`__","LWG","``zip``","October 2021","",""
+"`P2321R2 <https://wg21.link/P2321R2>`__","LWG","``zip``","October 2021","|In Progress|","14.0"
 "`P2340R1 <https://wg21.link/P2340R1>`__","LWG","Clarifying the status of the 'C headers'","October 2021","",""
 "`P2393R1 <https://wg21.link/P2393R1>`__","LWG","Cleaning up ``integer``-class types","October 2021","",""
 "`P2401R0 <https://wg21.link/P2401R0>`__","LWG","Add a conditional ``noexcept`` specification to ``std::exchange``","October 2021","|Complete|","14.0"
 "","","","","",""

libcxx/include/tuple

public:
     template<class U, size_t N>
         tuple& operator=(array<U, N> const&) // iff sizeof...(T) == N, EXTENSION
     template<class U, size_t N>
         tuple& operator=(array<U, N>&&) // iff sizeof...(T) == N, EXTENSION
 
     void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));               // constexpr in C++20
 };
 
+
+template<class... TTypes, class... UTypes, template<class> class TQual, template<class> class UQual> // since C++23
+  requires requires { typename tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>; }
+struct basic_common_reference<tuple<TTypes...>, tuple<UTypes...>, TQual, UQual> {
+  using type = tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>;
+};
+
+template<class... TTypes, class... UTypes>                                // since C++23
+  requires requires { typename tuple<common_type_t<TTypes, UTypes>...>; }
+struct common_type<tuple<TTypes...>, tuple<UTypes...>> {
+  using type = tuple<common_type_t<TTypes, UTypes>...>;
+};
+
 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
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         tuple(array<_Up, 0>) _NOEXCEPT {}
     template <class _Alloc, class _Up>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void swap(tuple&) _NOEXCEPT {}
 };
 
-#if _LIBCPP_STD_VER >= 17
+#if _LIBCPP_STD_VER > 20
+template <class... _TTypes, class... _UTypes, template<class> class _TQual, template<class> class _UQual>
+    requires requires { typename tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>; }
+struct basic_common_reference<tuple<_TTypes...>, tuple<_UTypes...>, _TQual, _UQual> {
+    using type = tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>;
+};
+
+template <class... _TTypes, class... _UTypes>
+    requires requires { typename tuple<common_type_t<_TTypes, _UTypes>...>; }
+struct common_type<tuple<_TTypes...>, tuple<_UTypes...>> {
+    using type = tuple<common_type_t<_TTypes, _UTypes>...>;
+};
+#endif
+
+#if _LIBCPP_STD_VER > 14
 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>;

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

 //===----------------------------------------------------------------------===//
 //
 //                     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++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // type_traits
 // common_reference
 
+#include <tuple>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T>
 constexpr bool has_type = requires {
   typename T::type;
 };
 
 // A slightly simplified variation of std::tuple
 template <class...>
-struct Tuple {};
+struct UserTuple {};
 
 template <class, class, class>
 struct Tuple_helper {};
 template <class... Ts, class... Us>
-struct Tuple_helper<std::void_t<std::common_reference_t<Ts, Us>...>, Tuple<Ts...>, Tuple<Us...> > {
-  using type = Tuple<std::common_reference_t<Ts, Us>...>;
+struct Tuple_helper<std::void_t<std::common_reference_t<Ts, Us>...>, UserTuple<Ts...>, UserTuple<Us...> > {
+  using type = UserTuple<std::common_reference_t<Ts, Us>...>;
 };
 
 namespace std {
 template <class... Ts, class... Us, template <class> class TQual, template <class> class UQual>
-struct basic_common_reference< ::Tuple<Ts...>, ::Tuple<Us...>, TQual, UQual>
-    : ::Tuple_helper<void, Tuple<TQual<Ts>...>, Tuple<UQual<Us>...> > {};
+struct basic_common_reference< ::UserTuple<Ts...>, ::UserTuple<Us...>, TQual, UQual>
+    : ::Tuple_helper<void, UserTuple<TQual<Ts>...>, UserTuple<UQual<Us>...> > {};
 } // namespace std
 
 struct X2 {};
 struct Y2 {};
 struct Z2 {};
 
 namespace std {
 template <>
 struct common_type<X2, Y2> {
   using type = Z2;
 };
 template <>
 struct common_type<Y2, X2> {
   using type = Z2;
 };
 } // namespace std
 
 // (6.1)
 //  -- If sizeof...(T) is zero, there shall be no member type.
 static_assert(!has_type<std::common_reference<> >);
 
 // (6.2)
 //  -- Otherwise, if sizeof...(T) is one, let T0 denote the sole type in the
 //     pack T. The member typedef type shall denote the same type as T0.

 
 static_assert(std::is_same_v<std::common_reference_t<int (&)[10], int (&&)[10]>, int const (&)[10]>);
 static_assert(std::is_same_v<std::common_reference_t<int const (&)[10], int volatile (&)[10]>, int const volatile (&)[10]>);
 
 // (6.3.2)
 //    -- Otherwise, if basic_common_reference<remove_cvref_t<T1>,
 //       remove_cvref_t<T2>, XREF(T1), XREF(T2)>::type is well-formed, then the
 //       member typedef type denotes that type.
-static_assert(std::is_same_v<std::common_reference_t<const Tuple<int, short>&, Tuple<int&, short volatile&>>,
-                             Tuple<const int&, const volatile short&>>);
+static_assert(std::is_same_v<std::common_reference_t<const UserTuple<int, short>&, UserTuple<int&, short volatile&>>,
+                             UserTuple<const int&, const volatile short&>>);
 
-static_assert(std::is_same_v<std::common_reference_t<volatile Tuple<int, short>&, const Tuple<int, short>&>,
-                             const volatile Tuple<int, short>&>);
+static_assert(std::is_same_v<std::common_reference_t<volatile UserTuple<int, short>&, const UserTuple<int, short>&>,
+                             const volatile UserTuple<int, short>&>);
 
 // (6.3.3)
 //    -- Otherwise, if COND_RES(T1, T2) is well-formed, then the member typedef
 //       type denotes that type.
 static_assert(std::is_same_v<std::common_reference_t<void, void>, void>);
 static_assert(std::is_same_v<std::common_reference_t<int, short>, int>);
 static_assert(std::is_same_v<std::common_reference_t<int, short&>, int>);
 static_assert(std::is_same_v<std::common_reference_t<int&, short&>, int>);

 static_assert(std::is_same_v<std::common_reference_t<moveonly const&, moveonly>, moveonly>);
 static_assert(std::is_same_v<std::common_reference_t<moveonly2 const&, moveonly>, moveonly>);
 static_assert(std::is_same_v<std::common_reference_t<moveonly const&, moveonly2>, moveonly>);
 
 static_assert(std::is_same_v<std::common_reference_t<X2&, Y2 const&>, Z2>);
 
 // (6.3.5)
 //    -- Otherwise, there shall be no member type.
-static_assert(!has_type<std::common_reference<volatile Tuple<short>&, const Tuple<int, short>&> >);
+static_assert(!has_type<std::common_reference<volatile UserTuple<short>&, const UserTuple<int, short>&> >);
 
 // (6.4)
 //  -- Otherwise, if sizeof...(T) is greater than two, let T1, T2, and Rest,
 //     respectively, denote the first, second, and (pack of) remaining types
 //     comprising T. Let C be the type common_reference_t<T1, T2>. Then:
 // (6.4.1)
 //    -- If there is such a type C, the member typedef type shall denote the
 //       same type, if any, as common_reference_t<C, Rest...>.
 static_assert(std::is_same_v<std::common_reference_t<int, int, int>, int>);
 static_assert(std::is_same_v<std::common_reference_t<int&&, int const&, int volatile&>, int const volatile&>);
 static_assert(std::is_same_v<std::common_reference_t<int&&, int const&, float&>, float>);
 
 // (6.4.2)
 //    -- Otherwise, there shall be no member type.
 static_assert(!has_type<std::common_reference<int, short, int, char*> >);
 
+#if TEST_STD_VER > 20
+static_assert(std::is_same_v<std::common_reference_t<std::tuple<int, int>>, std::tuple<int, int>>);
+static_assert(std::is_same_v<std::common_reference_t<std::tuple<int, long>, std::tuple<long, int>>, std::tuple<long, long>>);
+static_assert(std::is_same_v<std::common_reference_t<std::tuple<int&, const int&>, std::tuple<const int&, int>>,
+                             std::tuple<const int&, int>>);
+static_assert(std::is_same_v<std::common_reference_t<std::tuple<int&, volatile int&>, std::tuple<volatile int&, int>>,
+                             std::tuple<volatile int&, int>>);
+static_assert(std::is_same_v<std::common_reference_t<std::tuple<int&, const volatile int&>, std::tuple<const volatile int&, int>>,
+                             std::tuple<const volatile int&, int>>);
+static_assert(!has_type<std::common_reference_t<std::tuple<const int&, volatile int&>, std::tuple<volatile int&, const int&>>>);
+
+static_assert(std::is_same_v<std::common_reference_t<std::tuple<int, X2>, std::tuple<int, Y2>>, std::tuple<int, Z2>>);
+static_assert(std::is_same_v<std::common_reference_t<std::tuple<int, X2>, std::tuple<int, Y2>>, std::tuple<int, Z2>>);
+static_assert(!has_type<std::common_reference<std::tuple<int, const X2>, std::tuple<float, const Z2>>>);
+static_assert(!has_type<std::common_reference<std::tuple<int, X2>, std::tuple<float, Z2>>>);
+static_assert(!has_type<std::common_reference<std::tuple<int, X2>, int, X2>>);
+
+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>>);
+
+#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 "test_macros.h"
 
 struct E {};
 
 template <class T>
 struct X { explicit X(T const&){} };
void test_bullet_four() {
     static_assert((no_common_type<int, int, E>::value), "");
 #if TEST_STD_VER >= 11
     static_assert((no_common_type<int, int, E, int>::value), "");
     static_assert((no_common_type<int, int, int, E>::value), "");
 #endif
   }
 }
 
+#if TEST_STD_VER > 20
+struct A {};
+struct B {};
+struct C : B {};
+template<>
+struct std::common_type<A, std::tuple<B>> {
+  using type = tuple<B>;
+};
+#endif
+
 int main(int, char**)
 {
     static_assert((std::is_same<std::common_type<int>::type, int>::value), "");
     static_assert((std::is_same<std::common_type<char>::type, char>::value), "");
 #if TEST_STD_VER > 11
     static_assert((std::is_same<std::common_type_t<int>,   int>::value), "");
     static_assert((std::is_same<std::common_type_t<char>, char>::value), "");
 #endif
#endif
 
   test_bullet_one();
   test_bullet_two();
   test_bullet_three_one();
   test_bullet_three_three();
   test_bullet_three_four();
   test_bullet_four();
 
-//  P0548
+    // P0548
     static_assert((std::is_same<std::common_type<S<int> >::type,         S<int> >::value), "");
     static_assert((std::is_same<std::common_type<S<int>, S<int> >::type, S<int> >::value), "");
 
     static_assert((std::is_same<std::common_type<int>::type,                int>::value), "");
     static_assert((std::is_same<std::common_type<const int>::type,          int>::value), "");
     static_assert((std::is_same<std::common_type<volatile int>::type,       int>::value), "");
     static_assert((std::is_same<std::common_type<const volatile int>::type, int>::value), "");
 
     static_assert((std::is_same<std::common_type<int, int>::type,             int>::value), "");
     static_assert((std::is_same<std::common_type<const int, int>::type,       int>::value), "");
     static_assert((std::is_same<std::common_type<int, const int>::type,       int>::value), "");
     static_assert((std::is_same<std::common_type<const int, const int>::type, int>::value), "");
 
 #if TEST_STD_VER >= 11
     // Test that we're really variadic in C++11
     static_assert(std::is_same<std::common_type<int, int, int, int, int, int, int, int>::type, int>::value, "");
 #endif
 
+#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>>);
+#endif
+
   return 0;
 }