grpc 1.65.2 → 1.66.0

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

@@ -19,6 +19,8 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/strings/str_format.h"
+#include "absl/types/optional.h"
 
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
@@ -31,12 +33,22 @@ namespace grpc_core {
 // Allows writing 'return Pending{}' and with automatic conversions gets
 // upgraded to a Poll<> object.
 struct Pending {};
-inline bool operator==(const Pending&, const Pending&) { return true; }
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool operator==(const Pending&,
+                                                            const Pending&) {
+  return true;
+}
 
 // A type that contains no value. Useful for simulating 'void' in promises that
 // always need to return some kind of value.
 struct Empty {};
-inline bool operator==(const Empty&, const Empty&) { return true; }
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool operator==(const Empty&,
+                                                            const Empty&) {
+  return true;
+}
+template <typename Sink>
+void AbslStringify(Sink& sink, Empty) {
+  sink.Append("{}");
+}
 
 // The result of polling a Promise once.
 //
@@ -46,15 +58,17 @@ template <typename T>
 class Poll {
  public:
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Poll(Pending) : ready_(false) {}
-  Poll() : ready_(false) {}
-  Poll(const Poll& other) : ready_(other.ready_) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll(Pending) : ready_(false) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll() : ready_(false) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll(const Poll& other)
+      : ready_(other.ready_) {
     if (ready_) Construct(&value_, other.value_);
   }
-  Poll(Poll&& other) noexcept : ready_(other.ready_) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll(Poll&& other) noexcept
+      : ready_(other.ready_) {
     if (ready_) Construct(&value_, std::move(other.value_));
   }
-  Poll& operator=(const Poll& other) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll& operator=(const Poll& other) {
     if (ready_) {
       if (other.ready_) {
         value_ = other.value_;
@@ -68,7 +82,7 @@ class Poll {
     }
     return *this;
   }
-  Poll& operator=(Poll&& other) noexcept {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll& operator=(Poll&& other) noexcept {
     if (ready_) {
       if (other.ready_) {
         value_ = std::move(other.value_);
@@ -84,34 +98,36 @@ class Poll {
   }
   template <typename U>
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Poll(U value) : ready_(true) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll(U value) : ready_(true) {
     Construct(&value_, std::move(value));
   }
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Poll(T&& value) : ready_(true) { Construct(&value_, std::forward<T>(value)); }
-  ~Poll() {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll(T&& value) : ready_(true) {
+    Construct(&value_, std::forward<T>(value));
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~Poll() {
     if (ready_) Destruct(&value_);
   }
 
-  bool pending() const { return !ready_; }
-  bool ready() const { return ready_; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool pending() const { return !ready_; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool ready() const { return ready_; }
 
-  T& value() {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION T& value() {
     DCHECK(ready());
     return value_;
   }
 
-  const T& value() const {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION const T& value() const {
     DCHECK(ready());
     return value_;
   }
 
-  T* value_if_ready() {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION T* value_if_ready() {
     if (ready()) return &value_;
     return nullptr;
   }
 
-  const T* value_if_ready() const {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION const T* value_if_ready() const {
     if (ready()) return &value_;
     return nullptr;
   }
@@ -142,31 +158,31 @@ template <>
 class Poll<Empty> {
  public:
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Poll(Pending) : ready_(false) {}
-  Poll() : ready_(false) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll(Pending) : ready_(false) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll() : ready_(false) {}
   Poll(const Poll& other) = default;
   Poll(Poll&& other) noexcept = default;
   Poll& operator=(const Poll& other) = default;
   Poll& operator=(Poll&& other) = default;
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Poll(Empty) : ready_(true) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll(Empty) : ready_(true) {}
   ~Poll() = default;
 
-  bool pending() const { return !ready_; }
-  bool ready() const { return ready_; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool pending() const { return !ready_; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool ready() const { return ready_; }
 
-  Empty value() const {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Empty value() const {
     DCHECK(ready());
     return Empty{};
   }
 
-  Empty* value_if_ready() {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Empty* value_if_ready() {
     static Empty value;
     if (ready()) return &value;
     return nullptr;
   }
 
-  const Empty* value_if_ready() const {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION const Empty* value_if_ready() const {
     static Empty value;
     if (ready()) return &value;
     return nullptr;
@@ -194,17 +210,22 @@ class Poll<Poll<T>>;
 template <typename T>
 struct PollTraits {
   using Type = T;
-  static constexpr bool is_poll() { return false; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static constexpr bool is_poll() {
+    return false;
+  }
 };
 
 template <typename T>
 struct PollTraits<Poll<T>> {
   using Type = T;
-  static constexpr bool is_poll() { return true; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static constexpr bool is_poll() {
+    return true;
+  }
 };
 
 template <typename T>
-bool operator==(const Poll<T>& a, const Poll<T>& b) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool operator==(const Poll<T>& a,
+                                                     const Poll<T>& b) {
   if (a.pending() && b.pending()) return true;
   if (a.ready() && b.ready()) return a.value() == b.value();
   return false;
@@ -215,7 +236,7 @@ struct PollCastImpl;
 
 template <typename T, typename U>
 struct PollCastImpl<T, Poll<U>> {
-  static Poll<T> Cast(Poll<U>&& poll) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<T> Cast(Poll<U>&& poll) {
     if (poll.pending()) return Pending{};
     return static_cast<T>(std::move(poll.value()));
   }
@@ -223,21 +244,27 @@ struct PollCastImpl<T, Poll<U>> {
 
 template <typename T, typename U>
 struct PollCastImpl<T, U, std::enable_if<!PollTraits<U>::is_poll()>> {
-  static Poll<T> Cast(U&& poll) { return Poll<T>(T(std::move(poll))); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<T> Cast(U&& poll) {
+    return Poll<T>(T(std::move(poll)));
+  }
 };
 
 template <typename T>
 struct PollCastImpl<T, T> {
-  static Poll<T> Cast(T&& poll) { return Poll<T>(std::move(poll)); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<T> Cast(T&& poll) {
+    return Poll<T>(std::move(poll));
+  }
 };
 
 template <typename T>
 struct PollCastImpl<T, Poll<T>> {
-  static Poll<T> Cast(Poll<T>&& poll) { return std::move(poll); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<T> Cast(Poll<T>&& poll) {
+    return std::move(poll);
+  }
 };
 
 template <typename T, typename U>
-Poll<T> poll_cast(U poll) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<T> poll_cast(U poll) {
   return PollCastImpl<T, U>::Cast(std::move(poll));
 }
 
@@ -252,6 +279,45 @@ std::string PollToString(
   return t_to_string(poll.value());
 }
 
+template <typename Sink, typename T>
+void AbslStringify(Sink& sink, const Poll<T>& poll) {
+  if (poll.pending()) {
+    absl::Format(&sink, "<<pending>>");
+    return;
+  }
+  absl::Format(&sink, "%v", poll.value());
+}
+
+template <typename Sink, typename T>
+void AbslStringify(Sink& sink, const Poll<absl::optional<T>>& poll) {
+  if (poll.pending()) {
+    absl::Format(&sink, "<<pending>>");
+    return;
+  }
+  const auto& value = poll.value();
+  if (value.has_value()) {
+    absl::Format(&sink, "%v", value);
+  } else {
+    sink.append("nullopt");
+  }
+}
+
+// Hack to get metadata printing
+template <typename Sink, typename T, typename Deleter>
+void AbslStringify(
+    Sink& sink, const Poll<absl::optional<std::unique_ptr<T, Deleter>>>& poll) {
+  if (poll.pending()) {
+    absl::Format(&sink, "<<pending>>");
+    return;
+  }
+  const auto& value = poll.value();
+  if (value.has_value()) {
+    absl::Format(&sink, "%v", *value);
+  } else {
+    sink.Append("nullopt");
+  }
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_PROMISE_POLL_H

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

@@ -58,9 +58,12 @@ namespace promise_detail {
 template <typename T>
 class Immediate {
  public:
-  explicit Immediate(T value) : value_(std::move(value)) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Immediate(T value)
+      : value_(std::move(value)) {}
 
-  Poll<T> operator()() { return std::move(value_); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<T> operator()() {
+    return std::move(value_);
+  }
 
  private:
   T value_;
@@ -69,13 +72,16 @@ class Immediate {
 
 // Return \a value immediately
 template <typename T>
-promise_detail::Immediate<T> Immediate(T value) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION promise_detail::Immediate<T> Immediate(
+    T value) {
   return promise_detail::Immediate<T>(std::move(value));
 }
 
 // Return status Ok immediately
 struct ImmediateOkStatus {
-  Poll<absl::Status> operator()() { return absl::OkStatus(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<absl::Status> operator()() {
+    return absl::OkStatus();
+  }
 };
 
 // Typecheck that a promise returns the expected return type.
@@ -84,7 +90,7 @@ struct ImmediateOkStatus {
 // should fail to compile. When modifying this code these should be uncommented
 // and their miscompilation verified.
 template <typename T, typename F>
-auto WithResult(F f) ->
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto WithResult(F f) ->
     typename std::enable_if<std::is_same<decltype(f()), Poll<T>>::value,
                             F>::type {
   return f;

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

@@ -32,10 +32,11 @@ class Race<Promise, Promises...> {
  public:
   using Result = decltype(std::declval<Promise>()());
 
-  explicit Race(Promise promise, Promises... promises)
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Race(Promise promise,
+                                                     Promises... promises)
       : promise_(std::move(promise)), next_(std::move(promises)...) {}
 
-  Result operator()() {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Result operator()() {
     // Check our own promise.
     auto r = promise_();
     if (r.pending()) {
@@ -57,8 +58,11 @@ template <typename Promise>
 class Race<Promise> {
  public:
   using Result = decltype(std::declval<Promise>()());
-  explicit Race(Promise promise) : promise_(std::move(promise)) {}
-  Result operator()() { return promise_(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Race(Promise promise)
+      : promise_(std::move(promise)) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Result operator()() {
+    return promise_();
+  }
 
  private:
   Promise promise_;
@@ -70,7 +74,8 @@ class Race<Promise> {
 /// If two results are simultaneously available, bias towards the first result
 /// listed.
 template <typename... Promises>
-promise_detail::Race<Promises...> Race(Promises... promises) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION promise_detail::Race<Promises...> Race(
+    Promises... promises) {
   return promise_detail::Race<Promises...>(std::move(promises)...);
 }
 

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

@@ -36,22 +36,27 @@ struct SeqTraits {
   using UnwrappedType = T;
   using WrappedType = T;
   template <typename Next>
-  static auto CallFactory(Next* next, T&& value) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallFactory(Next* next,
+                                                               T&& value) {
     return next->Make(std::forward<T>(value));
   }
-  static bool IsOk(const T&) { return true; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsOk(const T&) {
+    return true;
+  }
   static const char* ErrorString(const T&) { abort(); }
   template <typename R>
   static R ReturnValue(T&&) {
     abort();
   }
   template <typename F, typename Elem>
-  static auto CallSeqFactory(F& f, Elem&& elem, T&& value) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallSeqFactory(F& f,
+                                                                  Elem&& elem,
+                                                                  T&& value) {
     return f(std::forward<Elem>(elem), std::forward<T>(value));
   }
   template <typename Result, typename PriorResult, typename RunNext>
-  static Poll<Result> CheckResultAndRunNext(PriorResult prior,
-                                            RunNext run_next) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
+  CheckResultAndRunNext(PriorResult prior, RunNext run_next) {
     return run_next(std::move(prior));
   }
 };
@@ -59,11 +64,15 @@ struct SeqTraits {
 template <typename P, typename... Fs>
 class Seq {
  public:
-  explicit Seq(P&& promise, Fs&&... factories, DebugLocation whence)
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Seq(P&& promise,
+                                                    Fs&&... factories,
+                                                    DebugLocation whence)
       : state_(std::forward<P>(promise), std::forward<Fs>(factories)...,
                whence) {}
 
-  auto operator()() { return state_.PollOnce(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto operator()() {
+    return state_.PollOnce();
+  }
 
  private:
   SeqState<SeqTraits, P, Fs...> state_;
@@ -98,32 +107,33 @@ struct SeqIterResultTraits {
 // etc
 // Return the final value.
 template <typename F>
-F Seq(F functor) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION F Seq(F functor) {
   return functor;
 }
 
 template <typename F0, typename F1>
-promise_detail::Seq<F0, F1> Seq(F0 f0, F1 f1, DebugLocation whence = {}) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION 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);
 }
 
 template <typename F0, typename F1, typename F2>
-promise_detail::Seq<F0, F1, F2> Seq(F0 f0, F1 f1, F2 f2,
-                                    DebugLocation whence = {}) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION 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);
 }
 
 template <typename F0, typename F1, typename F2, typename F3>
-promise_detail::Seq<F0, F1, F2, F3> Seq(F0 f0, F1 f1, F2 f2, F3 f3,
-                                        DebugLocation whence = {}) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION 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);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4>
-promise_detail::Seq<F0, F1, F2, F3, F4> Seq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4,
-                                            DebugLocation whence = {}) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION 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);
@@ -131,9 +141,8 @@ promise_detail::Seq<F0, F1, F2, F3, F4> Seq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4,
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5>
-promise_detail::Seq<F0, F1, F2, F3, F4, F5> Seq(F0 f0, F1 f1, F2 f2, F3 f3,
-                                                F4 f4, F5 f5,
-                                                DebugLocation whence = {}) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION 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);
@@ -141,9 +150,10 @@ promise_detail::Seq<F0, F1, F2, F3, F4, F5> Seq(F0 f0, F1 f1, F2 f2, F3 f3,
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6>
-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 = {}) {
+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);
@@ -151,9 +161,10 @@ promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6> Seq(F0 f0, F1 f1, F2 f2, F3 f3,
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6, typename F7>
-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 = {}) {
+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);
@@ -161,9 +172,10 @@ promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7> Seq(
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6, typename F7, typename F8>
-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 = {}) {
+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);
@@ -171,9 +183,10 @@ promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8> Seq(
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6, typename F7, typename F8, typename F9>
-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 = {}) {
+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),
@@ -183,9 +196,10 @@ promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> Seq(
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6, typename F7, typename F8, typename F9,
           typename F10>
-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 = {}) {
+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),
@@ -195,9 +209,10 @@ promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> Seq(
 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>
-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 = {}) {
+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),