[libcxx][type_traits] Add C++20 changes to common_type

[miscco]

Summary

This already implements the expected changes for LWG-3205

[miscco]

ping

[EricWF]

I assume this is a behavioral change? Why are there no new tests?

[miscco]

Actually I was having trouble comming up with a test case for bullet 4.

[miscco]

Add test for a reference wrapper type

[miscco]

Thanks to @CaseyCarter for the example

[miscco]

ping

[ldionne]

LGTM, but why is there no change to the conformance status page?

[miscco]

Thanks for the review, could somebody commit it as I do not have the rights

[ldionne]

In D74350#2034517, @miscco wrote:

Thanks for the review, could somebody commit it as I do not have the rights

Doing -- but could you please ask for commit rights? This wouldn't prevent you from needing to request reviews, but at least you could commit your patches yourself once you have the LGTM. The process for obtaining commit rights is https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access.

[ldionne]

Sorry, two more things as I look at the diff again locally.

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

228

There's a weird non-printable character on this line (<U+00AD>). I noticed that by looking at the diff in git. Please watch out for those.

231

Don't we need to test with some cv qualified and ref types too?

[miscco]

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

228

Sory, I guess this comes from copying from eel.is I will have a look for those

231

I guess adding cv qualifiers similar to the above bullets should work even for a reference wrapper.

If I understand CREF correctly this should also work std::is_same_v<std::common_type_t<bad_reference_wrapper<double>&, double>, double>

I will come back with some additional tests

[miscco]

Fix incorrect symbol in copied text and add some more tests

[miscco]

I really "love" arcanist. Gonna check why it is adding unrelated stuff again

[miscco]

@ldionne I added additional tests and removed the spurious character

libcxx/include/type_traits

 {
     typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
 };
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type;
 #endif
 
+#if _LIBCPP_STD_VER > 14
+template <class...> using void_t = void;
+#endif
+
+#if _LIBCPP_STD_VER > 17
+// Let COND_RES(X, Y) be:
+template <class _Tp, class _Up>
+using __cond_type = decltype(false ? _VSTD::declval<_Tp>() : _VSTD::declval<_Up>());
+
+template <class _Tp, class _Up, class = void>
+struct __common_type3 {};
+
+// sub-bullet 4 - "if COND_RES(CREF(D1), CREF(D2)) denotes a type..."
+template <class _Tp, class _Up>
+struct __common_type3<_Tp, _Up, void_t<__cond_type<const _Tp&, const _Up&>>>
+{
+    using type = remove_cvref_t<__cond_type<const _Tp&, const _Up&>>;
+};
+
+template <class _Tp, class _Up, class = void>
+struct __common_type2_imp : __common_type3<_Tp, _Up> {};
+#else
 template <class _Tp, class _Up, class = void>
 struct __common_type2_imp {};
+#endif
 
