Bug fix for PR#40495 is_invokable_v<void> does not compile

[ldionne]

Summary

Add specializations of __invoke_r for "callable"s of type cv-void
Add a bunch of tests for non-callable types

[EricWF]

This doesn't address cases where any of the arguments are *cv void*. I'll take a stab at a fix tomorrow since I wrote all this metaprogramming.

[ldionne]

This seems to have been fixed in r352522. Can we close this?

[ldionne]

Fixed in

commit 011943a6e805a7666a7bff90ba27cd766bcc3a58
Author: Eric Fiselier <[e-mail]>
Date:   Tue Jan 29 18:01:14 2019 +0000

    Fix PR40495 - is_invokable_v<void> does not compile

    The meta-programming that attempted to form the invoke call expression
    was not in a SFINAE context. This made it a hard error to provide
    non-referencable types like 'void' or 'void (...) const'.

    This patch fixes the error by checking the validity of the call
    expression within a SFINAE context.

    llvm-svn: 352522

Commandeering to close.

[ldionne]

@EricWF Fixed this in 011943a6e805a7666a7bff90ba27cd766bcc3a58.

libcxx/include/type_traits

     static const bool value = type::value;
 };
 
+template <class _Ret, class ..._Args>
+struct _LIBCPP_TEMPLATE_VIS __invokable_r<_Ret,                void, _Args...> : public false_type {};
+
+template <class _Ret, class ..._Args>
+struct _LIBCPP_TEMPLATE_VIS __invokable_r<_Ret, const          void, _Args...> : public false_type {};
+
+template <class _Ret, class ..._Args>
+struct _LIBCPP_TEMPLATE_VIS __invokable_r<_Ret,       volatile void, _Args...> : public false_type {};
+
+template <class _Ret, class ..._Args>
+struct _LIBCPP_TEMPLATE_VIS __invokable_r<_Ret, const volatile void, _Args...> : public false_type {};
+
+
 template <class _Fp, class ..._Args>
 using __invokable = __invokable_r<void, _Fp, _Args...>;
 

libcxx/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp

 // Most testing of is_invocable is done within the [meta.trans.other] result_of
 // tests.
 
+// Fn and all types in the template parameter pack ArgTypes shall be 
+//  complete types, cv void, or arrays of unknown bound.
+
+
 #include <type_traits>
 #include <functional>
 #include <memory>
+#include <vector>
 
 #include "test_macros.h"
 

   int operator()(Tag) { return 42; }
 };
 
