[libc++] Fix PR20084 - std::is_function<void() const> failed.

[EricWF]

Summary

This patch introduces some black magic to detect const and volatile qualified function types such as void () const.

The patch works in the following way:

We first rule out any type that satisfies on of the following. These restrictions are important so that the test below works properly.

• is_class<_Tp>::value
• is_union<_Tp>::value
• is_void<_Tp>::value
• is_reference<_Tp>::value
• __is_nullptr_t<_Tp>::value

If none of the above is true we perform overload resolution on __source<_Tp>(0) to determine the return type.

• If _Tp& is well-formed we select _Tp& __source(int). _Tp& is only ill formed for cv void types and cv/ref qualified function types.
• Otherwise we select __dummy_type __source(...). Since we know _Tp cannot be void then it must be a function type.

let R be the returned from __source<_Tp>(0).
We perform overload resolution on __test<_Tp>(R).

• If R is __dummy_type we call true_type __test(__dummy_type).
• if R is _Tp& and _Tp& decays to _Tp* we call true_type __test(_Tp*). Only references to function types decay to a pointer of the same type.
• In all other cases we call false_type __test(...).

__source<_Tp>(0) will try and form _Tp& in the return type. if _Tp& is not well formed the return type of __source<_Tp>(0) will be dummy type. _Tp& is only ill-formed for cv/ref qualified function types (and void which is dealt with elsewhere).

This fixes PR20084 - http://llvm.org/bugs/show_bug.cgi?id=20084

[rsmith]

include/type_traits

434–438

Makes sense to me ;-) Though I'd use __source(...) as a more "canonical" way of writing a less-preferred overload, as we do in the declaration of __test.

We'll use the __dummy_type path for both cv-/ref-qualified function types and for void, but it looks like we're handling the void case in __libcpp_is_function, so that's OK.

[EricWF]

Add an explanation of the patch to the description and address richards inline comments.

include/type_traits

434–438

Why is it that you can't form a reference to a cv/ref qualified function type? Could you point me to the standard. Thanks for the review!

[rsmith]

include/type_traits

434–438

There are no values of those types; they exist only so that member functions can be declared and pointer-to-member types can be written. The relevant rule is in [dcl.fct](8.3.5)/6 in the current draft.

[EricWF]

Address Richard's comments and remove extra tests that were added to function.pass.cpp (that is tested elsewhere).

[mclow.lists]

There are 12 different qualifiers that can go on functions.

const
volatile
&
&&

Since & and && are mutually exclusive, that leaves 12 different possibilities.
I only see tests for four here.

I'd love a remove_qualifiers type trait that took a function type and returned the unqualified type. That would be useful in several places; but the only way I've figured out how to do it involves tons of specializations (and even more for the non-variadic compilers).

[EricWF]

In D7573#124869, @mclow.lists wrote:

There are 12 different qualifiers that can go on functions.

const
volatile
&
&&

Since & and && are mutually exclusive, that leaves 12 different possibilities.
I only see tests for four here.

TEST_REGULAR(...) Should test all of the non-reference qualified possibilities.
TEST_REF_QUALIFIED(...) Should test all of the reference qualified ones.

What am I missing?

I'd love a remove_qualifiers type trait that took a function type and returned the unqualified type. That would be useful in several places; but the only way I've figured out how to do it involves tons of specializations (and even more for the non-variadic compilers).

I agree, I'll see what I can do but I don't think that should hold this up.

[mclow.lists]

Look at __member_pointer_traits_imp for a crappy way to do it.

Also, I'm not sure if std::function<void (int, ...) const>, is even legal, but if it is, that's more work.

[mclow.lists]

My bad; I missed that in the tests.

[eric_niebler]

I just ran into this problem while trying to get range-v3 working on clang-3.6. This is_function implementation probably instantiates fewer templates than the version currently shipping with libc++. Disclaimer: I haven't tested it exhaustively yet.

template<int I>
struct priority_tag
    : priority_tag<I - 1>
{};