+// sub-bullet 3 - "if decay_t<decltype(false ? declval<D1>() : declval<D2>())> ..."
 template <class _Tp, class _Up>
 struct __common_type2_imp<_Tp, _Up,
                           typename __void_t<decltype(
                                             true ? _VSTD::declval<_Tp>() : _VSTD::declval<_Up>()
                                             )>::type>
 {
   typedef _LIBCPP_NODEBUG_TYPE typename decay<decltype(
                          true ? _VSTD::declval<_Tp>() : _VSTD::declval<_Up>()

 // bullet 2 - sizeof...(Tp) == 1
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS common_type<_Tp>
     : public common_type<_Tp, _Tp> {};
 
 // bullet 3 - sizeof...(Tp) == 2
 
+// sub-bullet 1 - "If is_same_v<T1, D1> is false or ..."
 template <class _Tp, class _Up>
 struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up>
     : conditional<
         _IsSame<_Tp, typename decay<_Tp>::type>::value && _IsSame<_Up, typename decay<_Up>::type>::value,
         __common_type2_imp<_Tp, _Up>,
         common_type<typename decay<_Tp>::type, typename decay<_Up>::type>
     >::type
 {};
struct __has_operator_addressof
     : public integral_constant<bool, __has_operator_addressof_member_imp<_Tp>::value
                                   || __has_operator_addressof_free_imp<_Tp>::value>
 {};
 
 #endif  // _LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER > 14
 
-template <class...> using void_t = void;
-
 template <class... _Args>
 struct conjunction : _And<_Args...> {};
 template<class... _Args>
 _LIBCPP_INLINE_VAR constexpr bool conjunction_v
     = conjunction<_Args...>::value;
 
 template <class... _Args>
 struct disjunction : _Or<_Args...> {};

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

 struct E {};
 
 template <class T>
 struct X { explicit X(T const&){} };
 
 template <class T>
 struct S { explicit S(T const&){} };
 
+template <class T>
+struct bad_reference_wrapper {
+    bad_reference_wrapper(T&);
+    bad_reference_wrapper(T&&) = delete;
+    operator T&() const;
+};
+
 namespace std
 {
     template <typename T>
     struct common_type<T, ::S<T> >
     {
         typedef S<T> type;
     };
 

 struct TernaryOp {
   static_assert((std::is_same<typename std::decay<T1>::type, T1>::value), "must be same");
   static_assert((std::is_same<typename std::decay<T2>::type, T2>::value), "must be same");
   typedef typename std::decay<
       decltype(false ? std::declval<T1>() : std::declval<T2>())
     >::type type;
 };
 
+// (4.1)
 // -- If sizeof...(T) is zero, there shall be no member type.
 void test_bullet_one() {
   static_assert(no_common_type<>::value, "");
 }
 
-// If sizeof...(T) is one, let T0 denote the sole type constituting the pack T.
-// The member typedef-name type shall denote the same type as decay_t<T0>.
+// (4.2)
+// -- If sizeof...(T) is one, let T0 denote the sole type constituting the pack
+//    T. The member typedef-name type shall denote the same type, if any, as
+//    common_type_t<T0, T0>; otherwise there shall be no member type.
 void test_bullet_two() {
   static_assert((std::is_same<std::common_type<void>::type, void>::value), "");
   static_assert((std::is_same<std::common_type<int>::type, int>::value), "");
   static_assert((std::is_same<std::common_type<int const>::type, int>::value), "");
   static_assert((std::is_same<std::common_type<int volatile[]>::type, int volatile*>::value), "");
   static_assert((std::is_same<std::common_type<void(&)()>::type, void(*)()>::value), "");
 
   static_assert((no_common_type<X<double> >::value), "");
 }
 
 template <class T, class U, class Expect>
 void test_bullet_three_one_imp() {
   typedef typename std::decay<T>::type DT;
   typedef typename std::decay<U>::type DU;
   static_assert((!std::is_same<T, DT>::value || !std::is_same<U, DU>::value), "");
   static_assert((std::is_same<typename std::common_type<T, U>::type, Expect>::value), "");
   static_assert((std::is_same<typename std::common_type<U, T>::type, Expect>::value), "");
   static_assert((std::is_same<typename std::common_type<T, U>::type, typename std::common_type<DT, DU>::type>::value), "");
 }
 
-// (3.3)
+// (4.3)
 // -- If sizeof...(T) is two, let the first and second types constituting T be
 //    denoted by T1 and T2, respectively, and let D1 and D2 denote the same types
 //    as decay_t<T1> and decay_t<T2>, respectively.
-// (3.3.1)
+// (4.3.1)
 //    -- If is_same_v<T1, D1> is false or is_same_v<T2, D2> is false, let C
 //       denote the same type, if any, as common_type_t<D1, D2>.
 void test_bullet_three_one() {
   // Test that the user provided specialization of common_type is used after
   // decaying T1.
   {
     typedef const S<int> T1;
     typedef int T2;
void test_bullet_three_one() {
   {
     typedef int const T1[];
     typedef int const* Expect;
     static_assert((std::is_same<std::common_type<T1, T1>::type, Expect>::value), "");
     static_assert((std::is_same<std::common_type<T1, T1>::type, std::common_type<T1>::type>::value), "");
   }
 }
 
-// (3.3)
+// (4.3)
 // -- If sizeof...(T) is two, let the first and second types constituting T be
 //    denoted by T1 and T2, respectively, and let D1 and D2 denote the same types
 //    as decay_t<T1> and decay_t<T2>, respectively.
-// (3.3.1)
+// (4.3.1)
 //    -- If [...]
-// (3.3.2)
-//    -- Otherwise, let C denote the same type, if any, as
+// (4.3.2)
+//    -- [Note: [...]
+// (4.3.3)
+//    -- Otherwise, if
 //       decay_t<decltype(false ? declval<D1>() : declval<D2>())>
-void test_bullet_three_two() {
+//       denotes a type, let C denote that type.
+void test_bullet_three_three() {
   {
     typedef int const* T1;
     typedef int* T2;
     typedef TernaryOp<T1, T2>::type Expect;
     static_assert((std::is_same<std::common_type<T1, T2>::type, Expect>::value), "");
     static_assert((std::is_same<std::common_type<T2, T1>::type, Expect>::value), "");
   }
   // Test that there is no ::type member when the ternary op is ill-formed
void test_bullet_three_three() {
   {
     typedef void T1;
     typedef void Expect;
     static_assert((std::is_same<std::common_type<T1, T1>::type, Expect>::value), "");
     static_assert((std::is_same<std::common_type<T1, T1>::type, std::common_type<T1>::type>::value), "");
   }
 }
 
-// (3.4)
+// (4.3)
+// -- If sizeof...(T) is two, let the first and second types constituting T be
+//    denoted by T1 and T2, respectively, and let D1 and D2 denote the same types
+//    as decay_t<T1> and decay_t<T2>, respectively.
+// (4.3.1)
+//    -- If [...]
+// (4.3.2)
+//    -- [Note: [...]
+// (4.3.3)
+//    -- Otherwise
+// (4.3.4)
+//    -- Otherwise, if COND-RES(CREF(D1), CREF(D2)) denotes a type, let C
+//       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.
 // Let C denote the same type, if any, as common_type_t<T1, T2>. If there is
 // such a type C, the member typedef-name type shall denote the
 // same type, if any, as common_type_t<C, R...>. Otherwise, there shall be
 // no member type.
 void test_bullet_four() {
   { // test that there is no ::type member
#endif
     static_assert((std::is_same<std::common_type<int, S<int> >::type, S<int> >::value), "");
     static_assert((std::is_same<std::common_type<int, S<int>, S<int> >::type, S<int> >::value), "");
     static_assert((std::is_same<std::common_type<int, int, S<int> >::type, S<int> >::value), "");
 
 
   test_bullet_one();
   test_bullet_two();
   test_bullet_three_one();
-  test_bullet_three_two();
+  test_bullet_three_three();
+  test_bullet_three_four();
   test_bullet_four();
 
 //  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), "");