grpc 1.70.1 → 1.71.0

data/src/core/lib/iomgr/executor.cc

@@ -85,17 +85,6 @@ size_t Executor::RunClosures(const char* executor_name,
                              grpc_closure_list list) {
   size_t n = 0;
 
-  // In the executor, the ExecCtx for the thread is declared in the executor
-  // thread itself, but this is the point where we could start seeing
-  // application-level callbacks. No need to create a new ExecCtx, though,
-  // since there already is one and it is flushed (but not destructed) in this
-  // function itself. The ApplicationCallbackExecCtx will have its callbacks
-  // invoked on its destruction, which will be after completing any closures in
-  // the executor's closure list (which were explicitly scheduled onto the
-  // executor).
-  ApplicationCallbackExecCtx callback_exec_ctx(
-      GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD);
-
   grpc_closure* c = list.head;
   while (c != nullptr) {
     grpc_closure* next = c->next_data.next;

data/src/core/lib/iomgr/resolve_address_posix.cc

@@ -166,7 +166,6 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
   grpc_event_engine::experimental::GetDefaultEventEngine()->Run([on_resolved] {
-    ApplicationCallbackExecCtx app_exec_ctx;
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up SRV records"));
@@ -181,7 +180,6 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
     absl::string_view /* name_server */) {
   // Not supported
   grpc_event_engine::experimental::GetDefaultEventEngine()->Run([on_resolved] {
-    ApplicationCallbackExecCtx app_exec_ctx;
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up TXT records"));

data/src/core/lib/iomgr/resolve_address_windows.cc

@@ -164,7 +164,6 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
   RunCallbackOnDefaultEventEngine([on_resolved] {
-    ApplicationCallbackExecCtx app_exec_ctx;
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up SRV records"));
@@ -179,7 +178,6 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
     absl::string_view /* name_server */) {
   // Not supported
   RunCallbackOnDefaultEventEngine([on_resolved] {
-    ApplicationCallbackExecCtx app_exec_ctx;
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up TXT records"));

data/src/core/lib/iomgr/socket_utils_posix.cc

@@ -18,7 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/types/optional.h"
+#include <optional>
+
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKETUTILS
@@ -45,7 +46,7 @@ using ::grpc_core::PosixTcpOptions;
 namespace {
 
 int AdjustValue(int default_value, int min_value, int max_value,
-                absl::optional<int> actual_value) {
+                std::optional<int> actual_value) {
   if (!actual_value.has_value() || *actual_value < min_value ||
       *actual_value > max_value) {
     return default_value;

data/src/core/lib/iomgr/tcp_posix.cc

@@ -19,11 +19,12 @@
 #include <grpc/impl/grpc_types.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
 
@@ -815,7 +816,7 @@ static void maybe_post_reclaimer(grpc_tcp* tcp)
     TCP_REF(tcp, "posted_reclaimer");
     tcp->memory_owner.PostReclaimer(
         grpc_core::ReclamationPass::kBenign,
-        [tcp](absl::optional<grpc_core::ReclamationSweep> sweep) {
+        [tcp](std::optional<grpc_core::ReclamationSweep> sweep) {
           if (sweep.has_value()) {
             perform_reclamation(tcp);
           }

data/src/core/lib/iomgr/tcp_server_posix.cc

@@ -126,7 +126,6 @@ static grpc_error_handle CreateEventEngineListener(
         [s](int listener_fd, std::unique_ptr<EventEngine::Endpoint> ep,
             bool is_external, MemoryAllocator /*allocator*/,
             SliceBuffer* pending_data) {
-          grpc_core::ApplicationCallbackExecCtx app_ctx;
           grpc_core::ExecCtx exec_ctx;
           grpc_pollset* read_notifier_pollset;
           grpc_tcp_server_acceptor* acceptor;
@@ -213,7 +212,6 @@ static grpc_error_handle CreateEventEngineListener(
   } else {
     EventEngine::Listener::AcceptCallback accept_cb =
         [s](std::unique_ptr<EventEngine::Endpoint> ep, MemoryAllocator) {
-          grpc_core::ApplicationCallbackExecCtx app_ctx;
           grpc_core::ExecCtx exec_ctx;
           void* cb_arg;
           {
@@ -636,7 +634,7 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
             }
             DCHECK_GT(*listen_fd, 0);
             s->listen_fd_to_index_map.insert_or_assign(
-                *listen_fd, std::make_tuple(s->n_bind_ports, fd_index++));
+                *listen_fd, std::tuple(s->n_bind_ports, fd_index++));
           });
     } else {
       port = s->ee_listener->Bind(

data/src/core/lib/iomgr/tcp_server_windows.cc

@@ -650,7 +650,6 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   auto accept_cb = [s, on_accept_cb, on_accept_cb_arg](
                        std::unique_ptr<EventEngine::Endpoint> endpoint,
                        MemoryAllocator memory_allocator) {
-    grpc_core::ApplicationCallbackExecCtx app_ctx;
     grpc_core::ExecCtx exec_ctx;
     grpc_tcp_server_acceptor* acceptor =
         static_cast<grpc_tcp_server_acceptor*>(gpr_malloc(sizeof(*acceptor)));

data/src/core/lib/iomgr/timer_manager.cc

@@ -97,14 +97,6 @@ void grpc_timer_manager_tick() {
 }
 
 static void run_some_timers() {
-  // In the case of timers, the ExecCtx for the thread is declared
-  // in the timer thread itself, but this is the point where we
-  // could start seeing application-level callbacks. No need to
-  // create a new ExecCtx, though, since there already is one and it is
-  // flushed (but not destructed) in this function itself
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx(
-      GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD);
-
   // if there's something to execute...
   gpr_mu_lock(&g_mu);
   // remove a waiter from the pool, and start another thread if necessary
@@ -241,7 +233,7 @@ static void timer_main_loop() {
         GRPC_TRACE_LOG(timer_check, INFO)
             << "timers not checked: expect another thread to";
         next = grpc_core::Timestamp::InfFuture();
-        ABSL_FALLTHROUGH_INTENDED;
+        [[fallthrough]];
       case GRPC_TIMERS_CHECKED_AND_EMPTY:
         if (!wait_until(next)) {
           return;

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

@@ -21,6 +21,7 @@
 #include <algorithm>
 #include <atomic>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -28,7 +29,6 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
@@ -608,7 +608,7 @@ class PromiseActivity final
   // The main body of a step: set the current activity, and any contexts, and
   // then run the main polling loop. Contained in a function by itself in
   // order to keep the scoping rules a little easier in Step().
-  absl::optional<ResultType> RunStep() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
+  std::optional<ResultType> RunStep() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
     ScopedActivity scoped_activity(this);
     ScopedContext contexts(this);
     return StepLoop();
@@ -617,7 +617,7 @@ class PromiseActivity final
   // Similarly to RunStep, but additionally construct the promise from a
   // promise factory before entering the main loop. Called once from the
   // constructor.
-  absl::optional<ResultType> Start(Factory promise_factory)
+  std::optional<ResultType> Start(Factory promise_factory)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
     ScopedActivity scoped_activity(this);
     ScopedContext contexts(this);
@@ -627,7 +627,7 @@ class PromiseActivity final
 
   // Until there are no wakeups from within and the promise is incomplete:
   // poll the promise.
-  absl::optional<ResultType> StepLoop() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
+  std::optional<ResultType> StepLoop() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
     CHECK(is_current());
     while (true) {
       // Run the promise.

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

@@ -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,37 +79,30 @@ 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<
-#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_;
 
@@ -121,6 +114,10 @@ class PromiseLike<F, absl::enable_if_t<std::is_void<
     f_();
     return Empty{};
   }
+  PromiseLike(const PromiseLike&) = default;
+  PromiseLike& operator=(const PromiseLike&) = default;
+  PromiseLike(PromiseLike&&) = default;
+  PromiseLike& operator=(PromiseLike&&) = default;
   using Result = Empty;
 };