grpc 1.68.1 → 1.71.0

data/src/core/lib/promise/all_ok.h

@@ -24,6 +24,7 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "src/core/lib/promise/detail/join_state.h"
+#include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/status_flag.h"
@@ -81,6 +82,42 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto AllOk(Promises... promises) {
   return promise_detail::AllOk<Result, Promises...>(std::move(promises)...);
 }
 
+// Construct a promise for each element of the set, then run them all.
+// If any fail, cancel the rest and return the failure.
+// If all succeed, return Ok.
+template <typename Result, typename Iter, typename FactoryFn>
+inline auto AllOkIter(Iter begin, Iter end, FactoryFn factory_fn) {
+  using Factory =
+      promise_detail::RepeatedPromiseFactory<decltype(*begin), FactoryFn>;
+  Factory factory(std::move(factory_fn));
+  using Promise = typename Factory::Promise;
+  std::vector<Promise> promises;
+  std::vector<bool> done;
+  for (auto it = begin; it != end; ++it) {
+    promises.emplace_back(factory.Make(*it));
+    done.push_back(false);
+  }
+  return [promises = std::move(promises),
+          done = std::move(done)]() mutable -> Poll<Result> {
+    using Traits = promise_detail::AllOkTraits<Result>;
+    bool still_working = false;
+    for (size_t i = 0; i < promises.size(); ++i) {
+      if (done[i]) continue;
+      auto p = promises[i]();
+      if (auto* r = p.value_if_ready()) {
+        if (!Traits::IsOk(*r)) {
+          return Traits::template EarlyReturn<Result>(std::move(*r));
+        }
+        done[i] = true;
+      } else {
+        still_working = true;
+      }
+    }
+    if (still_working) return Pending{};
+    return Traits::FinalReturn();
+  };
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_PROMISE_ALL_OK_H

data/src/core/lib/promise/detail/basic_seq.h

@@ -17,35 +17,41 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/util/construct_destruct.h"
 
 namespace grpc_core {
 namespace promise_detail {
 
+template <typename FactoryFn>
+auto BindFactoryFnArgs(FactoryFn fn) {
+  return [fn = std::move(fn)](auto x) mutable {
+    return fn(std::get<0>(x), std::move(std::get<1>(x)));
+  };
+}
+
 // Models a sequence of unknown size
 // At each element, the accumulator A and the current value V is passed to some
 // function of type IterTraits::Factory as f(V, IterTraits::Argument); f is
 // expected to return a promise that resolves to IterTraits::Wrapped.
-template <class IterTraits>
+template <template <typename> class Traits, typename Iter, typename FactoryFn,
+          typename Argument>
 class BasicSeqIter {
  private:
-  using Traits = typename IterTraits::Traits;
-  using Iter = typename IterTraits::Iter;
-  using Factory = typename IterTraits::Factory;
-  using Argument = typename IterTraits::Argument;
-  using IterValue = typename IterTraits::IterValue;
-  using StateCreated = typename IterTraits::StateCreated;
-  using State = typename IterTraits::State;
-  using Wrapped = typename IterTraits::Wrapped;
+  using BoundFactoryFn = decltype(BindFactoryFnArgs(std::declval<FactoryFn>()));
+  using TplArg = std::tuple<decltype((*std::declval<Iter>())), Argument>;
+  using Factory = RepeatedPromiseFactory<TplArg, BoundFactoryFn>;
+  using State = typename Factory::Promise;
+  using StateResult = typename State::Result;
 
  public:
-  BasicSeqIter(Iter begin, Iter end, Factory f, Argument arg)
-      : cur_(begin), end_(end), f_(std::move(f)) {
+  BasicSeqIter(Iter begin, Iter end, FactoryFn f, Argument arg)
+      : cur_(begin), end_(end), f_(BindFactoryFnArgs(std::move(f))) {
     if (cur_ == end_) {
       Construct(&result_, std::move(arg));
     } else {
-      Construct(&state_, f_(*cur_, std::move(arg)));
+      Construct(&state_, f_.Make(TplArg(*cur_, std::move(arg))));
     }
   }
 
@@ -79,7 +85,7 @@ class BasicSeqIter {
     return *this;
   }
 
-  Poll<Wrapped> operator()() {
+  Poll<StateResult> operator()() {
     if (cur_ == end_) {
       return std::move(result_);
     }
@@ -87,11 +93,12 @@ class BasicSeqIter {
   }
 
  private:
-  Poll<Wrapped> PollNonEmpty() {
-    Poll<Wrapped> r = state_();
+  Poll<StateResult> PollNonEmpty() {
+    Poll<StateResult> r = state_();
     if (r.pending()) return r;
-    return Traits::template CheckResultAndRunNext<Wrapped>(
-        std::move(r.value()), [this](Wrapped arg) -> Poll<Wrapped> {
+    using Tr = Traits<StateResult>;
+    return Tr::template CheckResultAndRunNext<StateResult>(
+        std::move(r.value()), [this](auto arg) -> Poll<StateResult> {
           auto next = cur_;
           ++next;
           if (next == end_) {
@@ -99,7 +106,14 @@ class BasicSeqIter {
           }
           cur_ = next;
           state_.~State();
-          Construct(&state_, Traits::CallSeqFactory(f_, *cur_, std::move(arg)));
+          struct WrapperFactory {
+            BasicSeqIter* owner;
+            State Make(typename Tr::UnwrappedType r) {
+              return owner->f_.Make(TplArg(*owner->cur_, std::move(r)));
+            }
+          };
+          WrapperFactory wrapper_factory{this};
+          Construct(&state_, Tr::CallFactory(&wrapper_factory, std::move(arg)));
           return PollNonEmpty();
         });
   }

data/src/core/lib/promise/detail/join_state.h

@@ -57,11 +57,8 @@ struct JoinState<Traits, P0, P1> {
     Construct(&promise0, std::forward<P0>(p0));
     Construct(&promise1, std::forward<P1>(p1));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -163,12 +160,8 @@ struct JoinState<Traits, P0, P1, P2> {
     Construct(&promise1, std::forward<P1>(p1));
     Construct(&promise2, std::forward<P2>(p2));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -307,13 +300,8 @@ struct JoinState<Traits, P0, P1, P2, P3> {
     Construct(&promise2, std::forward<P2>(p2));
     Construct(&promise3, std::forward<P3>(p3));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-    Construct(&promise3, other.promise3);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -488,14 +476,8 @@ struct JoinState<Traits, P0, P1, P2, P3, P4> {
     Construct(&promise3, std::forward<P3>(p3));
     Construct(&promise4, std::forward<P4>(p4));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-    Construct(&promise3, other.promise3);
-    Construct(&promise4, other.promise4);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -706,15 +688,8 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5> {
     Construct(&promise4, std::forward<P4>(p4));
     Construct(&promise5, std::forward<P5>(p5));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-    Construct(&promise3, other.promise3);
-    Construct(&promise4, other.promise4);
-    Construct(&promise5, other.promise5);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -961,16 +936,8 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5, P6> {
     Construct(&promise5, std::forward<P5>(p5));
     Construct(&promise6, std::forward<P6>(p6));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-    Construct(&promise3, other.promise3);
-    Construct(&promise4, other.promise4);
-    Construct(&promise5, other.promise5);
-    Construct(&promise6, other.promise6);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -1253,17 +1220,8 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5, P6, P7> {
     Construct(&promise6, std::forward<P6>(p6));
     Construct(&promise7, std::forward<P7>(p7));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-    Construct(&promise3, other.promise3);
-    Construct(&promise4, other.promise4);
-    Construct(&promise5, other.promise5);
-    Construct(&promise6, other.promise6);
-    Construct(&promise7, other.promise7);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
@@ -1581,18 +1539,8 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5, P6, P7, P8> {
     Construct(&promise7, std::forward<P7>(p7));
     Construct(&promise8, std::forward<P8>(p8));
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) {
-    DCHECK(other.ready.none());
-    Construct(&promise0, other.promise0);
-    Construct(&promise1, other.promise1);
-    Construct(&promise2, other.promise2);
-    Construct(&promise3, other.promise3);
-    Construct(&promise4, other.promise4);
-    Construct(&promise5, other.promise5);
-    Construct(&promise6, other.promise6);
-    Construct(&promise7, other.promise7);
-    Construct(&promise8, other.promise8);
-  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(const JoinState& other) =
+      delete;
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {

data/src/core/lib/promise/detail/promise_factory.h

@@ -32,7 +32,7 @@
 // boundaries to provide the new steady state.
 //
 // A PromiseFactory formally is f(A) -> Promise<T> for some types A & T.
-// This get a bit awkward and inapproprate to write however, and so the type
+// This get a bit awkward and inappropriate to write however, and so the type
 // contained herein can adapt various kinds of callable into the correct form.
 // Of course a callable of a single argument returning a Promise will see an
 // identity translation. One taking no arguments and returning a Promise
@@ -111,13 +111,24 @@ class Curried {
 #endif
 };
 
+// These token types are passed to PromiseFactoryImpl as the first argument.
+// They declare the intent of the calling factory to be repeatable or once only.
+// We use that knowledge to filter out variants that promote promises to promise
+// factories for repeatable factories because that promotion is very often the
+// wrong thing to do.
+//
+// Prevents bugs of the class:
+// Loop(Seq(AccidentallyCallNonRepeatableThing()))
+struct RepeatableToken {};
+struct OnceToken {};
+
 // Promote a callable(A) -> T | Poll<T> to a PromiseFactory(A) -> Promise<T> by
 // capturing A.
-template <typename A, typename F>
+template <typename Token, typename A, typename F>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
     absl::enable_if_t<!IsVoidCallable<ResultOf<F(A)>>::value,
                       PromiseLike<Curried<RemoveCVRef<F>, A>>>
-    PromiseFactoryImpl(F&& f, A&& arg) {
+    PromiseFactoryImpl(Token, F&& f, A&& arg) {
   return Curried<RemoveCVRef<F>, A>(std::forward<F>(f), std::forward<A>(arg));
 }
 
@@ -126,70 +137,98 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
 template <typename A, typename F>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline absl::enable_if_t<
     !IsVoidCallable<ResultOf<F()>>::value, PromiseLike<RemoveCVRef<F>>>
-PromiseFactoryImpl(F f, A&&) {
+PromiseFactoryImpl(OnceToken, F f, A&&) {
   return PromiseLike<F>(std::move(f));
 }
 
-// Promote a callable() -> T|Poll<T> to a PromiseFactory() -> Promise<T>
+// Promote a callable() -> Poll<T> to a PromiseFactory() -> Promise<T>
 template <typename F>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline absl::enable_if_t<
-    !IsVoidCallable<ResultOf<F()>>::value, PromiseLike<RemoveCVRef<F>>>
-PromiseFactoryImpl(F f) {
+    !IsVoidCallable<ResultOf<F()>>::value &&
+        PollTraits<ResultOf<F()>>::is_poll(),
+    PromiseLike<RemoveCVRef<F>>>
+PromiseFactoryImpl(OnceToken, F f) {
   return PromiseLike<F>(std::move(f));
 }
 
+// Promote a callable() -> T to a PromiseFactory() -> Immediate<T>
+template <typename F>
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto PromiseFactoryImpl(
+    std::enable_if_t<!IsVoidCallable<ResultOf<F()>>::value &&
+                         !PollTraits<ResultOf<F()>>::is_poll() &&
+                         !std::is_same_v<ResultOf<F()>, void>,
+                     OnceToken>,
+    F f) {
+  auto f2 = [x = f()]() mutable { return std::move(x); };
+  return PromiseLike<decltype(f2)>(std::move(f2));
+}
+template <typename F>
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto PromiseFactoryImpl(
+    std::enable_if_t<!IsVoidCallable<ResultOf<F()>>::value &&
+                         !PollTraits<ResultOf<F()>>::is_poll() &&
+                         std::is_same_v<ResultOf<F()>, void>,
+                     OnceToken>,
+    F f) {
+  f();
+  auto f2 = []() { return Empty{}; };
+  return PromiseLike<decltype(f2)>(std::move(f2));
+}
+
 // Given a callable(A) -> Promise<T>, name it a PromiseFactory and use it.
-template <typename A, typename F>
+template <typename Token, typename A, typename F>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline absl::enable_if_t<
     IsVoidCallable<ResultOf<F(A)>>::value,
     PromiseLike<decltype(std::declval<F>()(std::declval<A>()))>>
-PromiseFactoryImpl(F&& f, A&& arg) {
+PromiseFactoryImpl(Token, F&& f, A&& arg) {
   return f(std::forward<A>(arg));
 }
 
 // Given a callable(A) -> Promise<T>, name it a PromiseFactory and use it.
-template <typename A, typename F>
+template <typename Token, typename A, typename F>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline absl::enable_if_t<
     IsVoidCallable<ResultOf<F(A)>>::value,
     PromiseLike<decltype(std::declval<F>()(std::declval<A>()))>>
-PromiseFactoryImpl(F& f, A&& arg) {
+PromiseFactoryImpl(Token, F& f, A&& arg) {
   return f(std::forward<A>(arg));
 }
 
 // Given a callable() -> Promise<T>, promote it to a
 // PromiseFactory(A) -> Promise<T> by dropping the first argument.
-template <typename A, typename F>
+template <typename Token, typename A, typename F>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
     absl::enable_if_t<IsVoidCallable<ResultOf<F()>>::value,
                       PromiseLike<decltype(std::declval<F>()())>>
-    PromiseFactoryImpl(F&& f, A&&) {
+    PromiseFactoryImpl(Token, F&& f, A&&) {
   return f();
 }
 
 // Given a callable() -> Promise<T>, name it a PromiseFactory and use it.
-template <typename F>
+template <typename Token, typename F>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
     absl::enable_if_t<IsVoidCallable<ResultOf<F()>>::value,
                       PromiseLike<decltype(std::declval<F>()())>>
-    PromiseFactoryImpl(F&& f) {
+    PromiseFactoryImpl(Token, F&& f) {
   return f();
 }
 
 template <typename A, typename F>
+// One instance of promise factory of the type OncePromiseFactory can be used to
+// generate a promise only once. If you need one instance of a promise factory
+// to return promises multiple times use RepeatedPromiseFactory.
 class OncePromiseFactory {
  private:
   GPR_NO_UNIQUE_ADDRESS F f_;
 
  public:
   using Arg = A;
-  using Promise =
-      decltype(PromiseFactoryImpl(std::move(f_), std::declval<A>()));
+  using Promise = decltype(PromiseFactoryImpl(OnceToken{}, std::move(f_),
+                                              std::declval<A>()));
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit OncePromiseFactory(F f)
       : f_(std::move(f)) {}
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make(Arg&& a) {
-    return PromiseFactoryImpl(std::move(f_), std::forward<Arg>(a));
+    return PromiseFactoryImpl(OnceToken{}, std::move(f_), std::forward<Arg>(a));
   }
 };
 
@@ -200,33 +239,38 @@ class OncePromiseFactory<void, F> {
 
  public:
   using Arg = void;
-  using Promise = decltype(PromiseFactoryImpl(std::move(f_)));
+  using Promise = decltype(PromiseFactoryImpl(OnceToken{}, std::move(f_)));
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit OncePromiseFactory(F f)
       : f_(std::move(f)) {}
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make() {
-    return PromiseFactoryImpl(std::move(f_));
+    return PromiseFactoryImpl(OnceToken{}, std::move(f_));
   }
 };
 
 template <typename A, typename F>
+// One instance of promise factory of the type RepeatedPromiseFactory can be
+// used to multiple times to return promises. If you need one instance of a
+// promise factory to return only one promise in its lifetime use
+// OncePromiseFactory.
 class RepeatedPromiseFactory {
  private:
   GPR_NO_UNIQUE_ADDRESS F f_;
 
  public:
   using Arg = A;
-  using Promise = decltype(PromiseFactoryImpl(f_, std::declval<A>()));
+  using Promise =
+      decltype(PromiseFactoryImpl(RepeatableToken{}, f_, std::declval<A>()));
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit RepeatedPromiseFactory(F f)
       : f_(std::move(f)) {}
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make(Arg&& a) const {
-    return PromiseFactoryImpl(f_, std::forward<Arg>(a));
+    return PromiseFactoryImpl(RepeatableToken{}, f_, std::forward<Arg>(a));
   }
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make(Arg&& a) {
-    return PromiseFactoryImpl(f_, std::forward<Arg>(a));
+    return PromiseFactoryImpl(RepeatableToken{}, f_, std::forward<Arg>(a));
   }
 };
 
@@ -237,19 +281,35 @@ class RepeatedPromiseFactory<void, F> {
 
  public:
   using Arg = void;
-  using Promise = decltype(PromiseFactoryImpl(f_));
+  using Promise = decltype(PromiseFactoryImpl(RepeatableToken{}, f_));
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit RepeatedPromiseFactory(F f)
       : f_(std::move(f)) {}
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make() const {
-    return PromiseFactoryImpl(f_);
+    return PromiseFactoryImpl(RepeatableToken{}, f_);
   }
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make() {
-    return PromiseFactoryImpl(f_);
+    return PromiseFactoryImpl(RepeatableToken{}, f_);
   }
 };
 
+template <typename A, typename F, typename = void>
+constexpr const bool kIsRepeatedPromiseFactory = false;
+
+template <typename A, typename F>
+constexpr const bool kIsRepeatedPromiseFactory<
+    A, F,
+    std::void_t<decltype(PromiseFactoryImpl(
+        RepeatableToken{}, std::declval<F&&>(), std::declval<A>()))>> = true;
+
+template <typename F>
+constexpr const bool
+    kIsRepeatedPromiseFactory<void, F,
+                              std::void_t<decltype(PromiseFactoryImpl(
+                                  RepeatableToken{}, std::declval<F&&>()))>> =
+        true;
+
 }  // namespace promise_detail
 }  // namespace grpc_core
 

data/src/core/lib/promise/detail/promise_like.h

@@ -79,26 +79,46 @@ template <>
 class PromiseLike<void>;
 
 template <typename F>
-class PromiseLike<F, absl::enable_if_t<!std::is_void<
-#if (defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703L) || \
-    (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-                         std::invoke_result_t<F>
-#else
-                         typename std::result_of<F()>::type
-#endif
-                         >::value>> {
+class PromiseLike<
+    F, absl::enable_if_t<!std::is_void<std::invoke_result_t<F>>::value>> {
  private:
   GPR_NO_UNIQUE_ADDRESS RemoveCVRef<F> f_;
+  using OriginalResult = decltype(f_());
+  using WrappedResult = decltype(WrapInPoll(std::declval<OriginalResult>()));
 
  public:
   // NOLINTNEXTLINE - internal detail that drastically simplifies calling code.
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION PromiseLike(F&& f)
       : f_(std::forward<F>(f)) {}
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto operator()()
-      -> decltype(WrapInPoll(f_())) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION WrappedResult operator()() {
     return WrapInPoll(f_());
   }
-  using Result = typename PollTraits<decltype(WrapInPoll(f_()))>::Type;
+  PromiseLike(const PromiseLike&) = default;
+  PromiseLike& operator=(const PromiseLike&) = default;
+  PromiseLike(PromiseLike&&) = default;
+  PromiseLike& operator=(PromiseLike&&) = default;
+  using Result = typename PollTraits<WrappedResult>::Type;
+};
+
+template <typename F>
+class PromiseLike<
+    F, absl::enable_if_t<std::is_void<std::invoke_result_t<F>>::value>> {
+ private:
+  GPR_NO_UNIQUE_ADDRESS RemoveCVRef<F> f_;
+
+ public:
+  // NOLINTNEXTLINE - internal detail that drastically simplifies calling code.
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION PromiseLike(F&& f)
+      : f_(std::forward<F>(f)) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Empty> operator()() {
+    f_();
+    return Empty{};
+  }
+  PromiseLike(const PromiseLike&) = default;
+  PromiseLike& operator=(const PromiseLike&) = default;
+  PromiseLike(PromiseLike&&) = default;
+  PromiseLike& operator=(PromiseLike&&) = default;
+  using Result = Empty;
 };
 
 }  // namespace promise_detail