template<>
struct priority_tag<0>
{};

// Function types here:
template<typename T>
char (&is_function_impl_(priority_tag<0>))[1];

// Array types here:
template<typename T, typename = decltype((*(T*)0)[0])>
char (&is_function_impl_(priority_tag<1>))[2];

// Anything that can be returned from a function here (including
// void and reference types):
template<typename T, typename = T(*)()>
char (&is_function_impl_(priority_tag<2>))[3];

// Classes and unions (including abstract types) here:
template<typename T, typename = int T::*>
char (&is_function_impl_(priority_tag<3>))[4];

template <typename T>
struct is_function
    : integral_constant<bool, sizeof(is_function_impl_<T>(priority_tag<3>{})) == 1>
{};

include/type_traits

 
 namespace __libcpp_is_function_imp
 {
+struct __dummy_type {};
 template <class _Tp> char  __test(_Tp*);
+template <class _Tp> char __test(__dummy_type);
 template <class _Tp> __two __test(...);
-template <class _Tp> _Tp&  __source();
+template <class _Tp> _Tp&  __source(int);
+template <class _Tp> __dummy_type __source(long);
 }
 
 template <class _Tp, bool = is_class<_Tp>::value ||

                             is_reference<_Tp>::value ||
                             __is_nullptr_t<_Tp>::value >
 struct __libcpp_is_function
-    : public integral_constant<bool, sizeof(__libcpp_is_function_imp::__test<_Tp>(__libcpp_is_function_imp::__source<_Tp>())) == 1>
+    : public integral_constant<bool, sizeof(__libcpp_is_function_imp::__test<_Tp>(__libcpp_is_function_imp::__source<_Tp>(0))) == 1>
     {};
 template <class _Tp> struct __libcpp_is_function<_Tp, true> : public false_type {};
 

test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp

 
 #include <type_traits>
 
+using namespace std;
+
+class Class {};
+
+enum Enum1 {};
+#if __cplusplus >= 201103L
+enum class Enum2 : int {};
+#else
+enum Enum2 {};
+#endif
+
 template <class T>
-void test_function_imp()
+void test()
 {
     static_assert(!std::is_void<T>::value, "");
 #if _LIBCPP_STD_VER > 11

     static_assert( std::is_function<T>::value, "");
 }
 
+// This function checks that we actually get to the SFINAE test in
+// __libcpp_is_function and check that it fails.
 template <class T>
-void test_function()
+void test_sfinae_failure()
 {
-    test_function_imp<T>();
-    test_function_imp<const T>();
-    test_function_imp<volatile T>();
-    test_function_imp<const volatile T>();
+    // Check that we get the overload of __libcpp_is_function that
+    // evaluates the sfinae
+    static_assert(!std::is_class<T>::value, "");
+    static_assert(!std::is_union<T>::value, "");
+    static_assert(!std::is_void<T>::value, "");
+    static_assert(!std::is_reference<T>::value, "");
+    static_assert(!std::__is_nullptr_t<T>::value, "");
+    // Check that the trait actually works
+    static_assert(!std::is_function<T>::value, "");
 }
 
