grpc 1.78.0 → 1.80.0.pre1

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

@@ -28,8 +28,8 @@ class TwoPartyPrioritizedRace {
  public:
   using Result = decltype(std::declval<A>()());
 
-  explicit TwoPartyPrioritizedRace(A a, B b)
-      : a_(std::move(a)), b_(std::move(b)) {}
+  explicit TwoPartyPrioritizedRace(A&& a, B&& b)
+      : a_(std::forward<A>(a)), b_(std::forward<B>(b)) {}
 
   Result operator()() {
     // Check the priority promise.
@@ -63,17 +63,20 @@ class PrioritizedRace<Promise, Promises...>
     : public TwoPartyPrioritizedRace<Promise, PrioritizedRace<Promises...>> {
  public:
   using Result = decltype(std::declval<Promise>()());
-  explicit PrioritizedRace(Promise promise, Promises... promises)
-      : TwoPartyPrioritizedRace<Promise, PrioritizedRace<Promises...>>(
-            std::move(promise),
-            PrioritizedRace<Promises...>(std::move(promises)...)) {}
+  explicit PrioritizedRace(Promise&& promise, Promises&&... promises)
+      : TwoPartyPrioritizedRace<std::decay_t<Promise>,
+                                std::decay_t<PrioritizedRace<Promises...>>>(
+            std::forward<Promise>(promise),
+            PrioritizedRace<std::decay_t<Promises>...>(
+                std::forward<Promises>(promises)...)) {}
 };
 
 template <typename Promise>
 class PrioritizedRace<Promise> {
  public:
   using Result = decltype(std::declval<Promise>()());
-  explicit PrioritizedRace(Promise promise) : promise_(std::move(promise)) {}
+  explicit PrioritizedRace(Promise&& promise)
+      : promise_(std::forward<Promise>(promise)) {}
   Result operator()() { return promise_(); }
 
  private:

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

@@ -36,9 +36,10 @@ using Promise = absl::AnyInvocable<Poll<T>()>;
 // Helper to execute a promise immediately and return either the result or
 // nothing.
 template <typename Promise>
-auto NowOrNever(Promise promise)
-    -> std::optional<typename promise_detail::PromiseLike<Promise>::Result> {
-  auto r = promise_detail::PromiseLike<Promise>(std::move(promise))();
+auto NowOrNever(Promise&& promise) -> std::optional<
+    typename promise_detail::PromiseLike<std::decay_t<Promise>>::Result> {
+  auto r = promise_detail::PromiseLike<std::decay_t<Promise>>(
+      std::forward<Promise>(promise))();
   if (auto* p = r.value_if_ready()) {
     return std::move(*p);
   }
@@ -56,9 +57,13 @@ namespace promise_detail {
 template <typename T>
 class Immediate {
  public:
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Immediate(T value)
+  template <typename U>
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Immediate(U value)
       : value_(std::move(value)) {}
 
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Immediate(T&& value)
+      : value_(std::forward<T>(value)) {}
+
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<T> operator()() {
     return std::move(value_);
   }
@@ -70,9 +75,10 @@ class Immediate {
 
 // Return \a value immediately
 template <typename T>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::Immediate<T>
-Immediate(T value) {
-  return promise_detail::Immediate<T>(std::move(value));
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::Immediate<
+    std::decay_t<T>>
+Immediate(T&& value) {
+  return promise_detail::Immediate<std::decay_t<T>>(std::forward<T>(value));
 }
 
 // Return status Ok immediately
@@ -88,10 +94,9 @@ struct ImmediateOkStatus {
 // should fail to compile. When modifying this code these should be uncommented
 // and their miscompilation verified.
 template <typename T, typename F>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto AssertResultType(F f) ->
-    typename std::enable_if<std::is_same<decltype(f()), Poll<T>>::value,
-                            F>::type {
-  return f;
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto AssertResultType(F&& f) ->
+    typename std::enable_if_t<std::is_same_v<decltype(f()), Poll<T>>, F> {
+  return std::forward<F>(f);
 }
 
 template <typename Promise>

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

@@ -35,9 +35,10 @@ class Race<Promise, Promises...> {
  public:
   using Result = decltype(std::declval<Promise>()());
 
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Race(Promise promise,
-                                                     Promises... promises)
-      : promise_(std::move(promise)), next_(std::move(promises)...) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Race(Promise&& promise,
+                                                     Promises&&... promises)
+      : promise_(std::forward<Promise>(promise)),
+        next_(std::forward<Promises>(promises)...) {}
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Result operator()() {
     // Check our own promise.
@@ -79,8 +80,8 @@ template <typename Promise>
 class Race<Promise> {
  public:
   using Result = decltype(std::declval<Promise>()());
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Race(Promise promise)
-      : promise_(std::move(promise)) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Race(Promise&& promise)
+      : promise_(std::forward<Promise>(promise)) {}
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Result operator()() {
     return promise_();
   }

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

@@ -90,8 +90,8 @@ struct SeqTraits {
   }
   template <typename Result, typename PriorResult, typename RunNext>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
-  CheckResultAndRunNext(PriorResult prior, RunNext run_next) {
-    return run_next(std::move(prior));
+  CheckResultAndRunNext(PriorResult&& prior, RunNext run_next) {
+    return run_next(std::forward<PriorResult>(prior));
   }
 };
 
@@ -128,113 +128,146 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline F Seq(F functor) {
 }
 
 template <typename F0, typename F1>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::Seq<F0, F1> Seq(
-    F0 f0, F1 f1, DebugLocation whence = {}) {
-  return promise_detail::Seq<F0, F1>(std::move(f0), std::move(f1), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto Seq(
+    F0&& f0, F1&& f1, DebugLocation whence = {}) {
+  return promise_detail::Seq<std::decay_t<F0>, std::decay_t<F1>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), whence);
 }
 
 template <typename F0, typename F1, typename F2>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::Seq<F0, F1, F2> Seq(
-    F0 f0, F1 f1, F2 f2, DebugLocation whence = {}) {
-  return promise_detail::Seq<F0, F1, F2>(std::move(f0), std::move(f1),
-                                         std::move(f2), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto Seq(
+    F0&& f0, F1&& f1, F2&& f2, DebugLocation whence = {}) {
+  return promise_detail::Seq<std::decay_t<F0>, std::decay_t<F1>,
+                             std::decay_t<F2>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::Seq<F0, F1, F2, F3>
-Seq(F0 f0, F1 f1, F2 f2, F3 f3, DebugLocation whence = {}) {
-  return promise_detail::Seq<F0, F1, F2, F3>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto Seq(
+    F0&& f0, F1&& f1, F2&& f2, F3&& f3, DebugLocation whence = {}) {
+  return promise_detail::Seq<std::decay_t<F0>, std::decay_t<F1>,
+                             std::decay_t<F2>, std::decay_t<F3>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::Seq<F0, F1, F2, F3,
-                                                                F4>
-Seq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, DebugLocation whence = {}) {
-  return promise_detail::Seq<F0, F1, F2, F3, F4>(std::move(f0), std::move(f1),
-                                                 std::move(f2), std::move(f3),
-                                                 std::move(f4), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto Seq(
+    F0&& f0, F1&& f1, F2&& f2, F3&& f3, F4&& f4, DebugLocation whence = {}) {
+  return promise_detail::Seq<std::decay_t<F0>, std::decay_t<F1>,
+                             std::decay_t<F2>, std::decay_t<F3>,
+                             std::decay_t<F4>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), std::forward<F4>(f4), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::Seq<F0, F1, F2, F3,
-                                                                F4, F5>
-Seq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, DebugLocation whence = {}) {
-  return promise_detail::Seq<F0, F1, F2, F3, F4, F5>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
-      std::move(f5), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto Seq(
+    F0&& f0, F1&& f1, F2&& f2, F3&& f3, F4&& f4, F5&& f5,
+    DebugLocation whence = {}) {
+  return promise_detail::Seq<std::decay_t<F0>, std::decay_t<F1>,
+                             std::decay_t<F2>, std::decay_t<F3>,
+                             std::decay_t<F4>, std::decay_t<F5>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), std::forward<F4>(f4), std::forward<F5>(f5), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
-    promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6>
-    Seq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6,
-        DebugLocation whence = {}) {
-  return promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
-      std::move(f5), std::move(f6), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Seq(F0&& f0, F1&& f1, F2&& f2,
+                                              F3&& f3, F4&& f4, F5&& f5,
+                                              F6&& f6,
+                                              DebugLocation whence = {}) {
+  return promise_detail::Seq<
+      std::decay_t<F0>, std::decay_t<F1>, std::decay_t<F2>, std::decay_t<F3>,
+      std::decay_t<F4>, std::decay_t<F5>, std::decay_t<F6>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), std::forward<F4>(f4), std::forward<F5>(f5),
+      std::forward<F6>(f6), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6, typename F7>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
-    promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7>
-    Seq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7,
-        DebugLocation whence = {}) {
-  return promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
-      std::move(f5), std::move(f6), std::move(f7), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Seq(F0&& f0, F1&& f1, F2&& f2,
+                                              F3&& f3, F4&& f4, F5&& f5,
+                                              F6&& f6, F7&& f7,
+                                              DebugLocation whence = {}) {
+  return promise_detail::Seq<
+      std::decay_t<F0>, std::decay_t<F1>, std::decay_t<F2>, std::decay_t<F3>,
+      std::decay_t<F4>, std::decay_t<F5>, std::decay_t<F6>, std::decay_t<F7>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), std::forward<F4>(f4), std::forward<F5>(f5),
+      std::forward<F6>(f6), std::forward<F7>(f7), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6, typename F7, typename F8>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
-    promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8>
-    Seq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7, F8 f8,
-        DebugLocation whence = {}) {
-  return promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
-      std::move(f5), std::move(f6), std::move(f7), std::move(f8), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Seq(F0&& f0, F1&& f1, F2&& f2,
+                                              F3&& f3, F4&& f4, F5&& f5,
+                                              F6&& f6, F7&& f7, F8&& f8,
+                                              DebugLocation whence = {}) {
+  return promise_detail::Seq<
+      std::decay_t<F0>, std::decay_t<F1>, std::decay_t<F2>, std::decay_t<F3>,
+      std::decay_t<F4>, std::decay_t<F5>, std::decay_t<F6>, std::decay_t<F7>,
+      std::decay_t<F8>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), std::forward<F4>(f4), std::forward<F5>(f5),
+      std::forward<F6>(f6), std::forward<F7>(f7), std::forward<F8>(f8), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6, typename F7, typename F8, typename F9>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
-    promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9>
-    Seq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7, F8 f8, F9 f9,
-        DebugLocation whence = {}) {
-  return promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
-      std::move(f5), std::move(f6), std::move(f7), std::move(f8), std::move(f9),
-      whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Seq(F0&& f0, F1&& f1, F2&& f2,
+                                              F3&& f3, F4&& f4, F5&& f5,
+                                              F6&& f6, F7&& f7, F8&& f8,
+                                              F9&& f9,
+                                              DebugLocation whence = {}) {
+  return promise_detail::Seq<
+      std::decay_t<F0>, std::decay_t<F1>, std::decay_t<F2>, std::decay_t<F3>,
+      std::decay_t<F4>, std::decay_t<F5>, std::decay_t<F6>, std::decay_t<F7>,
+      std::decay_t<F8>, std::decay_t<F9>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), std::forward<F4>(f4), std::forward<F5>(f5),
+      std::forward<F6>(f6), std::forward<F7>(f7), std::forward<F8>(f8),
+      std::forward<F9>(f9), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6, typename F7, typename F8, typename F9,
           typename F10>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
-    promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10>
-    Seq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7, F8 f8, F9 f9,
-        F10 f10, DebugLocation whence = {}) {
-  return promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
-      std::move(f5), std::move(f6), std::move(f7), std::move(f8), std::move(f9),
-      std::move(f10), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Seq(F0&& f0, F1&& f1, F2&& f2,
+                                              F3&& f3, F4&& f4, F5&& f5,
+                                              F6&& f6, F7&& f7, F8&& f8,
+                                              F9&& f9, F10&& f10,
+                                              DebugLocation whence = {}) {
+  return promise_detail::Seq<
+      std::decay_t<F0>, std::decay_t<F1>, std::decay_t<F2>, std::decay_t<F3>,
+      std::decay_t<F4>, std::decay_t<F5>, std::decay_t<F6>, std::decay_t<F7>,
+      std::decay_t<F8>, std::decay_t<F9>, std::decay_t<F10>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), std::forward<F4>(f4), std::forward<F5>(f5),
+      std::forward<F6>(f6), std::forward<F7>(f7), std::forward<F8>(f8),
+      std::forward<F9>(f9), std::forward<F10>(f10), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6, typename F7, typename F8, typename F9,
           typename F10, typename F11>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
-    promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11>
-    Seq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7, F8 f8, F9 f9,
-        F10 f10, F11 f11, DebugLocation whence = {}) {
-  return promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
-      std::move(f5), std::move(f6), std::move(f7), std::move(f8), std::move(f9),
-      std::move(f10), std::move(f11), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Seq(F0&& f0, F1&& f1, F2&& f2,
+                                              F3&& f3, F4&& f4, F5&& f5,
+                                              F6&& f6, F7&& f7, F8&& f8,
+                                              F9&& f9, F10&& f10, F11&& f11,
+                                              DebugLocation whence = {}) {
+  return promise_detail::Seq<
+      std::decay_t<F0>, std::decay_t<F1>, std::decay_t<F2>, std::decay_t<F3>,
+      std::decay_t<F4>, std::decay_t<F5>, std::decay_t<F6>, std::decay_t<F7>,
+      std::decay_t<F8>, std::decay_t<F9>, std::decay_t<F10>, std::decay_t<F11>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), std::forward<F4>(f4), std::forward<F5>(f5),
+      std::forward<F6>(f6), std::forward<F7>(f7), std::forward<F8>(f8),
+      std::forward<F9>(f9), std::forward<F10>(f10), std::forward<F11>(f11),
+      whence);
 }
 
 // Execute a sequence of operations of unknown length.
@@ -245,10 +278,12 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
 //   return argument;
 template <typename Iter, typename Factory, typename Argument>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto SeqIter(Iter begin, Iter end,
-                                                  Argument argument,
-                                                  Factory factory) {
-  return promise_detail::SeqIter<Iter, Factory, Argument>(
-      begin, end, std::move(factory), std::move(argument));
+                                                  Argument&& argument,
+                                                  Factory&& factory) {
+  return promise_detail::SeqIter<Iter, std::decay_t<Factory>,
+                                 std::decay_t<Argument>>(
+      begin, end, std::forward<Factory>(factory),
+      std::forward<Argument>(argument));
 }
 
 }  // namespace grpc_core

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

@@ -18,6 +18,8 @@
 #include <grpc/support/port_platform.h>
 
 #include <tuple>
+#include <type_traits>
+#include <utility>
 #include <variant>
 
 #include "src/core/lib/promise/detail/join_state.h"
@@ -231,6 +233,11 @@ class TryJoin {
     return state_.PollOnce();
   }
 
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    state_.ToProto(grpc_channelz_v2_Promise_TRY, promise_proto, arena);
+  }
+
  private:
   JoinState<TryJoinTraits<R>, Promises...> state_;
 };
@@ -247,15 +254,16 @@ struct WrapInStatusOrTuple {
 }  // namespace promise_detail
 
 template <template <typename> class R, typename... Promises>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::TryJoin<R,
-                                                                    Promises...>
-TryJoin(Promises... promises) {
-  return promise_detail::TryJoin<R, Promises...>(std::move(promises)...);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto TryJoin(
+    Promises&&... promises) {
+  return promise_detail::TryJoin<R, std::decay_t<Promises>...>(
+      std::forward<Promises>(promises)...);
 }
 
 template <template <typename> class R, typename F>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto TryJoin(F promise) {
-  return Map(promise, promise_detail::WrapInStatusOrTuple<R>{});
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto TryJoin(F&& promise) {
+  return Map(std::forward<F>(promise),
+             promise_detail::WrapInStatusOrTuple<R>{});
 }
 
 }  // namespace grpc_core

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

@@ -94,8 +94,8 @@ struct TrySeqTraitsWithSfinae {
   }
   template <typename Result, typename RunNext>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
-  CheckResultAndRunNext(T prior, RunNext run_next) {
-    return run_next(std::move(prior));
+  CheckResultAndRunNext(T&& prior, RunNext run_next) {
+    return run_next(std::forward<T>(prior));
   }
 };
 
@@ -122,9 +122,9 @@ struct TrySeqTraitsWithSfinae<absl::StatusOr<T>> {
   }
   template <typename Result, typename RunNext>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
-  CheckResultAndRunNext(absl::StatusOr<T> prior, RunNext run_next) {
+  CheckResultAndRunNext(absl::StatusOr<T>&& prior, RunNext run_next) {
     if (!prior.ok()) return FailureStatusCast<Result>(prior.status());
-    return run_next(std::move(prior));
+    return run_next(std::forward<absl::StatusOr<T>>(prior));
   }
 };
 
@@ -181,9 +181,9 @@ struct TrySeqTraitsWithSfinae<
   }
   template <typename Result, typename RunNext>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
-  CheckResultAndRunNext(T prior, RunNext run_next) {
-    if (!IsStatusOk(prior)) return Result(std::move(prior));
-    return run_next(std::move(prior));
+  CheckResultAndRunNext(T&& prior, RunNext run_next) {
+    if (!IsStatusOk(prior)) return Result(std::forward<T>(prior));
+    return run_next(std::forward<T>(prior));
   }
 };
 template <typename T>
@@ -213,9 +213,9 @@ struct TrySeqTraitsWithSfinae<
   }
   template <typename Result, typename RunNext>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
-  CheckResultAndRunNext(T prior, RunNext run_next) {
-    if (!IsStatusOk(prior)) return Result(std::move(prior));
-    return run_next(std::move(prior));
+  CheckResultAndRunNext(T&& prior, RunNext run_next) {
+    if (!IsStatusOk(prior)) return Result(std::forward<T>(prior));
+    return run_next(std::forward<T>(prior));
   }
 };
 template <>
@@ -241,9 +241,9 @@ struct TrySeqTraitsWithSfinae<absl::Status> {
   }
   template <typename Result, typename RunNext>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
-  CheckResultAndRunNext(absl::Status prior, RunNext run_next) {
+  CheckResultAndRunNext(absl::Status&& prior, RunNext run_next) {
     if (!prior.ok()) return StatusCast<Result>(std::move(prior));
-    return run_next(std::move(prior));
+    return run_next(std::forward<absl::Status>(prior));
   }
 };
 
@@ -306,66 +306,77 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline F TrySeq(F functor) {
 }
 
 template <typename F0, typename F1>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::TrySeq<F0, F1>
-TrySeq(F0 f0, F1 f1, DebugLocation whence = {}) {
-  return promise_detail::TrySeq<F0, F1>(std::move(f0), std::move(f1), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto TrySeq(
+    F0&& f0, F1&& f1, DebugLocation whence = {}) {
+  return promise_detail::TrySeq<std::decay_t<F0>, std::decay_t<F1>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), whence);
 }
 
 template <typename F0, typename F1, typename F2>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::TrySeq<F0, F1, F2>
-TrySeq(F0 f0, F1 f1, F2 f2, DebugLocation whence = {}) {
-  return promise_detail::TrySeq<F0, F1, F2>(std::move(f0), std::move(f1),
-                                            std::move(f2), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto TrySeq(
+    F0&& f0, F1&& f1, F2&& f2, DebugLocation whence = {}) {
+  return promise_detail::TrySeq<std::decay_t<F0>, std::decay_t<F1>,
+                                std::decay_t<F2>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::TrySeq<F0, F1, F2,
-                                                                   F3>
-TrySeq(F0 f0, F1 f1, F2 f2, F3 f3, DebugLocation whence = {}) {
-  return promise_detail::TrySeq<F0, F1, F2, F3>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto TrySeq(
+    F0&& f0, F1&& f1, F2&& f2, F3&& f3, DebugLocation whence = {}) {
+  return promise_detail::TrySeq<std::decay_t<F0>, std::decay_t<F1>,
+                                std::decay_t<F2>, std::decay_t<F3>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::TrySeq<F0, F1, F2,
-                                                                   F3, F4>
-TrySeq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, DebugLocation whence = {}) {
-  return promise_detail::TrySeq<F0, F1, F2, F3, F4>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
-      whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto TrySeq(
+    F0&& f0, F1&& f1, F2&& f2, F3&& f3, F4&& f4, DebugLocation whence = {}) {
+  return promise_detail::TrySeq<std::decay_t<F0>, std::decay_t<F1>,
+                                std::decay_t<F2>, std::decay_t<F3>,
+                                std::decay_t<F4>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), std::forward<F4>(f4), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
-    promise_detail::TrySeq<F0, F1, F2, F3, F4, F5>
-    TrySeq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5,
-           DebugLocation whence = {}) {
-  return promise_detail::TrySeq<F0, F1, F2, F3, F4, F5>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
-      std::move(f5), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto TrySeq(F0&& f0, F1&& f1, F2&& f2,
+                                                 F3&& f3, F4&& f4, F5&& f5,
+                                                 DebugLocation whence = {}) {
+  return promise_detail::TrySeq<std::decay_t<F0>, std::decay_t<F1>,
+                                std::decay_t<F2>, std::decay_t<F3>,
+                                std::decay_t<F4>, std::decay_t<F5>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), std::forward<F4>(f4), std::forward<F5>(f5), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
-    promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6>
-    TrySeq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6,
-           DebugLocation whence = {}) {
-  return promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
-      std::move(f5), std::move(f6), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto TrySeq(F0&& f0, F1&& f1, F2&& f2,
+                                                 F3&& f3, F4&& f4, F5&& f5,
+                                                 F6&& f6,
+                                                 DebugLocation whence = {}) {
+  return promise_detail::TrySeq<
+      std::decay_t<F0>, std::decay_t<F1>, std::decay_t<F2>, std::decay_t<F3>,
+      std::decay_t<F4>, std::decay_t<F5>, std::decay_t<F6>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), std::forward<F4>(f4), std::forward<F5>(f5),
+      std::forward<F6>(f6), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6, typename F7>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
-    promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6, F7>
-    TrySeq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7,
-           DebugLocation whence = {}) {
-  return promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6, F7>(
-      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
-      std::move(f5), std::move(f6), std::move(f7), whence);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto TrySeq(F0&& f0, F1&& f1, F2&& f2,
+                                                 F3&& f3, F4&& f4, F5&& f5,
+                                                 F6&& f6, F7&& f7,
+                                                 DebugLocation whence = {}) {
+  return promise_detail::TrySeq<
+      std::decay_t<F0>, std::decay_t<F1>, std::decay_t<F2>, std::decay_t<F3>,
+      std::decay_t<F4>, std::decay_t<F5>, std::decay_t<F6>, std::decay_t<F7>>(
+      std::forward<F0>(f0), std::forward<F1>(f1), std::forward<F2>(f2),
+      std::forward<F3>(f3), std::forward<F4>(f4), std::forward<F5>(f5),
+      std::forward<F6>(f6), std::forward<F7>(f7), whence);
 }
 
 // Try a sequence of operations of unknown length.
@@ -378,18 +389,23 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
 //   return argument;
 template <typename Iter, typename Factory, typename Argument>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto TrySeqIter(Iter begin, Iter end,
-                                                     Argument argument,
-                                                     Factory factory) {
-  return promise_detail::TrySeqIter<Iter, Factory, Argument>(
-      begin, end, std::move(factory), std::move(argument));
+                                                     Argument&& argument,
+                                                     Factory&& factory) {
+  return promise_detail::TrySeqIter<Iter, std::decay_t<Factory>,
+                                    std::decay_t<Argument>>(
+      begin, end, std::forward<Factory>(factory),
+      std::forward<Argument>(argument));
 }
 
 template <typename Container, typename Factory, typename Argument>
-auto TrySeqContainer(Container container, Argument argument, Factory factory) {
-  using Result =
-      typename promise_detail::TrySeqContainerResultTraits<Container, Factory,
-                                                           Argument>::Result;
-  return Result(std::move(container), std::move(factory), std::move(argument));
+auto TrySeqContainer(Container&& container, Argument&& argument,
+                     Factory&& factory) {
+  using Result = typename promise_detail::TrySeqContainerResultTraits<
+      std::decay_t<Container>, std::decay_t<Factory>,
+      std::decay_t<Argument>>::Result;
+  return Result(std::forward<Container>(container),
+                std::forward<Factory>(factory),
+                std::forward<Argument>(argument));
 }
 
 }  // namespace grpc_core

data/src/core/lib/resource_quota/api.cc

@@ -100,3 +100,10 @@ extern "C" void grpc_resource_quota_set_max_threads(
       ->thread_quota()
       ->SetMax(new_max_threads);
 }
+
+extern "C" void grpc_resource_quota_set_max_outstanding_streams(
+    grpc_resource_quota* resource_quota, int new_max_outstanding_streams) {
+  grpc_core::ResourceQuota::FromC(resource_quota)
+      ->stream_quota()
+      ->SetMaxOutstandingStreams(new_max_outstanding_streams);
+}