[libcxx] SFINAE-friendly common_type

[K-ballo]

Summary

Implement a SFINAE-friendly common_type as per LWG2408 for the variadic case, and fixes the no-variadic case to work with void as per LWG1255.

[K-ballo]

include/type_traits

216

This patch seems to be the first to make use of __void_t. I would rather have this named __void instead as it is not an alias, would that name potentially clash?

1489

Here __common_types is used merely to carry a pack of types, very much like the existing __tuple_types. Perhaps a generic one could be introduced to replace both uses.

[K-ballo]

Updated test to work under C++03 mode

[EricWF]

LGTM as far as LWG2408. I'll look at LWG1255 tomorrow.

include/type_traits

1487

I only see 3 bullets in http://cplusplus.github.io/LWG/lwg-defects.html#2408

1496

We can skip an instantiation here and go straight to __common_type2 right?

1501–1502

Isn't there a core language defect about the following specializations being ambiguous? Something along the lines of this?

template <class ...> struct Foo;

template <class T> 
struct Foo<T> {}; // Specialization 1

template <class T, class ... Args>
struct Foo<T, Args...> {}; // Specialization 2

using MyFoo = Foo<int>; // The defect is that both 1 and 2 match.

As far as I know it is accepted by all compilers but I just wanted to bring this up.

[K-ballo]

include/type_traits

1487

That's right, the current wording with only 3 bullets regresses key functionality when it comes to user-defined specializations of common_type. The 4 bullet version was my suggestion to get the original behavior back. This is now being tracked instead by LWG2465, so we could wait for it to settle to move forward with this patch. Otherwise, I'd rather not have a sfinae-friendly result_of if that means regressing functionality.

1496

No, doing so would mean skipping over user-defined specializations of common_type

1501–1502

I'm not sure, will investigate.

[EricWF]

Just so I'm sure I understand: This implementation applies decay<T> for ever pair of types in common_type<T...> even though N2408 says decay is only applied to the final type?

include/type_traits

1478

I think we need to qualify the declval<Tp> calls so they don't use ADL.

1501–1502

I think I found the bug that tracks this: http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1432 . Could we work around it for now?

[EricWF]

