grpc 1.78.0 → 1.80.0.pre1

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

@@ -137,8 +137,8 @@ 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(OnceToken, F f, A&&) {
-  return PromiseLike<F>(std::move(f));
+PromiseFactoryImpl(OnceToken, F&& f, A&&) {
+  return PromiseLike<F>(std::forward<RemoveCVRef<F>>(f));
 }
 
 // Promote a callable() -> Poll<T> to a PromiseFactory() -> Promise<T>
@@ -147,8 +147,8 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline absl::enable_if_t<
     !IsVoidCallable<ResultOf<F()>>::value &&
         PollTraits<ResultOf<F()>>::is_poll(),
     PromiseLike<RemoveCVRef<F>>>
-PromiseFactoryImpl(OnceToken, F f) {
-  return PromiseLike<F>(std::move(f));
+PromiseFactoryImpl(OnceToken, F&& f) {
+  return PromiseLike<RemoveCVRef<F>>(std::forward<F>(f));
 }
 
 // Promote a callable() -> T to a PromiseFactory() -> Immediate<T>
@@ -158,7 +158,7 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto PromiseFactoryImpl(
                          !PollTraits<ResultOf<F()>>::is_poll() &&
                          !std::is_same_v<ResultOf<F()>, void>,
                      OnceToken>,
-    F f) {
+    F&& f) {
   auto f2 = [x = f()]() mutable { return std::move(x); };
   return PromiseLike<decltype(f2)>(std::move(f2));
 }
@@ -168,7 +168,7 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto PromiseFactoryImpl(
                          !PollTraits<ResultOf<F()>>::is_poll() &&
                          std::is_same_v<ResultOf<F()>, void>,
                      OnceToken>,
-    F f) {
+    F&& f) {
   f();
   auto f2 = []() { return Empty{}; };
   return PromiseLike<decltype(f2)>(std::move(f2));
@@ -225,8 +225,8 @@ class OncePromiseFactory {
                                               std::declval<A>()));
   using UnderlyingFactory = F;
 
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit OncePromiseFactory(F f)
-      : f_(std::move(f)) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit OncePromiseFactory(F&& f)
+      : f_(std::forward<F>(f)) {}
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make(Arg&& a) {
     return PromiseFactoryImpl(OnceToken{}, std::move(f_), std::forward<Arg>(a));
@@ -243,8 +243,8 @@ class OncePromiseFactory<void, F> {
   using Promise = decltype(PromiseFactoryImpl(OnceToken{}, std::move(f_)));
   using UnderlyingFactory = F;
 
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit OncePromiseFactory(F f)
-      : f_(std::move(f)) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit OncePromiseFactory(F&& f)
+      : f_(std::forward<F>(f)) {}
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make() {
     return PromiseFactoryImpl(OnceToken{}, std::move(f_));
@@ -265,8 +265,8 @@ class RepeatedPromiseFactory {
   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 explicit RepeatedPromiseFactory(F&& f)
+      : f_(std::forward<F>(f)) {}
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make(Arg&& a) const {
     return PromiseFactoryImpl(RepeatableToken{}, f_, std::forward<Arg>(a));
@@ -293,8 +293,8 @@ class RepeatedPromiseFactory<void, F> {
   using Arg = void;
   using Promise = decltype(PromiseFactoryImpl(RepeatableToken{}, f_));
 
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit RepeatedPromiseFactory(F f)
-      : f_(std::move(f)) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit RepeatedPromiseFactory(F&& f)
+      : f_(std::forward<F>(f)) {}
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make() const {
     return PromiseFactoryImpl(RepeatableToken{}, f_);

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

@@ -19,6 +19,7 @@
 #include <stdint.h>
 
 #include <string>
+#include <type_traits>
 #include <utility>
 
 #include "src/core/lib/debug/trace.h"
@@ -124,10 +125,10 @@ class ForEach {
  public:
   using Result = decltype(Done<ActionResult>::Make(false));
 
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ForEach(Reader reader, Action action,
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ForEach(Reader&& reader, Action&& action,
                                                DebugLocation whence = {})
-      : reader_(std::move(reader)),
-        action_factory_(std::move(action)),
+      : reader_(std::forward<Reader>(reader)),
+        action_factory_(std::forward<Action>(action)),
         whence_(whence) {
     Construct(&reader_next_, reader_.Next());
   }
@@ -164,10 +165,33 @@ class ForEach {
     return PollAction();
   }
 
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    auto* for_each_promise =
+        grpc_channelz_v2_Promise_mutable_for_each_promise(promise_proto, arena);
+
+    grpc_channelz_v2_Promise_ForEach_set_reader_factory(
+        for_each_promise, StdStringToUpbString(TypeName<Reader>()));
+    grpc_channelz_v2_Promise_ForEach_set_action_factory(
+        for_each_promise, StdStringToUpbString(TypeName<ActionFactory>()));
+    if (reading_next_) {
+      PromiseAsProto(reader_next_,
+                     grpc_channelz_v2_Promise_ForEach_mutable_reader_promise(
+                         for_each_promise, arena),
+                     arena);
+    } else {
+      PromiseAsProto(in_action_.promise,
+                     grpc_channelz_v2_Promise_ForEach_mutable_action_promise(
+                         for_each_promise, arena),
+                     arena);
+    }
+  }
+
  private:
   struct InAction {
-    InAction(ActionPromise promise, ReaderResult result)
-        : promise(std::move(promise)), result(std::move(result)) {}
+    InAction(ActionPromise&& promise, ReaderResult&& result)
+        : promise(std::forward<ActionPromise>(promise)),
+          result(std::forward<ReaderResult>(result)) {}
     ActionPromise promise;
     ReaderResult result;
   };
@@ -240,9 +264,9 @@ class ForEach {
 template <typename Reader, typename Action>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline for_each_detail::ForEach<Reader,
                                                                      Action>
-ForEach(Reader reader, Action action, DebugLocation whence = {}) {
-  return for_each_detail::ForEach<Reader, Action>(std::move(reader),
-                                                  std::move(action), whence);
+ForEach(Reader&& reader, Action&& action, DebugLocation whence = {}) {
+  return for_each_detail::ForEach<std::decay_t<Reader>, std::decay_t<Action>>(
+      std::forward<Reader>(reader), std::forward<Action>(action), whence);
 }
 
 }  // namespace grpc_core

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

@@ -113,10 +113,11 @@ class If {
       typename PollTraits<decltype(std::declval<TruePromise>()())>::Type;
 
  public:
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION If(C condition, T if_true, F if_false)
-      : state_(Evaluating{ConditionPromise(std::move(condition)),
-                          TrueFactory(std::move(if_true)),
-                          FalseFactory(std::move(if_false))}) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION If(C&& condition, T&& if_true,
+                                          F&& if_false)
+      : state_(Evaluating{ConditionPromise(std::forward<C>(condition)),
+                          TrueFactory(std::forward<T>(if_true)),
+                          FalseFactory(std::forward<F>(if_false))}) {}
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> operator()() {
     return std::visit(CallPoll<false>{this}, state_);
@@ -173,10 +174,11 @@ class If<bool, T, F> {
       typename PollTraits<decltype(std::declval<TruePromise>()())>::Type;
 
  public:
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION If(bool condition, T if_true, F if_false)
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION If(bool condition, T&& if_true,
+                                          F&& if_false)
       : condition_(condition) {
-    TrueFactory true_factory(std::move(if_true));
-    FalseFactory false_factory(std::move(if_false));
+    TrueFactory true_factory(std::forward<T>(if_true));
+    FalseFactory false_factory(std::forward<F>(if_false));
     if (condition_) {
       Construct(&if_true_, true_factory.Make());
     } else {

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

@@ -17,6 +17,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <cstddef>
 #include <utility>
 #include <variant>
 
@@ -137,8 +138,8 @@ class Loop {
  public:
   using Result = typename promise_detail::LoopTraits<PromiseResult>::Result;
 
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Loop(F f)
-      : factory_(std::move(f)) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Loop(F&& f)
+      : factory_(std::forward<F>(f)) {}
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~Loop() {
     if (started_) Destruct(&promise_);
   }
@@ -223,18 +224,18 @@ Loop(F) -> Loop<F, false>;
 // A version of Loop that yields the activity to another promise once per
 // iteration.
 template <typename F>
-auto YieldingLoop(F f) {
-  return Loop<F, true>(std::move(f));
+auto YieldingLoop(F&& f) {
+  return Loop<F, true>(std::forward<F>(f));
 }
 
 template <typename PromiseFactory>
-auto NTimes(size_t times, PromiseFactory promise_factory) {
+auto NTimes(size_t times, PromiseFactory&& promise_factory) {
   DCHECK_GT(times, 1u);
   return Loop(
       [i = size_t{0}, times,
        promise_factory =
            promise_detail::RepeatedPromiseFactory<size_t, PromiseFactory>(
-               std::move(promise_factory))]() mutable {
+               std::forward<PromiseFactory>(promise_factory))]() mutable {
         return Seq(promise_factory.Make(i), [&i, times](auto result) {
           using Result = decltype(result);
           LoopCtl<Result> lc = std::move(result);
@@ -246,16 +247,17 @@ auto NTimes(size_t times, PromiseFactory promise_factory) {
 }
 
 template <typename PromiseFactory>
-auto WhilstSuccessful(PromiseFactory promise_factory) {
-  return Loop([promise_factory =
-                   promise_detail::RepeatedPromiseFactory<void, PromiseFactory>(
-                       std::move(promise_factory))]() mutable {
-    return Seq(promise_factory.Make(), [](auto result) {
-      using Result = decltype(result);
-      if (result.ok()) return LoopCtl<Result>(Continue());
-      return LoopCtl<Result>(std::move(result));
-    });
-  });
+auto WhilstSuccessful(PromiseFactory&& promise_factory) {
+  return Loop(
+      [promise_factory =
+           promise_detail::RepeatedPromiseFactory<void, PromiseFactory>(
+               std::forward<PromiseFactory>(promise_factory))]() mutable {
+        return Seq(promise_factory.Make(), [](auto result) {
+          using Result = decltype(result);
+          if (result.ok()) return LoopCtl<Result>(Continue());
+          return LoopCtl<Result>(std::move(result));
+        });
+      });
 }
 
 }  // namespace grpc_core

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

@@ -135,8 +135,8 @@ class Map {
   using PromiseType = promise_detail::PromiseLike<Promise>;
 
  public:
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Map(Promise promise, Fn fn)
-      : promise_(std::move(promise)), fn_(std::move(fn)) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Map(Promise&& promise, Fn&& fn)
+      : promise_(std::forward<Promise>(promise)), fn_(std::forward<Fn>(fn)) {}
 
   Map(const Map&) = delete;
   Map& operator=(const Map&) = delete;
@@ -185,9 +185,9 @@ class Map<Map<Promise, Fn0>, Fn1> {
   using PromiseType = typename Map<Promise, Fn0>::PromiseType;
 
  public:
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Map(Map<Promise, Fn0> map, Fn1 fn1)
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Map(Map<Promise, Fn0> map, Fn1&& fn1)
       : promise_(std::move(map.promise_)),
-        fn_(FusedFn(std::move(map.fn_), std::move(fn1))) {}
+        fn_(FusedFn(std::move(map.fn_), std::forward<Fn1>(fn1))) {}
 
   Map(const Map&) = delete;
   Map& operator=(const Map&) = delete;
@@ -228,23 +228,25 @@ class Map<Map<Promise, Fn0>, Fn1> {
 };
 
 template <typename Promise, typename Fn>
-Map(Promise, Fn) -> Map<Promise, Fn>;
+Map(Promise&&, Fn&&) -> Map<std::decay_t<Promise>, std::decay_t<Fn>>;
 
 // Maps a promise to a new promise that returns a tuple of the original result
 // and a bool indicating whether there was ever a Pending{} value observed from
 // polling.
 template <typename Promise>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto CheckDelayed(Promise promise) {
-  using P = promise_detail::PromiseLike<Promise>;
-  return [delayed = false, promise = P(std::move(promise))]() mutable
-             -> Poll<std::tuple<typename P::Result, bool>> {
-    auto r = promise();
-    if (r.pending()) {
-      delayed = true;
-      return Pending{};
-    }
-    return std::tuple(std::move(r.value()), delayed);
-  };
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto CheckDelayed(
+    Promise&& promise) {
+  using P = promise_detail::PromiseLike<std::decay_t<Promise>>;
+  return
+      [delayed = false, promise = P(std::forward<Promise>(promise))]() mutable
+          -> Poll<std::tuple<typename P::Result, bool>> {
+        auto r = promise();
+        if (r.pending()) {
+          delayed = true;
+          return Pending{};
+        }
+        return std::tuple(std::move(r.value()), delayed);
+      };
 }
 
 // Callable that takes a tuple and returns one element
@@ -266,7 +268,7 @@ namespace promise_detail {
 template <typename Fn>
 class MapError {
  public:
-  explicit MapError(Fn fn) : fn_(std::move(fn)) {}
+  explicit MapError(Fn&& fn) : fn_(std::forward<Fn>(fn)) {}
   absl::Status operator()(absl::Status status) {
     if (status.ok()) return status;
     return fn_(std::move(status));
@@ -284,33 +286,37 @@ class MapError {
 
 // Map status->better status in the case of errors
 template <typename Promise, typename Fn>
-auto MapErrors(Promise promise, Fn fn) {
-  return Map(std::move(promise), promise_detail::MapError<Fn>(std::move(fn)));
+auto MapErrors(Promise&& promise, Fn&& fn) {
+  return Map(std::forward<Promise>(promise),
+             promise_detail::MapError<std::decay_t<Fn>>(std::forward<Fn>(fn)));
 }
 
 // Simple mapper to add a prefix to the message of an error
 template <typename Promise>
-auto AddErrorPrefix(absl::string_view prefix, Promise promise) {
-  return MapErrors(std::move(promise), [prefix](absl::Status status) {
-    absl::Status out(status.code(), absl::StrCat(prefix, status.message()));
-    status.ForEachPayload(
-        [&out](absl::string_view name, const absl::Cord& value) {
-          out.SetPayload(name, value);
-        });
-    return out;
-  });
+auto AddErrorPrefix(absl::string_view prefix, Promise&& promise) {
+  return MapErrors(
+      std::forward<Promise>(promise), [prefix](absl::Status status) {
+        absl::Status out(status.code(), absl::StrCat(prefix, status.message()));
+        status.ForEachPayload(
+            [&out](absl::string_view name, const absl::Cord& value) {
+              out.SetPayload(name, value);
+            });
+        return out;
+      });
 }
 
 template <typename Gen, typename Promise>
-auto AddGeneratedErrorPrefix(Gen prefix, Promise promise) {
-  return MapErrors(std::move(promise), [prefix](absl::Status status) {
-    absl::Status out(status.code(), absl::StrCat(prefix(), status.message()));
-    status.ForEachPayload(
-        [&out](absl::string_view name, const absl::Cord& value) {
-          out.SetPayload(name, value);
-        });
-    return out;
-  });
+auto AddGeneratedErrorPrefix(Gen&& prefix, Promise&& promise) {
+  return MapErrors(std::forward<Promise>(promise),
+                   [prefix = std::forward<Gen>(prefix)](absl::Status status) {
+                     absl::Status out(status.code(),
+                                      absl::StrCat(prefix(), status.message()));
+                     status.ForEachPayload([&out](absl::string_view name,
+                                                  const absl::Cord& value) {
+                       out.SetPayload(name, value);
+                     });
+                     return out;
+                   });
 }
 
 // Input : A promise that resolves to Type T
@@ -321,26 +327,27 @@ auto AddGeneratedErrorPrefix(Gen prefix, Promise promise) {
 // gives an error. DiscardResult helps to discard the return value of the
 // promise.
 template <typename Promise>
-auto DiscardResult(Promise promise) {
-  return Map(std::move(promise), [](auto) {});
+auto DiscardResult(Promise&& promise) {
+  return Map(std::forward<Promise>(promise), [](auto) {});
 }
 
 // Given a promise, and N values, return a tuple with the resolved promise
 // first, and then the N values stapled to it.
 template <typename Promise, typename... Values>
-auto Staple(Promise promise, Values&&... values) {
-  return Map(std::move(promise), [values = std::tuple(std::forward<Values>(
-                                      values)...)](auto first_value) mutable {
-    return std::tuple_cat(std::tuple(std::move(first_value)),
-                          std::move(values));
-  });
+auto Staple(Promise&& promise, Values&&... values) {
+  return Map(std::forward<Promise>(promise),
+             [values = std::tuple(std::forward<Values>(values)...)](
+                 auto first_value) mutable {
+               return std::tuple_cat(std::tuple(std::move(first_value)),
+                                     std::move(values));
+             });
 }
 
 // Same as Staple, but assumes a StatusOr<X>, and returns X, Values.
 template <typename Promise, typename... Values>
-auto TryStaple(Promise promise, Values&&... values) {
+auto TryStaple(Promise&& promise, Values&&... values) {
   return Map(
-      std::move(promise),
+      std::forward<Promise>(promise),
       [values = std::tuple(std::forward<std::remove_reference_t<Values>>(
            values)...)](auto first_value) mutable
           -> absl::StatusOr<

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

@@ -264,8 +264,8 @@ template <typename T>
 class Center : public RefCounted<Center<T>, NonPolymorphicRefCount> {
  private:
   struct Node final : public Mpsc::Node {
-    explicit Node(uint32_t tokens, T value)
-        : Mpsc::Node(tokens), value(std::move(value)) {}
+    explicit Node(uint32_t tokens, T&& value)
+        : Mpsc::Node(tokens), value(std::forward<T>(value)) {}
     T value;
   };
 
@@ -316,12 +316,13 @@ class Center : public RefCounted<Center<T>, NonPolymorphicRefCount> {
     RefCountedPtr<Center<T>> center_;
   };
 
-  auto Send(T value, uint32_t tokens) {
-    return mpsc_.Send(new Node(tokens, std::move(value)));
+  auto Send(T&& value, uint32_t tokens) {
+    return mpsc_.Send(new Node(tokens, std::forward<T>(value)));
   }
 
-  StatusFlag UnbufferedImmediateSend(T value, uint32_t tokens) {
-    return mpsc_.UnbufferedImmediateSend(new Node(tokens, std::move(value)));
+  StatusFlag UnbufferedImmediateSend(T&& value, uint32_t tokens) {
+    return mpsc_.UnbufferedImmediateSend(
+        new Node(tokens, std::forward<T>(value)));
   }
 
   auto Next() {
@@ -392,13 +393,13 @@ class MpscSender {
   // The promise returned is thread safe. We can use multiple send calls
   // in parallel to generate multiple such send promises and these promises can
   // be run in parallel in a thread safe way.
-  auto Send(T t, uint32_t tokens) {
-    return Map(center_->Send(std::move(t), tokens),
+  auto Send(T&& t, uint32_t tokens) {
+    return Map(center_->Send(std::forward<T>(t), tokens),
                [c = center_](auto x) { return x; });
   }
 
-  StatusFlag UnbufferedImmediateSend(T t, uint32_t tokens) {
-    return center_->UnbufferedImmediateSend(std::move(t), tokens);
+  StatusFlag UnbufferedImmediateSend(T&& t, uint32_t tokens) {
+    return center_->UnbufferedImmediateSend(std::forward<T>(t), tokens);
   }
 
  private:

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

@@ -31,8 +31,8 @@ template <typename T>
 class Observable {
  public:
   // We need to assign a value initially.
-  explicit Observable(T initial)
-      : state_(MakeRefCounted<State>(std::move(initial))) {}
+  explicit Observable(T&& initial)
+      : state_(MakeRefCounted<State>(std::forward<T>(initial))) {}
 
   // Update the value to something new. Awakes any waiters.
   void Set(T value) { state_->Set(std::move(value)); }
@@ -41,8 +41,8 @@ class Observable {
   // that value.
   // is_acceptable is any invocable that takes a `const T&` and returns a bool.
   template <typename F>
-  auto NextWhen(F is_acceptable) {
-    return ObserverWhen<F>(state_, std::move(is_acceptable));
+  auto NextWhen(F&& is_acceptable) {
+    return ObserverWhen<F>(state_, std::forward<F>(is_acceptable));
   }
 
   // Returns a promise that resolves to a T when the value becomes != current.
@@ -157,9 +157,9 @@ class Observable {
   template <typename F>
   class ObserverWhen : public Observer {
    public:
-    ObserverWhen(RefCountedPtr<State> state, F is_acceptable)
+    ObserverWhen(RefCountedPtr<State> state, F&& is_acceptable)
         : Observer(std::move(state)),
-          is_acceptable_(std::move(is_acceptable)) {}
+          is_acceptable_(std::forward<F>(is_acceptable)) {}
 
     ObserverWhen(ObserverWhen&& other) noexcept
         : Observer(std::move(other)),

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

@@ -280,10 +280,12 @@ class Party : public Activity, private Wakeable {
     // spawning of promises is expected to be serialized by some external entity
     // (usually this is a Seq running on a different party).
     template <class Factory>
-    void Spawn(Factory factory) {
+    void Spawn(Factory&& factory) {
       auto empty_completion = [](Empty) {};
-      next_.Push(new ParticipantImpl<Factory, decltype(empty_completion)>(
-          "SpawnSerializer", std::move(factory), empty_completion));
+      next_.Push(new ParticipantImpl<std::decay_t<Factory>,
+                                     decltype(empty_completion)>(
+          "SpawnSerializer", std::forward<Factory>(factory),
+          std::move(empty_completion)));
       party_->WakeupFromState<false>(
           party_->state_.load(std::memory_order_relaxed), wakeup_mask_);
     }
@@ -338,11 +340,11 @@ class Party : public Activity, private Wakeable {
   // A party can hold upto 16 unresolved promises at a time. However, this
   // number might change in the future.
   template <typename Factory, typename OnComplete>
-  void Spawn(absl::string_view name, Factory promise_factory,
-             OnComplete on_complete);
+  void Spawn(absl::string_view name, Factory&& promise_factory,
+             OnComplete&& on_complete);
 
   template <typename Factory>
-  auto SpawnWaitable(absl::string_view name, Factory factory);
+  auto SpawnWaitable(absl::string_view name, Factory&& factory);
 
   void Orphan() final { Crash("unused"); }
 
@@ -430,10 +432,10 @@ class Party : public Activity, private Wakeable {
     using Promise = typename Factory::Promise;
 
    public:
-    ParticipantImpl(absl::string_view, SuppliedFactory promise_factory,
-                    OnComplete on_complete)
-        : on_complete_(std::move(on_complete)) {
-      Construct(&factory_, std::move(promise_factory));
+    ParticipantImpl(absl::string_view, SuppliedFactory&& promise_factory,
+                    OnComplete&& on_complete)
+        : on_complete_(std::forward<OnComplete>(on_complete)) {
+      Construct(&factory_, std::forward<SuppliedFactory>(promise_factory));
     }
     ~ParticipantImpl() {
       if (!started_) {
@@ -492,8 +494,9 @@ class Party : public Activity, private Wakeable {
     using Result = typename Promise::Result;
 
    public:
-    PromiseParticipantImpl(absl::string_view, SuppliedFactory promise_factory) {
-      Construct(&factory_, std::move(promise_factory));
+    PromiseParticipantImpl(absl::string_view,
+                           SuppliedFactory&& promise_factory) {
+      Construct(&factory_, std::forward<SuppliedFactory>(promise_factory));
     }
 
     ~PromiseParticipantImpl() {
@@ -716,18 +719,21 @@ struct ContextSubclass<Party> {
 };
 
 template <typename Factory, typename OnComplete>
-void Party::Spawn(absl::string_view name, Factory promise_factory,
-                  OnComplete on_complete) {
+void Party::Spawn(absl::string_view name, Factory&& promise_factory,
+                  OnComplete&& on_complete) {
   GRPC_TRACE_LOG(party_state, INFO) << "PARTY[" << this << "]: spawn " << name;
-  MaybeAsyncAddParticipant(new ParticipantImpl<Factory, OnComplete>(
-      name, std::move(promise_factory), std::move(on_complete)));
+  MaybeAsyncAddParticipant(
+      new ParticipantImpl<std::decay_t<Factory>, std::decay_t<OnComplete>>(
+          name, std::forward<Factory>(promise_factory),
+          std::forward<OnComplete>(on_complete)));
 }
 
 template <typename Factory>
-auto Party::SpawnWaitable(absl::string_view name, Factory promise_factory) {
+auto Party::SpawnWaitable(absl::string_view name, Factory&& promise_factory) {
   GRPC_TRACE_LOG(party_state, INFO) << "PARTY[" << this << "]: spawn " << name;
-  auto participant = MakeRefCounted<PromiseParticipantImpl<Factory>>(
-      name, std::move(promise_factory));
+  auto participant =
+      MakeRefCounted<PromiseParticipantImpl<std::decay_t<Factory>>>(
+          name, std::forward<Factory>(promise_factory));
   Participant* p = participant->Ref().release();
   MaybeAsyncAddParticipant(p);
   return [participant = std::move(participant)]() mutable {

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

@@ -248,27 +248,27 @@ struct PollCastImpl<T, Poll<U>> {
 template <typename T, typename U>
 struct PollCastImpl<T, U, std::enable_if<!PollTraits<U>::is_poll()>> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<T> Cast(U&& poll) {
-    return Poll<T>(T(std::move(poll)));
+    return Poll<T>(T(std::forward<U>(poll)));
   }
 };
 
 template <typename T>
 struct PollCastImpl<T, T> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<T> Cast(T&& poll) {
-    return Poll<T>(std::move(poll));
+    return Poll<T>(std::forward<T>(poll));
   }
 };
 
 template <typename T>
 struct PollCastImpl<T, Poll<T>> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<T> Cast(Poll<T>&& poll) {
-    return std::move(poll);
+    return std::forward<Poll<T>>(poll);
   }
 };
 
 template <typename T, typename U>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline Poll<T> poll_cast(U poll) {
-  return PollCastImpl<T, U>::Cast(std::move(poll));
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline Poll<T> poll_cast(U&& poll) {
+  return PollCastImpl<T, U>::Cast(std::forward<U>(poll));
 }
 
 template <typename T>