Reduce usage of costly-to-compile std::invoke_result_t

Summary: ispeters points out that instantiating `std::invoke_result_t` can quite heavy due to its flexible implementation. yfeldblum authored a folly mimic, which strives to be cheaper. In some places, we can just get away with `decltype(...)` -- primarily to avoid adding another #include.

Reviewed By: yfeldblum

Differential Revision: D79298082

fbshipit-source-id: 18a5e641e8af40a88249a3993e5661ee34d115fb

Author: snarkmaster

third-party/folly/src/folly/channels/ChannelProcessor-inl.h

@@ -118,8 +118,7 @@ class ChannelProcessorImpl {
 
   template <
       typename Function,
-      typename ReturnType =
-          typename std::invoke_result_t<Function>::StorageType>
+      typename ReturnType = typename invoke_result_t<Function>::StorageType>
   static folly::coro::Task<ReturnType> catchNonCoroException(Function func) {
     auto result = folly::makeTryWith(std::move(func));
     if (result.hasException()) {

third-party/folly/src/folly/coro/GmockHelpers.h

@@ -115,7 +115,7 @@ auto makeCoAction(Fn&& fn) {
       std::is_copy_constructible_v<remove_cvref_t<Fn>>,
       "Fn should be copyable to allow calling mocked call multiple times.");
 
-  using Ret = std::invoke_result_t<remove_cvref_t<Fn>&&>;
+  using Ret = invoke_result_t<remove_cvref_t<Fn>&&>;
   return ::testing::InvokeWithoutArgs(
       [fn = std::forward<Fn>(fn)]() mutable -> Ret { return co_invoke(fn); });
 }

third-party/folly/src/folly/coro/Synchronized.h

@@ -190,10 +190,10 @@ class Synchronized : public NonCopyableNonMovable {
   }
 
   template <typename FuncT>
-  using rlock_result_t = std::invoke_result_t<FuncT, ReadLockedPtr>;
+  using rlock_result_t = invoke_result_t<FuncT, ReadLockedPtr>;
 
   template <typename FuncT>
-  using wlock_result_t = std::invoke_result_t<FuncT, WriteLockedPtr>;
+  using wlock_result_t = invoke_result_t<FuncT, WriteLockedPtr>;
 
   template <typename FuncT, typename ReturnT = rlock_result_t<FuncT>>
   typename std::enable_if<!is_semi_awaitable_v<ReturnT>, Task<ReturnT>>::type

third-party/folly/src/folly/coro/safe/detail/AsyncClosure.h

@@ -561,7 +561,7 @@ auto async_closure_inner_coro_and_storage(auto&& make_inner_coro, BTup& b_tup) {
               if constexpr (OnlyGetInnerCoroType) { // Non-evaluated, see (1)
                 return type_identity<detected_or_t<
                     void*,
-                    std::invoke_result_t,
+                    invoke_result_t,
                     decltype(make_inner_coro),
                     decltype(async_closure_bind_inner_coro_arg<
                             StorageIs,

third-party/folly/src/folly/coro/safe/test/NowTaskTest.cpp

@@ -258,7 +258,7 @@ CO_TEST(NowTaskTest, awaitTry) {
 #endif
 }
 
-// `std::invoke_result_t` cannot pass prvalues -- it invokes a move ctor.
+// `invoke_result_t` cannot pass prvalues -- it invokes a move ctor.
 template <typename T>
 using blockingWait_result_t = decltype(blockingWait(FOLLY_DECLVAL(T)));
 template <typename T, typename Res>

third-party/folly/src/folly/lang/bind/Bind.h

@@ -430,7 +430,7 @@ template <typename... Args>
 constexpr auto in_place_with(
     auto make_fn, Args&&... args [[clang::lifetimebound]]) {
   return detail::in_place_fn_args<
-      std::invoke_result_t<decltype(make_fn), Args&&...>,
+      decltype(make_fn(FOLLY_DECLVAL(Args&&)...)),
       decltype(make_fn),
       Args...>{std::move(make_fn), static_cast<Args&&>(args)...};
 }

third-party/folly/src/folly/observer/detail/Core.h

@@ -63,7 +63,7 @@ class Core : public std::enable_shared_from_this<Core> {
     static CreatorContext create(const F& creator) {
       CreatorContext context;
       context.typeInfo = &typeid(F);
-      context.invokeResultTypeInfo = &typeid(std::invoke_result_t<F>);
+      context.invokeResultTypeInfo = &typeid(decltype(FOLLY_DECLVAL(F&&)()));
       if constexpr (Has_getNameT_v<F>) {
         context.name = creator.getName();
       }

third-party/folly/src/folly/result/result.h

@@ -278,10 +278,10 @@ const non_value_result& dfatal_get_empty_result_error();
 const non_value_result& dfatal_get_bad_result_access_error();
 
 template <typename T>
-using result_ref_wrap = std::conditional_t< // Reused by `result_generator`
+using result_ref_wrap = conditional_t< // Reused by `result_generator`
     std::is_rvalue_reference_v<T>,
     rvalue_reference_wrapper<std::remove_reference_t<T>>,
-    std::conditional_t<
+    conditional_t<
         std::is_lvalue_reference_v<T>,
         std::reference_wrapper<std::remove_reference_t<T>>,
         T>>;
@@ -921,15 +921,12 @@ auto /* implicit */ operator co_await(
 ///   - `result<>` coroutines catch unhandled exceptions, but can throw due to
 ///     argument copy/move ctors, or due to `bad_alloc`.
 ///   - Like all functions, `result<>` non-coroutines let exceptions fly.
-template <typename F>
+template <typename F, typename RetF = decltype(FOLLY_DECLVAL(F&&)())>
 // Wrap the return type of `fn` with `result` unless it already is `result`.
-typename std::conditional_t<
-    is_instantiation_of_v<result, std::invoke_result_t<F>>,
-    std::invoke_result_t<F>,
-    result<std::invoke_result_t<F>>>
+conditional_t<is_instantiation_of_v<result, RetF>, RetF, result<RetF>>
 result_catch_all(F&& fn) noexcept {
   try {
-    if constexpr (std::is_void_v<std::invoke_result_t<F>>) {
+    if constexpr (std::is_void_v<RetF>) {
       static_cast<F&&>(fn)();
       return {};
     } else {