Even though this in no-where close to perfect (because we don't know how to specify common_type) I think this is a strict improvement to what we have now for 3 reasons:

1. It makes common_type SFINAE friendly.
2. It properly supports common_type<void, void>
3. It properly supports user defined specializations (unlike N2408).

I'm can't decide on whether we should keep applying decay to the result of every ternary expression or adopt the new behaviour of only decaying the final result. However since this patch maintains the existing behaviour I think we should apply it until the committee comes to a consensus about what to do.

@K-ballo: Are you still willing to work on this?

include/type_traits

1453

Is it possible to make the non-variadic version SFINAE friendly as well? Or does it require expression SFINAE (which ilslikely not available)?

[K-ballo]

In D6964#164655, @EricWF wrote:

Just so I'm sure I understand: This implementation applies decay<T> for ever pair of types in common_type<T...> even though N2408 says decay is only applied to the final type?

That sounds correct. In other words, it applies as much decay and in the same places as C++11 common_type used to do.

In D6964#164665, @EricWF wrote:

@K-ballo: Are you still willing to work on this?

I am willing but time is lacking, and I'm already on my way to Lenexa. If you know how to workaround CWG1432 and want to move this patch forward quickly then don't let me hold it.

include/type_traits

1453

The implementation used in the variadic version does indeed require expression SFINAE.

1478

Good catch.

1501–1502

I'm not sure I understand how to workaround this issue. Would that just take a third non-variadic argument, say <_Tp, _Up, _Vp, Wp...>?

[EricWF]

In D6964#164887, @K-ballo wrote:

I am willing but time is lacking, and I'm already on my way to Lenexa. If you know how to workaround CWG1432 and want to move this patch forward quickly then don't let me hold it.

Right! I forgot that the US is quite a trek for you. I'll see you in Lenexa. I'm not worried about moving this quickly I just feel bad for leaving this for so long. Sorry : (

include/type_traits

1501–1502

Yeah I think that is how you work around it. However I just noticed that our current common_type has this problem and it hasn't broken yet.

[EricWF]

LGTM. I don't know why I've been putting this off for so long.

There is still some contention over weither common_type should apply "decay" to every result or just the last one. This patch applies it to every result as does the current implementation.
For that reason I think this is a strict improvement.

@K-ballo May I commit this with a couple of small changes? I want to fully qualify all of the calls to "declval<Tp>(...)".

[K-ballo]

In D6964#241105, @EricWF wrote:

@K-ballo May I commit this with a couple of small changes? I want to fully qualify all of the calls to "declval<Tp>(...)".

Please do. I have submitted bug reports in the past for pesky unqualified calls to declval.

[EricWF]

Committed in r246977. Thanks again.

include/type_traits

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 template <class...> 
 struct __void_t { typedef void type; };
 #endif
 
 template <bool _Bp, class _If, class _Then>
     struct _LIBCPP_TYPE_VIS_ONLY conditional {typedef _If type;};
 template <class _If, class _Then>
     struct _LIBCPP_TYPE_VIS_ONLY conditional<false, _If, _Then> {typedef _Then type;};
 
 #if _LIBCPP_STD_VER > 11

 {
 public:
     typedef typename decay<_Tp>::type type;
 };
 
 template <class _Tp, class _Up>
 struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up, void>
 {
-private:
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    static _Tp&& __t();
-    static _Up&& __u();
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    static _Tp __t();
-    static _Up __u();
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-public:
-    typedef typename remove_reference<decltype(true ? __t() : __u())>::type type;
+    typedef typename decay<decltype(true ? declval<_Tp>() : declval<_Up>())>::type type;
 };
 
 #else  // _LIBCPP_HAS_NO_VARIADICS
 
-template <class ..._Tp> struct common_type;
+// bullet 1 - sizeof...(Tp) == 0
+
+template <class ..._Tp>
+struct _LIBCPP_TYPE_VIS_ONLY common_type {};
+
+// bullet 2 - sizeof...(Tp) == 1
 
 template <class _Tp>
 struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp>
 {
     typedef typename decay<_Tp>::type type;
 };
 
+// bullet 3 - sizeof...(Tp) == 2
+
+template <class _Tp, class _Up, class = void>
+struct __common_type2 {};
+
 template <class _Tp, class _Up>
-struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up>
+struct __common_type2<_Tp, _Up,
+    typename __void_t<decltype(true ? declval<_Tp>() : declval<_Up>())>::type>
 {
-private:
-    static _Tp&& __t();
-    static _Up&& __u();
-    static bool __f();
-public:
-    typedef typename decay<decltype(__f() ? __t() : __u())>::type type;
+    typedef typename decay<decltype(true ? declval<_Tp>() : declval<_Up>())>::type type;
 };
 
+template <class _Tp, class _Up>
+struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up>
+    : __common_type2<_Tp, _Up> {};
+
+// bullet 4 - sizeof...(Tp) > 2
+
+template <class ...Tp> struct __common_types;
+
+template <class, class = void>
+struct __common_type_impl {};
+
 template <class _Tp, class _Up, class ..._Vp>
-struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up, _Vp...>
+struct __common_type_impl<__common_types<_Tp, _Up, _Vp...>,
+    typename __void_t<typename common_type<_Tp, _Up>::type>::type>
 {
     typedef typename common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type;
 };
 
+template <class _Tp, class _Up, class ..._Vp>
+struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up, _Vp...>
+    : __common_type_impl<__common_types<_Tp, _Up, _Vp...> > {};
+
 #if _LIBCPP_STD_VER > 11
 template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type;
 #endif
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 // is_assignable
 

test/std/utilities/meta/meta.trans/meta.trans.other/common_type.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.
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // common_type
 
 #include <type_traits>
 
+struct E {};
+
+template <class T>
+struct X { explicit X(T const&){} };
+
+template <class T>
+struct S { explicit S(T const&){} };
+
+namespace std
+{
+    template <typename T>
+    struct common_type<T, ::S<T> >
+    {
+        typedef S<T> type;
+    };
+}
+
+template <class T, class U, class = void>
+struct no_common_type : std::true_type {};
+
+template <class T, class U>
+struct no_common_type<T, U, typename std::conditional<false,
+    typename std::common_type<T, U>::type, void>::type> : std::false_type {};
+
 int main()
 {
     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 _LIBCPP_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
 
     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<int,     const int>::type, int>::value), "");
-    
     static_assert((std::is_same<std::common_type<long,       const int>::type, long>::value), "");
     static_assert((std::is_same<std::common_type<const long,       int>::type, long>::value), "");
     static_assert((std::is_same<std::common_type<long,    volatile int>::type, long>::value), "");
     static_assert((std::is_same<std::common_type<volatile long,    int>::type, long>::value), "");
     static_assert((std::is_same<std::common_type<const long, const int>::type, long>::value), "");
 
     static_assert((std::is_same<std::common_type<double, char>::type, double>::value), "");
     static_assert((std::is_same<std::common_type<short, char>::type, int>::value), "");
 #if _LIBCPP_STD_VER > 11
     static_assert((std::is_same<std::common_type_t<double, char>, double>::value), "");
     static_assert((std::is_same<std::common_type_t<short, char>, int>::value), "");
 #endif
 
     static_assert((std::is_same<std::common_type<double, char, long long>::type, double>::value), "");
     static_assert((std::is_same<std::common_type<unsigned, char, long long>::type, long long>::value), "");
 #if _LIBCPP_STD_VER > 11
     static_assert((std::is_same<std::common_type_t<double, char, long long>, double>::value), "");
     static_assert((std::is_same<std::common_type_t<unsigned, char, long long>, long long>::value), "");
 #endif
+
+    static_assert((std::is_same<std::common_type<               void>::type, void>::value), "");
+    static_assert((std::is_same<std::common_type<const          void>::type, void>::value), "");
+    static_assert((std::is_same<std::common_type<      volatile void>::type, void>::value), "");
+    static_assert((std::is_same<std::common_type<const volatile void>::type, void>::value), "");
+
+    static_assert((std::is_same<std::common_type<void,       const void>::type, void>::value), "");
+    static_assert((std::is_same<std::common_type<const void,       void>::type, void>::value), "");
+    static_assert((std::is_same<std::common_type<void,    volatile void>::type, void>::value), "");
+    static_assert((std::is_same<std::common_type<volatile void,    void>::type, void>::value), "");
+    static_assert((std::is_same<std::common_type<const void, const void>::type, void>::value), "");
+
+    static_assert((no_common_type<void, int>::value), "");
+    static_assert((no_common_type<int, void>::value), "");
+    static_assert((no_common_type<int, E>::value), "");
+    static_assert((no_common_type<int, X<int> >::value), "");
+
+    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), "");
 }