[libcxx] P0604, invoke_result and is_invocable

[K-ballo]

Summary

Introduce a new form of result_of without function type encoding.

Rename and split is_callable/is_nothrow_callable into is_invocable/is_nothrow_invocable/is_invocable_r/is_nothrow_invocable_r (and associated types accordingly)

Change function type encoding of previous is_callable/is_nothrow_callable traits to conventional template type parameter lists.

[K-ballo]

Fix synopsis

[EricWF]

LGTM. Thanks.

@K-ballo I always forget. Do you have commit access?

[K-ballo]

In D38831#917439, @EricWF wrote:

@K-ballo I always forget. Do you have commit access?

I do not. It's all yours.

[bebuch]

Please commit!

[lichray]

[...]test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp:118:9: error: static_assert failed due to requirement '!std::is_nothrow_invocable_r_v<int, Fn>' ""
        static_assert(!std::is_nothrow_invocable_r_v<int, Fn>, "");
        ^             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 error generated.
--

with Clang-5.0 and trunk. Can you reproduce?

[K-ballo]

In D38831#952228, @lichray wrote:

[...]test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp:118:9: error: static_assert failed due to requirement '!std::is_nothrow_invocable_r_v<int, Fn>' ""
        static_assert(!std::is_nothrow_invocable_r_v<int, Fn>, "");
        ^             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 error generated.
--

with Clang-5.0 and trunk. Can you reproduce?

I can reproduce.

It seems the intention was to match the tests from the previous section, so an extra int argument would be missing. I'll take care of it.

[K-ballo]

Fixed incorrect test case.

[lichray]

That commit message generated from arc wasn't all that friendly :/
Thanks for the patch, and @K-ballo you should ask Chris for a commit bit :)

[K-ballo]

Thanks @lichray

include/type_traits

namespace std
 
     template <class T> struct has_virtual_destructor;
 
     // Relationships between types:
     template <class T, class U> struct is_same;
     template <class Base, class Derived> struct is_base_of;
     template <class From, class To> struct is_convertible;
 
-    template <class, class R = void> struct is_callable; // not defined
-    template <class Fn, class... ArgTypes, class R>
-      struct is_callable<Fn(ArgTypes...), R>;
-
-    template <class, class R = void> struct is_nothrow_callable; // not defined
-    template <class Fn, class... ArgTypes, class R>
-      struct is_nothrow_callable<Fn(ArgTypes...), R>;
+    template <class Fn, class... ArgTypes> struct is_invocable;
+    template <class R, class Fn, class... ArgTypes> struct is_invocable_r;
+
+    template <class Fn, class... ArgTypes> struct is_nothrow_invocable;
+    template <class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;
 
     // Alignment properties and transformations:
     template <class T> struct alignment_of;
     template <size_t Len, size_t Align = most_stringent_alignment_requirement>
         struct aligned_storage;
     template <size_t Len, class... Types> struct aligned_union;
     template <class T> struct remove_cvref; // C++20
 
     template <class T> struct decay;
     template <class... T> struct common_type;
     template <class T> struct underlying_type;
     template <class> class result_of; // undefined
     template <class Fn, class... ArgTypes> class result_of<Fn(ArgTypes...)>;
+    template <class Fn, class... ArgTypes> struct invoke_result;  // C++17
 
     // const-volatile modifications:
     template <class T>
       using remove_const_t    = typename remove_const<T>::type;  // C++14
     template <class T>
       using remove_volatile_t = typename remove_volatile<T>::type;  // C++14
     template <class T>
       using remove_cv_t       = typename remove_cv<T>::type;  // C++14
namespace std
     template <bool b, class T=void>
       using enable_if_t       = typename enable_if<b,T>::type;  // C++14
     template <bool b, class T, class F>
       using conditional_t     = typename conditional<b,T,F>::type;  // C++14
     template <class... T>
       using common_type_t     = typename common_type<T...>::type;  // C++14
     template <class T>
       using underlying_type_t = typename underlying_type<T>::type;  // C++14
-    template <class F, class... ArgTypes>
-      using result_of_t       = typename result_of<F(ArgTypes...)>::type;  // C++14
+    template <class T>
+      using result_of_t       = typename result_of<T>::type;  // C++14
+    template <class Fn, class... ArgTypes>
+      using invoke_result_t   = typename invoke_result<Fn, ArgTypes...>::type;  // C++17
 
     template <class...>
       using void_t = void;   // C++17
       
       // See C++14 20.10.4.1, primary type categories
       template <class T> constexpr bool is_void_v
         = is_void<T>::value;                                             // C++17
       template <class T> constexpr bool is_null_pointer_v
template <class...>
 
       // See C++14 20.10.6, type relations
       template <class T, class U> constexpr bool is_same_v
         = is_same<T, U>::value;                                          // C++17
       template <class Base, class Derived> constexpr bool is_base_of_v
         = is_base_of<Base, Derived>::value;                              // C++17
       template <class From, class To> constexpr bool is_convertible_v
         = is_convertible<From, To>::value;                               // C++17