+
 int main()
 {
+//  Non-callable things
+    {
+    static_assert(!std::is_invocable<void>::value, "");
+    static_assert(!std::is_invocable<const void>::value, "");
+    static_assert(!std::is_invocable<volatile void>::value, "");
+    static_assert(!std::is_invocable<const volatile void>::value, "");
+    static_assert(!std::is_invocable<std::nullptr_t>::value, "");
+    static_assert(!std::is_invocable<int>::value, "");
+    static_assert(!std::is_invocable<double>::value, "");
+
+    static_assert(!std::is_invocable<int[]>::value, "");
+    static_assert(!std::is_invocable<int[3]>::value, "");
+
+    static_assert(!std::is_invocable<int *>::value, "");
+    static_assert(!std::is_invocable<const int *>::value, "");
+    static_assert(!std::is_invocable<int const *>::value, "");
+
+    static_assert(!std::is_invocable<int &>::value, "");
+    static_assert(!std::is_invocable<const int &>::value, "");
+    static_assert(!std::is_invocable<int &&>::value, "");
+
+    static_assert(!std::is_invocable<std::vector<int>>::value, "");
+    static_assert(!std::is_invocable<std::vector<int*>>::value, "");
+    static_assert(!std::is_invocable<std::vector<int**>>::value, "");
+
+//  with parameters
+    static_assert(!std::is_invocable<int, int>::value, "");
+    static_assert(!std::is_invocable<int, double, float>::value, "");
+    static_assert(!std::is_invocable<int, char, float, double>::value, "");
+
+
+    static_assert(!std::is_invocable_r<int, void>::value, "");
+    static_assert(!std::is_invocable_r<int, const void>::value, "");
+    static_assert(!std::is_invocable_r<int, volatile void>::value, "");
+    static_assert(!std::is_invocable_r<int, const volatile void>::value, "");
+    static_assert(!std::is_invocable_r<int, std::nullptr_t>::value, "");
+    static_assert(!std::is_invocable_r<int, int>::value, "");
+    static_assert(!std::is_invocable_r<int, double>::value, "");
+
+    static_assert(!std::is_invocable_r<int, int[]>::value, "");
+    static_assert(!std::is_invocable_r<int, int[3]>::value, "");
+
+    static_assert(!std::is_invocable_r<int, int *>::value, "");
+    static_assert(!std::is_invocable_r<int, const int *>::value, "");
+    static_assert(!std::is_invocable_r<int, int const *>::value, "");
+
+    static_assert(!std::is_invocable_r<int, int &>::value, "");
+    static_assert(!std::is_invocable_r<int, const int &>::value, "");
+    static_assert(!std::is_invocable_r<int, int &&>::value, "");
+
+    static_assert(!std::is_invocable_r<int, std::vector<int>>::value, "");
+    static_assert(!std::is_invocable_r<int, std::vector<int*>>::value, "");
+    static_assert(!std::is_invocable_r<int, std::vector<int**>>::value, "");
+
+//  with parameters
+    static_assert(!std::is_invocable_r<int, int, int>::value, "");
+    static_assert(!std::is_invocable_r<int, int, double, float>::value, "");
+    static_assert(!std::is_invocable_r<int, int, char, float, double>::value, "");
+    }
+
     {
         using Fn = int(Tag::*)(int);
         using RFn = int(Tag::*)(int) &&;

libcxx/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp

 
 #include <type_traits>
 #include <functional>
+#include <vector>
 
 #include "test_macros.h"
 

 
 int main()
 {
+//  Non-callable things
+    {
+    static_assert(!std::is_nothrow_invocable<void>::value, "");
+    static_assert(!std::is_nothrow_invocable<const void>::value, "");
+    static_assert(!std::is_nothrow_invocable<volatile void>::value, "");
+    static_assert(!std::is_nothrow_invocable<const volatile void>::value, "");
+    static_assert(!std::is_nothrow_invocable<std::nullptr_t>::value, "");
+    static_assert(!std::is_nothrow_invocable<int>::value, "");
+    static_assert(!std::is_nothrow_invocable<double>::value, "");
+
+    static_assert(!std::is_nothrow_invocable<int[]>::value, "");
+    static_assert(!std::is_nothrow_invocable<int[3]>::value, "");
+
+    static_assert(!std::is_nothrow_invocable<int *>::value, "");
+    static_assert(!std::is_nothrow_invocable<const int *>::value, "");
+    static_assert(!std::is_nothrow_invocable<int const *>::value, "");
+
+    static_assert(!std::is_nothrow_invocable<int &>::value, "");
+    static_assert(!std::is_nothrow_invocable<const int &>::value, "");
+    static_assert(!std::is_nothrow_invocable<int &&>::value, "");
+
+    static_assert(!std::is_nothrow_invocable<int, std::vector<int>>::value, "");
+    static_assert(!std::is_nothrow_invocable<int, std::vector<int*>>::value, "");
+    static_assert(!std::is_nothrow_invocable<int, std::vector<int**>>::value, "");
+
+//  with parameters
+    static_assert(!std::is_nothrow_invocable<int, int>::value, "");
+    static_assert(!std::is_nothrow_invocable<int, double, float>::value, "");
+    static_assert(!std::is_nothrow_invocable<int, char, float, double>::value, "");
+
+
+    static_assert(!std::is_nothrow_invocable_r<int, void>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, const void>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, volatile void>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, const volatile void>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, std::nullptr_t>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, int>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, double>::value, "");
+
+    static_assert(!std::is_nothrow_invocable_r<int, int[]>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, int[3]>::value, "");
+
+    static_assert(!std::is_nothrow_invocable_r<int, int *>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, const int *>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, int const *>::value, "");
+
+    static_assert(!std::is_nothrow_invocable_r<int, int &>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, const int &>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, int &&>::value, "");
+
+    static_assert(!std::is_nothrow_invocable_r<int, std::vector<int>>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, std::vector<int*>>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, std::vector<int**>>::value, "");
+
+//  with parameters
+    static_assert(!std::is_nothrow_invocable_r<int, int, int>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, int, double, float>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, int, char, float, double>::value, "");
+    }
+
     {
         // Check that the conversion to the return type is properly checked
         using Fn = CallObject<true, int>;