+// Since we can't actually add the const volatile and ref qualifiers once
+// later let's use a macro to do it.
+#define TEST_REGULAR(...)                 \
+    test<__VA_ARGS__>();                  \
+    test<__VA_ARGS__ const>();            \
+    test<__VA_ARGS__ volatile>();         \
+    test<__VA_ARGS__ const volatile>()
+
+#define TEST_REF_QUALIFIED(...)           \
+    test<__VA_ARGS__ &>();                \
+    test<__VA_ARGS__ const &>();          \
+    test<__VA_ARGS__ volatile &>();       \
+    test<__VA_ARGS__ const volatile &>(); \
+    test<__VA_ARGS__ &&>();               \
+    test<__VA_ARGS__ const &&>();         \
+    test<__VA_ARGS__ volatile &&>();      \
+    test<__VA_ARGS__ const volatile &&>()
+
+#define TEST_SFINAE_FAILURE(...)                       \
+    test_sfinae_failure<__VA_ARGS__>();                \
+    test_sfinae_failure<__VA_ARGS__ const>();          \
+    test_sfinae_failure<__VA_ARGS__ volatile>();       \
+    test_sfinae_failure<__VA_ARGS__ const volatile>()
+
+#define TEST_MEM_FN_REF(...)                               \
+    test_sfinae_failure<__VA_ARGS__ &>();                  \
+    test_sfinae_failure<__VA_ARGS__ const &>();            \
+    test_sfinae_failure<__VA_ARGS__ volatile &>();         \
+    test_sfinae_failure<__VA_ARGS__ const volatile &>();   \
+    test_sfinae_failure<__VA_ARGS__ &&>();                 \
+    test_sfinae_failure<__VA_ARGS__ const &&>();           \
+    test_sfinae_failure<__VA_ARGS__ volatile &&>();        \
+    test_sfinae_failure<__VA_ARGS__ const volatile &&>()
+
 int main()
 {
-    test_function<void ()>();
-    test_function<void (int)>();
-    test_function<int (double)>();
-    test_function<int (double, char)>();
+    TEST_REGULAR( void () );
+    TEST_REGULAR( void (int) );
+    TEST_REGULAR( int (double) );
+    TEST_REGULAR( int (double, char) );
+    TEST_REGULAR( void (...) );
+    TEST_REGULAR( void (int, ...) );
+    TEST_REGULAR( int (double, ...) );
+    TEST_REGULAR( int (double, char, ...) );
+#if __cplusplus >= 201103L
+    TEST_REF_QUALIFIED( void () );
+    TEST_REF_QUALIFIED( void (int) );
+    TEST_REF_QUALIFIED( int (double) );
+    TEST_REF_QUALIFIED( int (double, char) );
+    TEST_REF_QUALIFIED( void (...) );
+    TEST_REF_QUALIFIED( void (int, ...) );
+    TEST_REF_QUALIFIED( int (double, ...) );
+    TEST_REF_QUALIFIED( int (double, char, ...) );
+#endif
+
+    TEST_SFINAE_FAILURE( int );
+    TEST_SFINAE_FAILURE( int* );
+    TEST_SFINAE_FAILURE( int const* );
+    TEST_SFINAE_FAILURE( int volatile* );
+    TEST_SFINAE_FAILURE( int const volatile* );
+    TEST_SFINAE_FAILURE( void* );
+    TEST_SFINAE_FAILURE( Enum1 );
+    TEST_SFINAE_FAILURE( Enum1* );
+    TEST_SFINAE_FAILURE( Enum2 );
+    TEST_SFINAE_FAILURE( Enum2* );
+
+    TEST_SFINAE_FAILURE( void (Class::*)() );
+    TEST_SFINAE_FAILURE( void (Class::*)(int) );
+    TEST_SFINAE_FAILURE( int (Class::*)(double) );
+    TEST_SFINAE_FAILURE( int (Class::*)(double, char) );
+    TEST_SFINAE_FAILURE( void (Class::*)(...) );
+    TEST_SFINAE_FAILURE( void (Class::*)(int, ...) );
+    TEST_SFINAE_FAILURE( int (Class::*)(double, ...) );
+    TEST_SFINAE_FAILURE( int (Class::*)(double, char, ...) );
+#if __cplusplus >= 201103L
+    TEST_MEM_FN_REF( void (Class::*)() );
+    TEST_MEM_FN_REF( void (Class::*)(int) );
+    TEST_MEM_FN_REF( int (Class::*)(double) );
+    TEST_MEM_FN_REF( int (Class::*)(double, char) );
+    TEST_MEM_FN_REF( void (Class::*)(...) );
+    TEST_MEM_FN_REF( void (Class::*)(int, ...) );
+    TEST_MEM_FN_REF( int (Class::*)(double, ...) );
+    TEST_MEM_FN_REF( int (Class::*)(double, char, ...) );
+#endif
 }