-      template <class T, class R = void> constexpr bool is_callable_v
-        = is_callable<T, R>::value;                                      // C++17
-      template <class T, class R = void> constexpr bool is_nothrow_callable_v
-        = is_nothrow_callable<T, R>::value;                              // C++17
+      template <class Fn, class... ArgTypes> constexpr bool is_invocable_v
+        = is_invocable<Fn, ArgTypes...>::value;                          // C++17
+      template <class R, class Fn, class... ArgTypes> constexpr bool is_invocable_r_v
+        = is_invocable_r<R, Fn, ArgTypes...>::value;                     // C++17
+      template <class Fn, class... ArgTypes> constexpr bool is_nothrow_invocable_v
+        = is_nothrow_invocable<Fn, ArgTypes...>::value;                  // C++17
+      template <class R, class Fn, class... ArgTypes> constexpr bool is_nothrow_invocable_r_v
+        = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;             // C++17
 
       // [meta.logical], logical operator traits:
       template<class... B> struct conjunction;                           // C++17
       template<class... B> 
         constexpr bool conjunction_v = conjunction<B...>::value;         // C++17
       template<class... B> struct disjunction;                           // C++17
       template<class... B>
         constexpr bool disjunction_v = disjunction<B...>::value;         // C++17

 using __nothrow_invokable_r =
     __nothrow_invokable_r_imp<
             __invokable_r<_Ret, _Fp, _Args...>::value,
             is_void<_Ret>::value,
             _Ret, _Fp, _Args...
     >;
 
 template <class _Fp, class ..._Args>
+using __nothrow_invokable =
+    __nothrow_invokable_r_imp<
+            __invokable<_Fp, _Args...>::value,
+            true, void, _Fp, _Args...
+    >;
+
+template <class _Fp, class ..._Args>
 struct __invoke_of
     : public enable_if<
         __invokable<_Fp, _Args...>::value,
         typename __invokable_r<void, _Fp, _Args...>::_Result>
 {
 };
 
 // result_of
 
 template <class _Fp, class ..._Args>
 class _LIBCPP_TEMPLATE_VIS result_of<_Fp(_Args...)>
     : public __invoke_of<_Fp, _Args...>
 {
 };
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using result_of_t = typename result_of<_Tp>::type;
 #endif
 
 #if _LIBCPP_STD_VER > 14
 
-// is_callable
+// invoke_result
 
-template <class _Fn, class _Ret = void>
-struct _LIBCPP_TEMPLATE_VIS is_callable;
+template <class _Fn, class... _Args>
+struct _LIBCPP_TEMPLATE_VIS invoke_result
+    : __invoke_of<_Fn, _Args...>
+{
+};
+
+template <class _Fn, class... _Args>
+using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
+
+// is_invocable
 
-template <class _Fn, class ..._Args, class _Ret>
-struct _LIBCPP_TEMPLATE_VIS is_callable<_Fn(_Args...), _Ret>
+template <class _Fn, class ..._Args>
+struct _LIBCPP_TEMPLATE_VIS is_invocable
+    : integral_constant<bool, __invokable<_Fn, _Args...>::value> {};
+
+template <class _Ret, class _Fn, class ..._Args>
+struct _LIBCPP_TEMPLATE_VIS is_invocable_r
     : integral_constant<bool, __invokable_r<_Ret, _Fn, _Args...>::value> {};
 
-template <class _Fn, class _Ret = void>
-constexpr bool is_callable_v = is_callable<_Fn, _Ret>::value;
+template <class _Fn, class ..._Args>
+constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
+
+template <class _Ret, class _Fn, class ..._Args>
+constexpr bool is_invocable_r_v = is_invocable_r<_Ret, _Fn, _Args...>::value;
 
 // is_nothrow_callable
 
-template <class _Fn, class _Ret = void>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_callable;
+template <class _Fn, class ..._Args>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable
+    : integral_constant<bool, __nothrow_invokable<_Fn, _Args...>::value> {};
+
+template <class _Ret, class _Fn, class ..._Args>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable_r
+    : integral_constant<bool, __nothrow_invokable_r<_Ret, _Fn, _Args...>::value> {};
 
-template <class _Fn, class ..._Args, class _Ret>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_callable<_Fn(_Args...), _Ret>
-    : integral_constant<bool, __nothrow_invokable_r<_Ret, _Fn, _Args...>::value>
-{};
+template <class _Fn, class ..._Args>
+constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<_Fn, _Args...>::value;
 
