Index: libcxx/include/type_traits
===================================================================
--- libcxx/include/type_traits
+++ libcxx/include/type_traits
@@ -4382,6 +4382,19 @@
     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...>;
 
Index: libcxx/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
===================================================================
--- libcxx/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
+++ libcxx/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
@@ -15,9 +15,14 @@
 // 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"
 
@@ -37,8 +42,69 @@
   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) &&;
Index: libcxx/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
===================================================================
--- libcxx/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
+++ libcxx/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
@@ -14,6 +14,7 @@
 
 #include <type_traits>
 #include <functional>
+#include <vector>
 
 #include "test_macros.h"
 
@@ -73,6 +74,66 @@
 
 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>;