-template <class _Fn, class _Ret = void>
-constexpr bool is_nothrow_callable_v = is_nothrow_callable<_Fn, _Ret>::value;
+template <class _Ret, class _Fn, class ..._Args>
+constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;
 
 #endif // _LIBCPP_STD_VER > 14
 
 #endif  // !defined(_LIBCPP_CXX03_LANG)
 
 template <class _Tp> struct __is_swappable;
 template <class _Tp> struct __is_nothrow_swappable;
 

include/variant

static constexpr decltype(auto) __visit_value(_Visitor&& __visitor,
     return __visit_alt(
         __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
         _VSTD::forward<_Vs>(__vs)...);
   }
 
 private:
   template <class _Visitor, class... _Values>
   static constexpr void __std_visit_exhaustive_visitor_check() {
-    static_assert(is_callable_v<_Visitor(_Values...)>,
+    static_assert(is_invocable_v<_Visitor, _Values...>,
                   "`std::visit` requires the visitor to be exhaustive.");
   }
 
   template <class _Visitor>
   struct __value_visitor {
     template <class... _Alts>
     inline _LIBCPP_INLINE_VISIBILITY
     constexpr decltype(auto) operator()(_Alts&&... __alts) const {

test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp

#endif
         }
     }
 #endif
 }
 
 void call_operator_sfinae_test() {
     { // wrong number of arguments
         using T = decltype(std::not_fn(returns_true));
-        static_assert(std::is_callable<T()>::value, ""); // callable only with no args
-        static_assert(!std::is_callable<T(bool)>::value, "");
+        static_assert(std::is_invocable<T>::value, ""); // callable only with no args
+        static_assert(!std::is_invocable<T, bool>::value, "");
     }
     { // violates const correctness (member function pointer)
         using T = decltype(std::not_fn(&MemFunCallable::return_value_nc));
-        static_assert(std::is_callable<T(MemFunCallable&)>::value, "");
-        static_assert(!std::is_callable<T(const MemFunCallable&)>::value, "");
+        static_assert(std::is_invocable<T, MemFunCallable&>::value, "");
+        static_assert(!std::is_invocable<T, const MemFunCallable&>::value, "");
     }
     { // violates const correctness (call object)
         using Obj = CopyCallable<bool>;
         using NCT = decltype(std::not_fn(Obj{true}));
         using CT = const NCT;
-        static_assert(std::is_callable<NCT()>::value, "");
-        static_assert(!std::is_callable<CT()>::value, "");
+        static_assert(std::is_invocable<NCT>::value, "");
+        static_assert(!std::is_invocable<CT>::value, "");
     }
     { // returns bad type with no operator!
         auto fn = [](auto x) { return x; };
         using T = decltype(std::not_fn(fn));
-        static_assert(std::is_callable<T(bool)>::value, "");
-        static_assert(!std::is_callable<T(std::string)>::value, "");
+        static_assert(std::is_invocable<T, bool>::value, "");
+        static_assert(!std::is_invocable<T, std::string>::value, "");
     }
 }
 
 void call_operator_forwarding_test()
 {
     using Fn = ForwardingCallObject;
     auto obj = std::not_fn(Fn{});
     const auto& c_obj = obj;

test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp

 {
     using H = std::hash<X>;
     static_assert(!std::is_default_constructible<H>::value, "");
     static_assert(!std::is_copy_constructible<H>::value, "");
     static_assert(!std::is_move_constructible<H>::value, "");
     static_assert(!std::is_copy_assignable<H>::value, "");
     static_assert(!std::is_move_assignable<H>::value, "");
 #if TEST_STD_VER > 14
-    static_assert(!std::is_callable<H(X&)>::value, "");
-    static_assert(!std::is_callable<H(X const&)>::value, "");
+    static_assert(!std::is_invocable<H, X&>::value, "");
+    static_assert(!std::is_invocable<H, X const&>::value, "");
 #endif
 }

test/std/utilities/meta/meta.rel/is_callable.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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-
-// type_traits
-
-// is_callable
-
-// Most testing of is_callable is done within the [meta.trans.other] result_of
-// tests.
-
-#include <type_traits>
-#include <functional>
-#include <memory>
-
-#include "test_macros.h"
-
-struct Tag {};
-struct DerFromTag : Tag {};
-
-struct Implicit {
-  Implicit(int) {}
-};
-
-struct Explicit {
-  explicit Explicit(int) {}
-};
-
-struct NotCallableWithInt {
-  int operator()(int) = delete;
-  int operator()(Tag) { return 42; }
-};
-
-int main()
-{
-    {
-        using Fn = int(Tag::*)(int);
-        using RFn = int(Tag::*)(int) &&;
-        // INVOKE bullet 1, 2 and 3
-        {
-            // Bullet 1
-            static_assert(std::is_callable<Fn(Tag&, int)>::value, "");
-            static_assert(std::is_callable<Fn(DerFromTag&, int)>::value, "");
-            static_assert(std::is_callable<RFn(Tag&&, int)>::value, "");
-            static_assert(!std::is_callable<RFn(Tag&, int)>::value, "");
-            static_assert(!std::is_callable<Fn(Tag&)>::value, "");
-            static_assert(!std::is_callable<Fn(Tag const&, int)>::value, "");
-        }
-        {
-            // Bullet 2
-            using T = std::reference_wrapper<Tag>;
-            using DT = std::reference_wrapper<DerFromTag>;
-            using CT = std::reference_wrapper<const Tag>;
-            static_assert(std::is_callable<Fn(T&, int)>::value, "");
-            static_assert(std::is_callable<Fn(DT&, int)>::value, "");
-            static_assert(std::is_callable<Fn(const T&, int)>::value, "");
-            static_assert(std::is_callable<Fn(T&&, int)>::value, "");
-            static_assert(!std::is_callable<Fn(CT&, int)>::value, "");
-            static_assert(!std::is_callable<RFn(T, int)>::value, "");
-        }
-        {
-            // Bullet 3
-            using T = Tag*;
-            using DT = DerFromTag*;
-            using CT = const Tag*;
-            using ST = std::unique_ptr<Tag>;
-            static_assert(std::is_callable<Fn(T&, int)>::value, "");
-            static_assert(std::is_callable<Fn(DT&, int)>::value, "");
-            static_assert(std::is_callable<Fn(const T&, int)>::value, "");
-            static_assert(std::is_callable<Fn(T&&, int)>::value, "");
-            static_assert(std::is_callable<Fn(ST, int)>::value, "");
-            static_assert(!std::is_callable<Fn(CT&, int)>::value, "");
-            static_assert(!std::is_callable<RFn(T, int)>::value, "");
-        }
-    }
-    {
-        // Bullets 4, 5 and 6
-        using Fn = int (Tag::*);
-        static_assert(!std::is_callable<Fn()>::value, "");
-        {
-            // Bullet 4
-            static_assert(std::is_callable<Fn(Tag&)>::value, "");
-            static_assert(std::is_callable<Fn(DerFromTag&)>::value, "");
-            static_assert(std::is_callable<Fn(Tag&&)>::value, "");
-            static_assert(std::is_callable<Fn(Tag const&)>::value, "");
-        }
-        {
-            // Bullet 5
-            using T = std::reference_wrapper<Tag>;
-            using DT = std::reference_wrapper<DerFromTag>;
-            using CT = std::reference_wrapper<const Tag>;
-            static_assert(std::is_callable<Fn(T&)>::value, "");
-            static_assert(std::is_callable<Fn(DT&)>::value, "");
-            static_assert(std::is_callable<Fn(const T&)>::value, "");
-            static_assert(std::is_callable<Fn(T&&)>::value, "");
-            static_assert(std::is_callable<Fn(CT&)>::value, "");
-        }
-        {
-            // Bullet 6
-            using T = Tag*;
-            using DT = DerFromTag*;
-            using CT = const Tag*;
-            using ST = std::unique_ptr<Tag>;
-            static_assert(std::is_callable<Fn(T&)>::value, "");
-            static_assert(std::is_callable<Fn(DT&)>::value, "");
-            static_assert(std::is_callable<Fn(const T&)>::value, "");
-            static_assert(std::is_callable<Fn(T&&)>::value, "");
-            static_assert(std::is_callable<Fn(ST)>::value, "");
-            static_assert(std::is_callable<Fn(CT&)>::value, "");
-        }
-    }
-    {
-        // INVOKE bullet 7
-        {
-            // Function pointer
-            using Fp = void(*)(Tag&, int);
-            static_assert(std::is_callable<Fp(Tag&, int)>::value, "");
-            static_assert(std::is_callable<Fp(DerFromTag&, int)>::value, "");
-            static_assert(!std::is_callable<Fp(const Tag&, int)>::value, "");
-            static_assert(!std::is_callable<Fp()>::value, "");
-            static_assert(!std::is_callable<Fp(Tag&)>::value, "");
-        }
-        {
-            // Function reference
-            using Fp = void(&)(Tag&, int);
-            static_assert(std::is_callable<Fp(Tag&, int)>::value, "");
-            static_assert(std::is_callable<Fp(DerFromTag&, int)>::value, "");
-            static_assert(!std::is_callable<Fp(const Tag&, int)>::value, "");
-            static_assert(!std::is_callable<Fp()>::value, "");
-            static_assert(!std::is_callable<Fp(Tag&)>::value, "");
-        }
-        {
-            // Function object
-            using Fn = NotCallableWithInt;
-            static_assert(std::is_callable<Fn(Tag)>::value, "");
-            static_assert(!std::is_callable<Fn(int)>::value, "");
-        }
-    }
-    {
-        // Check that the conversion to the return type is properly checked
-        using Fn = int(*)();
-        static_assert(std::is_callable<Fn(), Implicit>::value, "");
-        static_assert(std::is_callable<Fn(), double>::value, "");
-        static_assert(std::is_callable<Fn(), const volatile void>::value, "");
-        static_assert(!std::is_callable<Fn(), Explicit>::value, "");
-    }
-    {
-        // Check for is_callable_v
-        using Fn = void(*)();
-        static_assert(std::is_callable_v<Fn()>, "");
-        static_assert(!std::is_callable_v<Fn(int)>, "");
-    }
-}

test/std/utilities/meta/meta.rel/is_invocable.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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// type_traits
+
+// is_invocable
+
+// Most testing of is_invocable is done within the [meta.trans.other] result_of
+// tests.
+
+#include <type_traits>
+#include <functional>
+#include <memory>
+
+#include "test_macros.h"
+
+struct Tag {};
+struct DerFromTag : Tag {};
+
+struct Implicit {
+  Implicit(int) {}
+};
+
+struct Explicit {
+  explicit Explicit(int) {}
+};
+
+struct NotCallableWithInt {
+  int operator()(int) = delete;
+  int operator()(Tag) { return 42; }
+};
+
+int main()
+{
+    {
+        using Fn = int(Tag::*)(int);
+        using RFn = int(Tag::*)(int) &&;
+        // INVOKE bullet 1, 2 and 3
+        {
+            // Bullet 1
+            static_assert(std::is_invocable<Fn, Tag&, int>::value, "");
+            static_assert(std::is_invocable<Fn, DerFromTag&, int>::value, "");
+            static_assert(std::is_invocable<RFn, Tag&&, int>::value, "");
+            static_assert(!std::is_invocable<RFn, Tag&, int>::value, "");
+            static_assert(!std::is_invocable<Fn, Tag&>::value, "");
+            static_assert(!std::is_invocable<Fn, Tag const&, int>::value, "");
+        }
+        {
+            // Bullet 2
+            using T = std::reference_wrapper<Tag>;
+            using DT = std::reference_wrapper<DerFromTag>;
+            using CT = std::reference_wrapper<const Tag>;
+            static_assert(std::is_invocable<Fn, T&, int>::value, "");
+            static_assert(std::is_invocable<Fn, DT&, int>::value, "");
+            static_assert(std::is_invocable<Fn, const T&, int>::value, "");
+            static_assert(std::is_invocable<Fn, T&&, int>::value, "");
+            static_assert(!std::is_invocable<Fn, CT&, int>::value, "");
+            static_assert(!std::is_invocable<RFn, T, int>::value, "");
+        }
+        {
+            // Bullet 3
+            using T = Tag*;
+            using DT = DerFromTag*;
+            using CT = const Tag*;
+            using ST = std::unique_ptr<Tag>;
+            static_assert(std::is_invocable<Fn, T&, int>::value, "");
+            static_assert(std::is_invocable<Fn, DT&, int>::value, "");
+            static_assert(std::is_invocable<Fn, const T&, int>::value, "");
+            static_assert(std::is_invocable<Fn, T&&, int>::value, "");
+            static_assert(std::is_invocable<Fn, ST, int>::value, "");
+            static_assert(!std::is_invocable<Fn, CT&, int>::value, "");
+            static_assert(!std::is_invocable<RFn, T, int>::value, "");
+        }
+    }
+    {
+        // Bullets 4, 5 and 6
+        using Fn = int (Tag::*);
+        static_assert(!std::is_invocable<Fn>::value, "");
+        {
+            // Bullet 4
+            static_assert(std::is_invocable<Fn, Tag&>::value, "");
+            static_assert(std::is_invocable<Fn, DerFromTag&>::value, "");
+            static_assert(std::is_invocable<Fn, Tag&&>::value, "");
+            static_assert(std::is_invocable<Fn, Tag const&>::value, "");
+        }
+        {
+            // Bullet 5
+            using T = std::reference_wrapper<Tag>;
+            using DT = std::reference_wrapper<DerFromTag>;
+            using CT = std::reference_wrapper<const Tag>;
+            static_assert(std::is_invocable<Fn, T&>::value, "");
+            static_assert(std::is_invocable<Fn, DT&>::value, "");
+            static_assert(std::is_invocable<Fn, const T&>::value, "");
+            static_assert(std::is_invocable<Fn, T&&>::value, "");
+            static_assert(std::is_invocable<Fn, CT&>::value, "");
+        }
+        {
+            // Bullet 6
+            using T = Tag*;
+            using DT = DerFromTag*;
+            using CT = const Tag*;
+            using ST = std::unique_ptr<Tag>;
+            static_assert(std::is_invocable<Fn, T&>::value, "");
+            static_assert(std::is_invocable<Fn, DT&>::value, "");
+            static_assert(std::is_invocable<Fn, const T&>::value, "");
+            static_assert(std::is_invocable<Fn, T&&>::value, "");
+            static_assert(std::is_invocable<Fn, ST>::value, "");
+            static_assert(std::is_invocable<Fn, CT&>::value, "");
+        }
+    }
+    {
+        // INVOKE bullet 7
+        {
+            // Function pointer
+            using Fp = void(*)(Tag&, int);
+            static_assert(std::is_invocable<Fp, Tag&, int>::value, "");
+            static_assert(std::is_invocable<Fp, DerFromTag&, int>::value, "");
+            static_assert(!std::is_invocable<Fp, const Tag&, int>::value, "");
+            static_assert(!std::is_invocable<Fp>::value, "");
+            static_assert(!std::is_invocable<Fp, Tag&>::value, "");
+        }
+        {
+            // Function reference
+            using Fp = void(&)(Tag&, int);
+            static_assert(std::is_invocable<Fp, Tag&, int>::value, "");
+            static_assert(std::is_invocable<Fp, DerFromTag&, int>::value, "");
+            static_assert(!std::is_invocable<Fp, const Tag&, int>::value, "");
+            static_assert(!std::is_invocable<Fp>::value, "");
+            static_assert(!std::is_invocable<Fp, Tag&>::value, "");
+        }
+        {
+            // Function object
+            using Fn = NotCallableWithInt;
+            static_assert(std::is_invocable<Fn, Tag>::value, "");
+            static_assert(!std::is_invocable<Fn, int>::value, "");
+        }
+    }
+    {
+        // Check that the conversion to the return type is properly checked
+        using Fn = int(*)();
+        static_assert(std::is_invocable_r<Implicit, Fn>::value, "");
+        static_assert(std::is_invocable_r<double, Fn>::value, "");
+        static_assert(std::is_invocable_r<const volatile void, Fn>::value, "");
+        static_assert(!std::is_invocable_r<Explicit, Fn>::value, "");
+    }
+    {
+        // Check for is_invocable_v
+        using Fn = void(*)();
+        static_assert(std::is_invocable_v<Fn>, "");
+        static_assert(!std::is_invocable_v<Fn, int>, "");
+    }
+    {
+        // Check for is_invocable_r_v
+        using Fn = void(*)();
+        static_assert(std::is_invocable_r_v<void, Fn>, "");
+        static_assert(!std::is_invocable_r_v<int, Fn>, "");
+    }
+}

test/std/utilities/meta/meta.rel/is_nothrow_callable.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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-
-// type_traits
-
-// is_nothrow_callable
-
-#include <type_traits>
-#include <functional>
-
-#include "test_macros.h"
-
-struct Tag {};
-
-struct Implicit {
-  Implicit(int) noexcept {}
-};
-
-struct ThrowsImplicit {
-  ThrowsImplicit(int) {}
-};
-
-struct Explicit {
-  explicit Explicit(int) noexcept {}
-};
-
-template <bool IsNoexcept, class Ret, class ...Args>
-struct CallObject {
-  Ret operator()(Args&&...) const noexcept(IsNoexcept);
-};
-
-template <class Fn>
-constexpr bool throws_callable() {
-    return std::is_callable<Fn>::value &&
-        !std::is_nothrow_callable<Fn>::value;
-}
-
-template <class Fn, class Ret>
-constexpr bool throws_callable() {
-    return std::is_callable<Fn, Ret>::value &&
-        !std::is_nothrow_callable<Fn, Ret>::value;
-}
-
-// FIXME(EricWF) Don't test the where noexcept is *not* part of the type system
-// once implementations have caught up.
-void test_noexcept_function_pointers()
-{
-    struct Dummy { void foo() noexcept {} static void bar() noexcept {} };
-#if !defined(__cpp_noexcept_function_type)
-    {
-        // Check that PMF's and function pointers *work*. is_nothrow_callable will always
-        // return false because 'noexcept' is not part of the function type.
-        static_assert(throws_callable<decltype(&Dummy::foo)(Dummy&)>(), "");
-        static_assert(throws_callable<decltype(&Dummy::bar)()>(), "");
-    }
-#else
-    {
-        // Check that PMF's and function pointers actually work and that
-        // is_nothrow_callable returns true for noexcept PMF's and function
-        // pointers.
-        static_assert(std::is_nothrow_callable<decltype(&Dummy::foo)(Dummy&)>::value, "");
-        static_assert(std::is_nothrow_callable<decltype(&Dummy::bar)()>::value, "");
-    }
-#endif
-}
-
-int main()
-{
-    {
-        // Check that the conversion to the return type is properly checked
-        using Fn = CallObject<true, int>;
-        static_assert(std::is_nothrow_callable<Fn(), Implicit>::value, "");
-        static_assert(std::is_nothrow_callable<Fn(), double>::value, "");
-        static_assert(std::is_nothrow_callable<Fn(), const volatile void>::value, "");
-        static_assert(throws_callable<Fn(), ThrowsImplicit>(), "");
-        static_assert(!std::is_nothrow_callable<Fn(), Explicit>(), "");
-    }
-    {
-        // Check that the conversion to the parameters is properly checked
-        using Fn = CallObject<true, void, const Implicit&, const ThrowsImplicit&>;
-        static_assert(std::is_nothrow_callable<Fn(Implicit&, ThrowsImplicit&)>::value, "");
-        static_assert(std::is_nothrow_callable<Fn(int, ThrowsImplicit&)>::value, "");
-        static_assert(throws_callable<Fn(int, int)>(), "");
-        static_assert(!std::is_nothrow_callable<Fn()>::value, "");
-    }
-    {
-        // Check that the noexcept-ness of function objects is checked.
-        using Fn = CallObject<true, void>;
-        using Fn2 = CallObject<false, void>;
-        static_assert(std::is_nothrow_callable<Fn()>::value, "");
-        static_assert(throws_callable<Fn2()>(), "");
-    }
-    {
-        // Check that PMD derefs are noexcept
-        using Fn = int (Tag::*);
-        static_assert(std::is_nothrow_callable<Fn(Tag&)>::value, "");
-        static_assert(std::is_nothrow_callable<Fn(Tag&), Implicit>::value, "");
-        static_assert(throws_callable<Fn(Tag&), ThrowsImplicit>(), "");
-    }
-    {
-        // Check for is_nothrow_callable_v
-        using Fn = CallObject<true, int>;
-        static_assert(std::is_nothrow_callable_v<Fn()>, "");
-        static_assert(!std::is_nothrow_callable_v<Fn(int)>, "");
-    }
-    test_noexcept_function_pointers();
-}

test/std/utilities/meta/meta.rel/is_nothrow_invocable.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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// type_traits
+
+// is_nothrow_invocable
+
+#include <type_traits>
+#include <functional>
+
+#include "test_macros.h"
+
+struct Tag {};
+
+struct Implicit {
+  Implicit(int) noexcept {}
+};
+
+struct ThrowsImplicit {
+  ThrowsImplicit(int) {}
+};
+
+struct Explicit {
+  explicit Explicit(int) noexcept {}
+};
+
+template <bool IsNoexcept, class Ret, class ...Args>
+struct CallObject {
+  Ret operator()(Args&&...) const noexcept(IsNoexcept);
+};
+
+template <class Fn, class ...Args>
+constexpr bool throws_invocable() {
+    return std::is_invocable<Fn, Args...>::value &&
+        !std::is_nothrow_invocable<Fn, Args...>::value;
+}
+
+template <class Ret, class Fn, class ...Args>
+constexpr bool throws_invocable_r() {
+    return std::is_invocable_r<Ret, Fn, Args...>::value &&
+        !std::is_nothrow_invocable_r<Ret, Fn, Args...>::value;
+}
+
+// FIXME(EricWF) Don't test the where noexcept is *not* part of the type system
+// once implementations have caught up.
+void test_noexcept_function_pointers()
+{
+    struct Dummy { void foo() noexcept {} static void bar() noexcept {} };
+#if !defined(__cpp_noexcept_function_type)
+    {
+        // Check that PMF's and function pointers *work*. is_nothrow_invocable will always
+        // return false because 'noexcept' is not part of the function type.
+        static_assert(throws_invocable<decltype(&Dummy::foo), Dummy&>(), "");
+        static_assert(throws_invocable<decltype(&Dummy::bar)>(), "");
+    }
+#else
+    {
+        // Check that PMF's and function pointers actually work and that
+        // is_nothrow_invocable returns true for noexcept PMF's and function
+        // pointers.
+        static_assert(std::is_nothrow_invocable<decltype(&Dummy::foo), Dummy&>::value, "");
+        static_assert(std::is_nothrow_invocable<decltype(&Dummy::bar)>::value, "");
+    }
+#endif
+}
+
+int main()
+{
+    {
+        // Check that the conversion to the return type is properly checked
+        using Fn = CallObject<true, int>;
+        static_assert(std::is_nothrow_invocable_r<Implicit, Fn>::value, "");
+        static_assert(std::is_nothrow_invocable_r<double, Fn>::value, "");
+        static_assert(std::is_nothrow_invocable_r<const volatile void, Fn>::value, "");
+        static_assert(throws_invocable_r<ThrowsImplicit, Fn>(), "");
+        static_assert(!std::is_nothrow_invocable<Fn(), Explicit>(), "");
+    }
+    {
+        // Check that the conversion to the parameters is properly checked
+        using Fn = CallObject<true, void, const Implicit&, const ThrowsImplicit&>;
+        static_assert(std::is_nothrow_invocable<Fn, Implicit&, ThrowsImplicit&>::value, "");
+        static_assert(std::is_nothrow_invocable<Fn, int, ThrowsImplicit&>::value, "");
+        static_assert(throws_invocable<Fn, int, int>(), "");
+        static_assert(!std::is_nothrow_invocable<Fn>::value, "");
+    }
+    {
+        // Check that the noexcept-ness of function objects is checked.
+        using Fn = CallObject<true, void>;
+        using Fn2 = CallObject<false, void>;
+        static_assert(std::is_nothrow_invocable<Fn>::value, "");
+        static_assert(throws_invocable<Fn2>(), "");
+    }
+    {
+        // Check that PMD derefs are noexcept
+        using Fn = int (Tag::*);
+        static_assert(std::is_nothrow_invocable<Fn, Tag&>::value, "");
+        static_assert(std::is_nothrow_invocable_r<Implicit, Fn, Tag&>::value, "");
+        static_assert(throws_invocable_r<ThrowsImplicit, Fn, Tag&>(), "");
+    }
+    {
+        // Check for is_nothrow_invocable_v
+        using Fn = CallObject<true, int>;
+        static_assert(std::is_nothrow_invocable_v<Fn>, "");
+        static_assert(!std::is_nothrow_invocable_v<Fn, int>, "");
+    }
+    {
+        // Check for is_nothrow_invocable_r_v
+        using Fn = CallObject<true, int>;
+        static_assert(std::is_nothrow_invocable_r_v<void, Fn>, "");
+        static_assert(!std::is_nothrow_invocable_r_v<int, Fn, int>, "");
+    }
+    test_noexcept_function_pointers();
+}

test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp

 };
 
 template <class T, class = void>
 struct HasType : std::false_type {};
 
 template <class T>
 struct HasType<T, typename Voider<typename T::type>::type> : std::true_type {};
 
+#if TEST_STD_VER > 14
+template <typename T, typename U>
+struct test_invoke_result;
+
+template <typename Fn, typename ...Args, typename Ret>
+struct test_invoke_result<Fn(Args...), Ret>
+{
+    static void call()
+    {
+        static_assert(std::is_invocable<Fn, Args...>::value, "");
+        static_assert(std::is_invocable_r<Ret, Fn, Args...>::value, "");
+        static_assert((std::is_same<typename std::invoke_result<Fn, Args...>::type, Ret>::value), "");
+    }
+};
+#endif
+
 template <class T, class U>
 void test_result_of()
 {
+    static_assert((std::is_same<typename std::result_of<T>::type, U>::value), "");
 #if TEST_STD_VER > 14
-    static_assert(std::is_callable<T>::value, "");
-    static_assert(std::is_callable<T, U>::value, "");
+    test_invoke_result<T, U>::call();
 #endif
-    static_assert((std::is_same<typename std::result_of<T>::type, U>::value), "");
 }
 
+#if TEST_STD_VER > 14
+template <typename T>
+struct test_invoke_no_result;
+
+template <typename Fn, typename ...Args>
+struct test_invoke_no_result<Fn(Args...)>
+{
+    static void call()
+    {
+        static_assert(std::is_invocable<Fn, Args...>::value == false, "");
+        static_assert((!HasType<std::invoke_result<Fn, Args...> >::value), "");
+    }
+};
+#endif
+
 template <class T>
 void test_no_result()
 {
 #if TEST_STD_VER >= 11
     static_assert((!HasType<std::result_of<T> >::value), "");
 #endif
 #if TEST_STD_VER > 14
-    static_assert(std::is_callable<T>::value == false, "");
+    test_invoke_no_result<T>::call();
 #endif
 }
 
 int main()
 {
     typedef NotDerived ND;
     { // functor object
     test_result_of<S(int), short> ();

test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp

 {
     wat& operator*() { return *this; }
     void foo();
 };
 
 struct F {};
 struct FD : public F {};
 
+#if TEST_STD_VER > 14
+template <typename T, typename U>
+struct test_invoke_result;
+
+template <typename Fn, typename ...Args, typename Ret>
+struct test_invoke_result<Fn(Args...), Ret>
+{
+    static void call()
+    {
+        static_assert(std::is_invocable<Fn, Args...>::value, "");
+        static_assert(std::is_invocable_r<Ret, Fn, Args...>::value, "");
+        static_assert((std::is_same<typename std::invoke_result<Fn, Args...>::type, Ret>::value), "");
+        static_assert((std::is_same<std::invoke_result_t<Fn, Args...>, Ret>::value), "");
+    }
+};
+#endif
+
 template <class T, class U>
 void test_result_of_imp()
 {
     static_assert((std::is_same<typename std::result_of<T>::type, U>::value), "");
 #if TEST_STD_VER > 11
     static_assert((std::is_same<std::result_of_t<T>, U>::value), "");
 #endif
 #if TEST_STD_VER > 14
-    static_assert(std::is_callable<T>::value, "");
-    static_assert(std::is_callable<T, U>::value, "");
+    test_invoke_result<T, U>::call();
 #endif
 }
 
 int main()
 {
     {
     typedef char F::*PMD;
     test_result_of_imp<PMD(F                &), char                &>();