grpc 1.65.2 → 1.66.0.pre3

data/src/core/lib/transport/call_filters.h

@@ -16,7 +16,9 @@
 #define GRPC_SRC_CORE_LIB_TRANSPORT_CALL_FILTERS_H
 
 #include <cstdint>
+#include <limits>
 #include <memory>
+#include <ostream>
 #include <type_traits>
 
 #include "absl/log/check.h"
@@ -26,11 +28,15 @@
 #include "src/core/lib/gprpp/dump_args.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/promise.h"
+#include "src/core/lib/promise/seq.h"
 #include "src/core/lib/promise/status_flag.h"
+#include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/transport/call_final_info.h"
+#include "src/core/lib/transport/call_state.h"
 #include "src/core/lib/transport/message.h"
 #include "src/core/lib/transport/metadata.h"
 
@@ -116,6 +122,10 @@ struct NoInterceptor {};
 
 namespace filters_detail {
 
+inline void* Offset(void* base, size_t amt) {
+  return static_cast<char*>(base) + amt;
+}
+
 // One call filter constructor
 // Contains enough information to allocate and initialize the
 // call data for one filter.
@@ -168,11 +178,10 @@ struct ResultOr {
 };
 
 // One filter operation metadata
-// Given a value of type V, produces a promise of type R.
-template <typename R, typename V>
+// Given a value of type T, produces a promise of type ResultOr<T>.
+template <typename T>
 struct Operator {
-  using Result = R;
-  using Arg = V;
+  using Arg = T;
   // Pointer to corresponding channel data for this filter
   void* channel_data;
   // Offset of the call data for this filter within the call data memory
@@ -180,13 +189,13 @@ struct Operator {
   // Initialize the promise data for this filter, and poll once.
   // Return the result of the poll.
   // If the promise finishes, also destroy the promise data!
-  Poll<R> (*promise_init)(void* promise_data, void* call_data,
-                          void* channel_data, V value);
+  Poll<ResultOr<T>> (*promise_init)(void* promise_data, void* call_data,
+                                    void* channel_data, T value);
   // Poll the promise data for this filter.
   // If the promise finishes, also destroy the promise data!
   // Note that if the promise always finishes on the first poll, then supplying
   // this method is unnecessary (as it will never be called).
-  Poll<R> (*poll)(void* promise_data);
+  Poll<ResultOr<T>> (*poll)(void* promise_data);
   // Destroy the promise data for this filter for an in-progress operation
   // before the promise finishes.
   // Note that if the promise always finishes on the first poll, then supplying
@@ -202,24 +211,19 @@ struct HalfCloseOperator {
   void (*half_close)(void* call_data, void* channel_data);
 };
 
-void RunHalfClose(absl::Span<const HalfCloseOperator> ops, void* call_data);
+struct ServerTrailingMetadataOperator {
+  // Pointer to corresponding channel data for this filter
+  void* channel_data;
+  // Offset of the call data for this filter within the call data memory
+  size_t call_offset;
+  ServerMetadataHandle (*server_trailing_metadata)(
+      void* call_data, void* channel_data, ServerMetadataHandle metadata);
+};
 
-// We divide operations into fallible and infallible.
-// Fallible operations can fail, and that failure terminates the call.
-// Infallible operations cannot fail.
-// Fallible operations are used for client initial, and server initial metadata,
-// and messages.
-// Infallible operations are used for server trailing metadata.
-// (This is because server trailing metadata occurs when the call is finished -
-// and so we couldn't possibly become more finished - and also because it's the
-// preferred representation of failure anyway!)
-
-// An operation that could fail: takes a T argument, produces a ResultOr<T>
-template <typename T>
-using FallibleOperator = Operator<ResultOr<T>, T>;
-// And one that cannot: takes a T argument, produces a T
-template <typename T>
-using InfallibleOperator = Operator<T, T>;
+void RunHalfClose(absl::Span<const HalfCloseOperator> ops, void* call_data);
+ServerMetadataHandle RunServerTrailingMetadata(
+    absl::Span<const ServerTrailingMetadataOperator> ops, void* call_data,
+    ServerMetadataHandle md);
 
 // One call finalizer
 struct Finalizer {
@@ -231,19 +235,20 @@ struct Finalizer {
 
 // A layout of operations for a given filter stack
 // This includes which operations, how much memory is required, what alignment.
-template <typename Op>
+template <typename T>
 struct Layout {
   size_t promise_size = 0;
   size_t promise_alignment = 0;
-  std::vector<Op> ops;
+  std::vector<Operator<T>> ops;
 
-  void Add(size_t filter_promise_size, size_t filter_promise_alignment, Op op) {
+  void Add(size_t filter_promise_size, size_t filter_promise_alignment,
+           Operator<T> op) {
     promise_size = std::max(promise_size, filter_promise_size);
     promise_alignment = std::max(promise_alignment, filter_promise_alignment);
     ops.push_back(op);
   }
 
-  void Reverse() { std::reverse(ops.begin(), ops.end()); }
+  void Reverse() { absl::c_reverse(ops); }
 };
 
 // AddOp and friends
@@ -263,16 +268,7 @@ struct AddOpImpl;
 
 template <typename FunctionImpl, FunctionImpl impl, typename FilterType,
           typename T>
-void AddOp(FilterType* channel_data, size_t call_offset,
-           Layout<FallibleOperator<T>>& to) {
-  AddOpImpl<FilterType, T, FunctionImpl, impl>::Add(channel_data, call_offset,
-                                                    to);
-}
-
-template <typename FunctionImpl, FunctionImpl impl, typename FilterType,
-          typename T>
-void AddOp(FilterType* channel_data, size_t call_offset,
-           Layout<InfallibleOperator<T>>& to) {
+void AddOp(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
   AddOpImpl<FilterType, T, FunctionImpl, impl>::Add(channel_data, call_offset,
                                                     to);
 }
@@ -303,13 +299,73 @@ template <typename FilterType>
 void AddHalfClose(FilterType*, size_t, const NoInterceptor*,
                   std::vector<HalfCloseOperator>&) {}
 
+template <typename FilterType>
+void AddServerTrailingMetadata(
+    FilterType* channel_data, size_t call_offset,
+    void (FilterType::Call::*)(ServerMetadata&),
+    std::vector<ServerTrailingMetadataOperator>& to) {
+  to.push_back(ServerTrailingMetadataOperator{
+      channel_data, call_offset,
+      [](void* call_data, void*, ServerMetadataHandle metadata) {
+        static_cast<typename FilterType::Call*>(call_data)
+            ->OnServerTrailingMetadata(*metadata);
+        return metadata;
+      }});
+}
+
+template <typename FilterType>
+void AddServerTrailingMetadata(
+    FilterType* channel_data, size_t call_offset,
+    void (FilterType::Call::*)(ServerMetadata&, FilterType*),
+    std::vector<ServerTrailingMetadataOperator>& to) {
+  to.push_back(ServerTrailingMetadataOperator{
+      channel_data, call_offset,
+      [](void* call_data, void* channel_data, ServerMetadataHandle metadata) {
+        static_cast<typename FilterType::Call*>(call_data)
+            ->OnServerTrailingMetadata(*metadata,
+                                       static_cast<FilterType*>(channel_data));
+        return metadata;
+      }});
+}
+
+template <typename FilterType>
+void AddServerTrailingMetadata(
+    FilterType* channel_data, size_t call_offset,
+    absl::Status (FilterType::Call::*)(ServerMetadata&),
+    std::vector<ServerTrailingMetadataOperator>& to) {
+  to.push_back(ServerTrailingMetadataOperator{
+      channel_data, call_offset,
+      [](void* call_data, void*, ServerMetadataHandle metadata) {
+        auto r = static_cast<typename FilterType::Call*>(call_data)
+                     ->OnServerTrailingMetadata(*metadata);
+        if (r.ok()) return metadata;
+        return CancelledServerMetadataFromStatus(r);
+      }});
+}
+
+template <typename FilterType>
+void AddServerTrailingMetadata(
+    FilterType* channel_data, size_t call_offset,
+    ServerMetadataHandle (FilterType::Call::*)(ServerMetadataHandle),
+    std::vector<ServerTrailingMetadataOperator>& to) {
+  to.push_back(ServerTrailingMetadataOperator{
+      channel_data, call_offset,
+      [](void* call_data, void*, ServerMetadataHandle metadata) {
+        return static_cast<typename FilterType::Call*>(call_data)
+            ->OnServerTrailingMetadata(std::move(metadata));
+      }});
+}
+
+template <typename FilterType>
+void AddServerTrailingMetadata(FilterType*, size_t, const NoInterceptor*,
+                               std::vector<ServerTrailingMetadataOperator>&) {}
+
 // const NoInterceptor $EVENT
 // These do nothing, and specifically DO NOT add an operation to the layout.
 // Supported for fallible & infallible operations.
 template <typename FilterType, typename T, const NoInterceptor* which>
 struct AddOpImpl<FilterType, T, const NoInterceptor*, which> {
-  static void Add(FilterType*, size_t, Layout<FallibleOperator<T>>&) {}
-  static void Add(FilterType*, size_t, Layout<InfallibleOperator<T>>&) {}
+  static void Add(FilterType*, size_t, Layout<T>&) {}
 };
 
 // void $INTERCEPTOR_NAME($VALUE_TYPE&)
@@ -317,10 +373,9 @@ template <typename FilterType, typename T,
           void (FilterType::Call::*impl)(typename T::element_type&)>
 struct AddOpImpl<FilterType, T,
                  void (FilterType::Call::*)(typename T::element_type&), impl> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     to.Add(0, 0,
-           FallibleOperator<T>{
+           Operator<T>{
                channel_data,
                call_offset,
                [](void*, void* call_data, void*, T value) -> Poll<ResultOr<T>> {
@@ -332,21 +387,6 @@ struct AddOpImpl<FilterType, T,
                nullptr,
            });
   }
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<InfallibleOperator<T>>& to) {
-    to.Add(0, 0,
-           InfallibleOperator<T>{
-               channel_data,
-               call_offset,
-               [](void*, void* call_data, void*, T value) -> Poll<T> {
-                 (static_cast<typename FilterType::Call*>(call_data)->*impl)(
-                     *value);
-                 return std::move(value);
-               },
-               nullptr,
-               nullptr,
-           });
-  }
 };
 
 // void $INTERCEPTOR_NAME($VALUE_TYPE&, FilterType*)
@@ -356,10 +396,9 @@ template <typename FilterType, typename T,
 struct AddOpImpl<
     FilterType, T,
     void (FilterType::Call::*)(typename T::element_type&, FilterType*), impl> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     to.Add(0, 0,
-           FallibleOperator<T>{
+           Operator<T>{
                channel_data,
                call_offset,
                [](void*, void* call_data, void* channel_data,
@@ -372,33 +411,16 @@ struct AddOpImpl<
                nullptr,
            });
   }
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<InfallibleOperator<T>>& to) {
-    to.Add(
-        0, 0,
-        InfallibleOperator<T>{
-            channel_data,
-            call_offset,
-            [](void*, void* call_data, void* channel_data, T value) -> Poll<T> {
-              (static_cast<typename FilterType::Call*>(call_data)->*impl)(
-                  *value, static_cast<FilterType*>(channel_data));
-              return std::move(value);
-            },
-            nullptr,
-            nullptr,
-        });
-  }
 };
 
 // $VALUE_HANDLE $INTERCEPTOR_NAME($VALUE_HANDLE, FilterType*)
 template <typename FilterType, typename T,
           T (FilterType::Call::*impl)(T, FilterType*)>
 struct AddOpImpl<FilterType, T, T (FilterType::Call::*)(T, FilterType*), impl> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     to.Add(
         0, 0,
-        FallibleOperator<T>{
+        Operator<T>{
             channel_data,
             call_offset,
             [](void*, void* call_data, void* channel_data,
@@ -412,24 +434,6 @@ struct AddOpImpl<FilterType, T, T (FilterType::Call::*)(T, FilterType*), impl> {
             nullptr,
         });
   }
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<InfallibleOperator<T>>& to) {
-    to.Add(
-        0, 0,
-        InfallibleOperator<T>{
-            channel_data,
-            call_offset,
-            [](void*, void* call_data, void* channel_data, T value) -> Poll<T> {
-              (static_cast<typename FilterType::Call*>(call_data)->*impl)(
-                  *value, static_cast<FilterType*>(channel_data));
-              return (
-                  static_cast<typename FilterType::Call*>(call_data)->*impl)(
-                  std::move(value), static_cast<FilterType*>(channel_data));
-            },
-            nullptr,
-            nullptr,
-        });
-  }
 };
 
 // absl::Status $INTERCEPTOR_NAME($VALUE_TYPE&)
@@ -438,11 +442,10 @@ template <typename FilterType, typename T,
 struct AddOpImpl<FilterType, T,
                  absl::Status (FilterType::Call::*)(typename T::element_type&),
                  impl> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     to.Add(
         0, 0,
-        FallibleOperator<T>{
+        Operator<T>{
             channel_data,
             call_offset,
             [](void*, void* call_data, void*, T value) -> Poll<ResultOr<T>> {
@@ -457,24 +460,6 @@ struct AddOpImpl<FilterType, T,
             nullptr,
         });
   }
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<InfallibleOperator<T>>& to) {
-    to.Add(
-        0, 0,
-        InfallibleOperator<T>{
-            channel_data,
-            call_offset,
-            [](void*, void* call_data, void*, T value) -> Poll<T> {
-              auto r =
-                  (static_cast<typename FilterType::Call*>(call_data)->*impl)(
-                      *value);
-              if (r.ok()) return std::move(value);
-              return StatusCast<ServerMetadataHandle>(std::move(r));
-            },
-            nullptr,
-            nullptr,
-        });
-  }
 };
 
 // absl::Status $INTERCEPTOR_NAME(const $VALUE_TYPE&)
@@ -484,11 +469,10 @@ template <typename FilterType, typename T,
 struct AddOpImpl<
     FilterType, T,
     absl::Status (FilterType::Call::*)(const typename T::element_type&), impl> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     to.Add(
         0, 0,
-        FallibleOperator<T>{
+        Operator<T>{
             channel_data,
             call_offset,
             [](void*, void* call_data, void*, T value) -> Poll<ResultOr<T>> {
@@ -513,11 +497,10 @@ struct AddOpImpl<FilterType, T,
                  absl::Status (FilterType::Call::*)(typename T::element_type&,
                                                     FilterType*),
                  impl> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     to.Add(
         0, 0,
-        FallibleOperator<T>{
+        Operator<T>{
             channel_data,
             call_offset,
             [](void*, void* call_data, void* channel_data,
@@ -543,11 +526,10 @@ struct AddOpImpl<FilterType, T,
                  absl::Status (FilterType::Call::*)(
                      const typename T::element_type&, FilterType*),
                  impl> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     to.Add(
         0, 0,
-        FallibleOperator<T>{
+        Operator<T>{
             channel_data,
             call_offset,
             [](void*, void* call_data, void* channel_data,
@@ -571,11 +553,10 @@ template <typename FilterType, typename T,
 struct AddOpImpl<FilterType, T,
                  absl::StatusOr<T> (FilterType::Call::*)(T, FilterType*),
                  impl> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     to.Add(
         0, 0,
-        FallibleOperator<T>{
+        Operator<T>{
             channel_data,
             call_offset,
             [](void*, void* call_data, void* channel_data,
@@ -601,11 +582,10 @@ struct AddOpImpl<FilterType, T,
                  ServerMetadataHandle (FilterType::Call::*)(
                      typename T::element_type&),
                  impl> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     to.Add(
         0, 0,
-        FallibleOperator<T>{
+        Operator<T>{
             channel_data,
             call_offset,
             [](void*, void* call_data, void*, T value) -> Poll<ResultOr<T>> {
@@ -630,11 +610,10 @@ struct AddOpImpl<FilterType, T,
                  ServerMetadataHandle (FilterType::Call::*)(
                      const typename T::element_type&),
                  impl> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     to.Add(
         0, 0,
-        FallibleOperator<T>{
+        Operator<T>{
             channel_data,
             call_offset,
             [](void*, void* call_data, void*, T value) -> Poll<ResultOr<T>> {
@@ -659,11 +638,10 @@ struct AddOpImpl<FilterType, T,
                  ServerMetadataHandle (FilterType::Call::*)(
                      typename T::element_type&, FilterType*),
                  impl> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     to.Add(
         0, 0,
-        FallibleOperator<T>{
+        Operator<T>{
             channel_data,
             call_offset,
             [](void*, void* call_data, void* channel_data,
@@ -689,11 +667,10 @@ struct AddOpImpl<FilterType, T,
                  ServerMetadataHandle (FilterType::Call::*)(
                      const typename T::element_type&, FilterType*),
                  impl> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     to.Add(
         0, 0,
-        FallibleOperator<T>{
+        Operator<T>{
             channel_data,
             call_offset,
             [](void*, void* call_data, void* channel_data,
@@ -717,8 +694,7 @@ template <typename FilterType, typename T, typename R,
 struct AddOpImpl<
     FilterType, T, R (FilterType::Call::*)(typename T::element_type&), impl,
     absl::enable_if_t<std::is_same<absl::Status, PromiseResult<R>>::value>> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     class Promise {
      public:
       Promise(T value, typename FilterType::Call* call_data, FilterType*)
@@ -733,7 +709,7 @@ struct AddOpImpl<
         if (r->ok()) {
           return ResultOr<T>{std::move(value), nullptr};
         }
-        return ResultOr<T>{nullptr, ServerMetadataFromStatus(*r)};
+        return ResultOr<T>{nullptr, CancelledServerMetadataFromStatus(*r)};
       }
 
      private:
@@ -741,7 +717,7 @@ struct AddOpImpl<
       GPR_NO_UNIQUE_ADDRESS R impl_;
     };
     to.Add(sizeof(Promise), alignof(Promise),
-           FallibleOperator<T>{
+           Operator<T>{
                channel_data,
                call_offset,
                [](void* promise_data, void* call_data, void* channel_data,
@@ -770,8 +746,7 @@ struct AddOpImpl<
     R (FilterType::Call::*)(typename T::element_type&, FilterType*), impl,
     absl::enable_if_t<!std::is_same<R, absl::Status>::value &&
                       std::is_same<absl::Status, PromiseResult<R>>::value>> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     class Promise {
      public:
       Promise(T value, typename FilterType::Call* call_data,
@@ -788,7 +763,7 @@ struct AddOpImpl<
         if (r->ok()) {
           return ResultOr<T>{std::move(value), nullptr};
         }
-        return ResultOr<T>{nullptr, ServerMetadataFromStatus(*r)};
+        return ResultOr<T>{nullptr, CancelledServerMetadataFromStatus(*r)};
       }
 
      private:
@@ -796,7 +771,7 @@ struct AddOpImpl<
       GPR_NO_UNIQUE_ADDRESS R impl_;
     };
     to.Add(sizeof(Promise), alignof(Promise),
-           FallibleOperator<T>{
+           Operator<T>{
                channel_data,
                call_offset,
                [](void* promise_data, void* call_data, void* channel_data,
@@ -824,8 +799,7 @@ template <typename FilterType, typename T, typename R,
 struct AddOpImpl<FilterType, T, R (FilterType::Call::*)(T, FilterType*), impl,
                  absl::enable_if_t<std::is_same<absl::StatusOr<T>,
                                                 PromiseResult<R>>::value>> {
-  static void Add(FilterType* channel_data, size_t call_offset,
-                  Layout<FallibleOperator<T>>& to) {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     class Promise {
      public:
       Promise(T value, typename FilterType::Call* call_data,
@@ -838,14 +812,15 @@ struct AddOpImpl<FilterType, T, R (FilterType::Call::*)(T, FilterType*), impl,
         if (r == nullptr) return Pending{};
         this->~Promise();
         if (r->ok()) return ResultOr<T>{std::move(**r), nullptr};
-        return ResultOr<T>{nullptr, ServerMetadataFromStatus(r->status())};
+        return ResultOr<T>{nullptr,
+                           CancelledServerMetadataFromStatus(r->status())};
       }
 
      private:
       GPR_NO_UNIQUE_ADDRESS R impl_;
     };
     to.Add(sizeof(Promise), alignof(Promise),
-           FallibleOperator<T>{
+           Operator<T>{
                channel_data,
                call_offset,
                [](void* promise_data, void* call_data, void* channel_data,
@@ -887,12 +862,12 @@ struct StackData {
   // For each kind of operation, a layout of the operations for this call.
   // (there's some duplicate data here, and that's ok: we want to avoid
   // pointer chasing as much as possible when executing a call)
-  Layout<FallibleOperator<ClientMetadataHandle>> client_initial_metadata;
-  Layout<FallibleOperator<ServerMetadataHandle>> server_initial_metadata;
-  Layout<FallibleOperator<MessageHandle>> client_to_server_messages;
+  Layout<ClientMetadataHandle> client_initial_metadata;
+  Layout<ServerMetadataHandle> server_initial_metadata;
+  Layout<MessageHandle> client_to_server_messages;
   std::vector<HalfCloseOperator> client_to_server_half_close;
-  Layout<FallibleOperator<MessageHandle>> server_to_client_messages;
-  Layout<InfallibleOperator<ServerMetadataHandle>> server_trailing_metadata;
+  Layout<MessageHandle> server_to_client_messages;
+  std::vector<ServerTrailingMetadataOperator> server_trailing_metadata;
   // A list of finalizers for this call.
   // We use a bespoke data structure here because finalizers can never be
   // asynchronous.
@@ -901,6 +876,17 @@ struct StackData {
   // (to capture ownership of channel data)
   std::vector<ChannelDataDestructor> channel_data_destructors;
 
+  bool empty() const {
+    return filter_constructor.empty() && filter_destructor.empty() &&
+           client_initial_metadata.ops.empty() &&
+           server_initial_metadata.ops.empty() &&
+           client_to_server_messages.ops.empty() &&
+           client_to_server_half_close.empty() &&
+           server_to_client_messages.ops.empty() &&
+           server_trailing_metadata.empty() && finalizers.empty() &&
+           channel_data_destructors.empty();
+  }
+
   // Add one filter to the list of filters, and update alignment.
   // Returns the offset of the call data for this filter.
   // Specifically does not update any of the layouts or finalizers.
@@ -1030,9 +1016,9 @@ struct StackData {
   template <typename FilterType>
   void AddServerTrailingMetadataOp(FilterType* channel_data,
                                    size_t call_offset) {
-    AddOp<decltype(&FilterType::Call::OnServerTrailingMetadata),
-          &FilterType::Call::OnServerTrailingMetadata>(
-        channel_data, call_offset, server_trailing_metadata);
+    AddServerTrailingMetadata(channel_data, call_offset,
+                              &FilterType::Call::OnServerTrailingMetadata,
+                              server_trailing_metadata);
   }
 
   // Finalizer interception adders
@@ -1104,8 +1090,7 @@ class OperationExecutor {
   // Start executing a layout. May allocate space to store the relevant promise.
   // Returns the result of the first poll.
   // If the promise finishes, also destroy the promise data.
-  Poll<ResultOr<T>> Start(const Layout<FallibleOperator<T>>* layout, T input,
-                          void* call_data);
+  Poll<ResultOr<T>> Start(const Layout<T>* layout, T input, void* call_data);
   // Continue executing a layout. Returns the result of the next poll.
   // If the promise finishes, also destroy the promise data.
   Poll<ResultOr<T>> Step(void* call_data);
@@ -1127,133 +1112,8 @@ class OperationExecutor {
   Poll<ResultOr<T>> ContinueStep(void* call_data);
 
   void* promise_data_ = nullptr;
-  const FallibleOperator<T>* ops_;
-  const FallibleOperator<T>* end_ops_;
-};
-
-// Per OperationExecutor, but for infallible operation sequences.
-template <typename T>
-class InfallibleOperationExecutor {
- public:
-  InfallibleOperationExecutor() = default;
-  ~InfallibleOperationExecutor();
-  InfallibleOperationExecutor(const InfallibleOperationExecutor&) = delete;
-  InfallibleOperationExecutor& operator=(const InfallibleOperationExecutor&) =
-      delete;
-  InfallibleOperationExecutor(InfallibleOperationExecutor&& other) noexcept
-      : ops_(other.ops_), end_ops_(other.end_ops_) {
-    // Movable iff we're not running.
-    DCHECK_EQ(other.promise_data_, nullptr);
-  }
-  InfallibleOperationExecutor& operator=(
-      InfallibleOperationExecutor&& other) noexcept {
-    DCHECK_EQ(other.promise_data_, nullptr);
-    DCHECK_EQ(promise_data_, nullptr);
-    ops_ = other.ops_;
-    end_ops_ = other.end_ops_;
-    return *this;
-  }
-
-  // IsRunning() is true if we're currently executing a sequence of operations.
-  bool IsRunning() const { return promise_data_ != nullptr; }
-  // Start executing a layout. May allocate space to store the relevant promise.
-  // Returns the result of the first poll.
-  // If the promise finishes, also destroy the promise data.
-  Poll<T> Start(const Layout<InfallibleOperator<T>>* layout, T input,
-                void* call_data);
-  // Continue executing a layout. Returns the result of the next poll.
-  // If the promise finishes, also destroy the promise data.
-  Poll<T> Step(void* call_data);
-
- private:
-  // Start polling on the current step of the layout.
-  // `input` is the current value (either the input to the first step, or the
-  // so far transformed value)
-  // `call_data` is the call data for the filter stack.
-  // If this op finishes immediately then we iterative move to the next step.
-  // If we reach the end up the ops, we return the overall poll result,
-  // otherwise we return Pending.
-  Poll<T> InitStep(T input, void* call_data);
-  // Continue polling on the current step of the layout.
-  // Called on the next poll after InitStep returns pending.
-  // If the promise is still pending, returns this.
-  // If the promise completes we call into InitStep to continue execution
-  // through the filters.
-  Poll<T> ContinueStep(void* call_data);
-
-  void* promise_data_ = nullptr;
-  const InfallibleOperator<T>* ops_;
-  const InfallibleOperator<T>* end_ops_;
-};
-
-// The current state of a pipe.
-// CallFilters expose a set of pipe like objects for client & server initial
-// metadata and for messages.
-// This class tracks the state of one of those pipes.
-// Size matters here: this state is kept for the lifetime of a call, and we keep
-// multiple of them.
-// This class encapsulates the untyped work of the state machine; there are
-// typed wrappers around this class as private members of CallFilters that
-// augment it to provide all the functionality that we must.
-class PipeState {
- public:
-  struct StartPushed {};
-  PipeState() = default;
-  explicit PipeState(StartPushed) : state_(ValueState::kQueued) {}
-  // Start the pipe: allows pulls to proceed
-  void Start();
-  // A push operation is beginning
-  void BeginPush();
-  // A previously started push operation has completed
-  void DropPush();
-  // Poll for push completion: occurs after the corresponding Pull()
-  Poll<StatusFlag> PollPush();
-  // Poll for pull completion; returns Failure{} if closed with error,
-  // true if a value is available, or false if the pipe was closed without
-  // error.
-  Poll<ValueOrFailure<bool>> PollPull();
-  // A pulled value has been consumed: we can unblock the push
-  void AckPull();
-  // A previously started pull operation has completed
-  void DropPull();
-  // Close sending
-  void CloseSending();
-  // Close sending with error
-  void CloseWithError();
-  // Poll for closedness - if true, closed with error
-  Poll<bool> PollClosed();
-
-  bool holds_error() const { return state_ == ValueState::kError; }
-
-  std::string DebugString() const;
-
- private:
-  enum class ValueState : uint8_t {
-    // Nothing sending nor receiving
-    kIdle,
-    // Sent, but not yet received
-    kQueued,
-    // Trying to receive, but not yet sent
-    kWaiting,
-    // Ready to start processing, but not yet started
-    // (we have the value to send through the pipe, the reader is waiting,
-    // but it's not yet been polled)
-    kReady,
-    // Processing through filters
-    kProcessing,
-    // Closed sending
-    kClosed,
-    // Closed due to failure
-    kError
-  };
-  // Waiter for a promise blocked waiting to send.
-  IntraActivityWaiter wait_send_;
-  // Waiter for a promise blocked waiting to receive.
-  IntraActivityWaiter wait_recv_;
-  // Current state.
-  ValueState state_ = ValueState::kIdle;
-  // Has the pipe been started?
-  bool started_ = false;
+  const Operator<T>* ops_;
+  const Operator<T>* end_ops_;
 };
 
 template <typename Fn>
@@ -1424,42 +1284,187 @@ class CallFilters {
   CallFilters(CallFilters&&) = delete;
   CallFilters& operator=(CallFilters&&) = delete;
 
-  void SetStack(RefCountedPtr<Stack> stack);
+  void AddStack(RefCountedPtr<Stack> stack) {
+    if (stack->data_.empty()) return;
+    stacks_.emplace_back(std::move(stack));
+  }
+  void Start();
 
   // Access client initial metadata before it's processed
   ClientMetadata* unprocessed_client_initial_metadata() {
-    return client_initial_metadata_.get();
+    return push_client_initial_metadata_.get();
   }
 
+ private:
+  template <typename Output, typename Input,
+            Input(CallFilters::*input_location),
+            filters_detail::Layout<Input>(filters_detail::StackData::*layout),
+            void (CallState::*on_done)(), typename StackIterator>
+  class Executor {
+   public:
+    Executor(CallFilters* filters, StackIterator stack_begin,
+             StackIterator stack_end)
+        : stack_current_(stack_begin),
+          stack_end_(stack_end),
+          filters_(filters) {
+      DCHECK_NE((filters_->*input_location).get(), nullptr);
+    }
+
+    Poll<ValueOrFailure<Output>> operator()() {
+      if ((filters_->*input_location) != nullptr) {
+        if (stack_current_ == stack_end_) {
+          DCHECK_NE((filters_->*input_location).get(), nullptr);
+          (filters_->call_state_.*on_done)();
+          return Output(std::move(filters_->*input_location));
+        }
+        return FinishStep(executor_.Start(
+            &(stack_current_->stack->data_.*layout),
+            std::move(filters_->*input_location), filters_->call_data_));
+      } else {
+        return FinishStep(executor_.Step(filters_->call_data_));
+      }
+    }
+
+   private:
+    Poll<ValueOrFailure<Output>> FinishStep(
+        Poll<filters_detail::ResultOr<Input>> p) {
+      auto* r = p.value_if_ready();
+      if (r == nullptr) return Pending{};
+      if (r->ok != nullptr) {
+        ++stack_current_;
+        if (stack_current_ == stack_end_) {
+          (filters_->call_state_.*on_done)();
+          return ValueOrFailure<Output>{std::move(r->ok)};
+        }
+        return FinishStep(
+            executor_.Start(&(stack_current_->stack->data_.*layout),
+                            std::move(r->ok), filters_->call_data_));
+      }
+      (filters_->call_state_.*on_done)();
+      filters_->PushServerTrailingMetadata(std::move(r->error));
+      return Failure{};
+    }
+
+    StackIterator stack_current_;
+    StackIterator stack_end_;
+    CallFilters* filters_;
+    filters_detail::OperationExecutor<Input> executor_;
+  };
+
+ public:
   // Client: Fetch client initial metadata
   // Returns a promise that resolves to ValueOrFailure<ClientMetadataHandle>
-  GRPC_MUST_USE_RESULT auto PullClientInitialMetadata();
-  // Server: Indicate that no server initial metadata will be sent
-  void NoServerInitialMetadata() {
-    server_initial_metadata_state_.CloseSending();
+  GRPC_MUST_USE_RESULT auto PullClientInitialMetadata() {
+    call_state_.BeginPullClientInitialMetadata();
+    return Executor<ClientMetadataHandle, ClientMetadataHandle,
+                    &CallFilters::push_client_initial_metadata_,
+                    &filters_detail::StackData::client_initial_metadata,
+                    &CallState::FinishPullClientInitialMetadata,
+                    StacksVector::const_iterator>(this, stacks_.cbegin(),
+                                                  stacks_.cend());
   }
   // Server: Push server initial metadata
   // Returns a promise that resolves to a StatusFlag indicating success
-  GRPC_MUST_USE_RESULT auto PushServerInitialMetadata(ServerMetadataHandle md);
+  StatusFlag PushServerInitialMetadata(ServerMetadataHandle md) {
+    push_server_initial_metadata_ = std::move(md);
+    return call_state_.PushServerInitialMetadata();
+  }
   // Client: Fetch server initial metadata
   // Returns a promise that resolves to ValueOrFailure<ServerMetadataHandle>
-  GRPC_MUST_USE_RESULT auto PullServerInitialMetadata();
+  GRPC_MUST_USE_RESULT auto PullServerInitialMetadata() {
+    return Seq(
+        [this]() {
+          return call_state_.PollPullServerInitialMetadataAvailable();
+        },
+        [this](bool has_server_initial_metadata) {
+          return If(
+              has_server_initial_metadata,
+              [this]() {
+                return Map(
+                    Executor<
+                        absl::optional<ServerMetadataHandle>,
+                        ServerMetadataHandle,
+                        &CallFilters::push_server_initial_metadata_,
+                        &filters_detail::StackData::server_initial_metadata,
+                        &CallState::FinishPullServerInitialMetadata,
+                        StacksVector::const_reverse_iterator>(
+                        this, stacks_.crbegin(), stacks_.crend()),
+                    [](ValueOrFailure<absl::optional<ServerMetadataHandle>> r) {
+                      if (r.ok()) return std::move(*r);
+                      return absl::optional<ServerMetadataHandle>{};
+                    });
+              },
+              []() {
+                return Immediate(absl::optional<ServerMetadataHandle>{});
+              });
+        });
+  }
   // Client: Push client to server message
   // Returns a promise that resolves to a StatusFlag indicating success
-  GRPC_MUST_USE_RESULT auto PushClientToServerMessage(MessageHandle message);
-  // Client: Indicate that no more messages will be sent
-  void FinishClientToServerSends() {
-    client_to_server_message_state_.CloseSending();
+  GRPC_MUST_USE_RESULT auto PushClientToServerMessage(MessageHandle message) {
+    call_state_.BeginPushClientToServerMessage();
+    DCHECK_NE(message.get(), nullptr);
+    DCHECK_EQ(push_client_to_server_message_.get(), nullptr);
+    push_client_to_server_message_ = std::move(message);
+    return [this]() { return call_state_.PollPushClientToServerMessage(); };
   }
+  // Client: Indicate that no more messages will be sent
+  void FinishClientToServerSends() { call_state_.ClientToServerHalfClose(); }
   // Server: Fetch client to server message
   // Returns a promise that resolves to ValueOrFailure<MessageHandle>
-  GRPC_MUST_USE_RESULT auto PullClientToServerMessage();
+  GRPC_MUST_USE_RESULT auto PullClientToServerMessage() {
+    return TrySeq(
+        [this]() {
+          return call_state_.PollPullClientToServerMessageAvailable();
+        },
+        [this](bool message_available) {
+          return If(
+              message_available,
+              [this]() {
+                return Executor<
+                    absl::optional<MessageHandle>, MessageHandle,
+                    &CallFilters::push_client_to_server_message_,
+                    &filters_detail::StackData::client_to_server_messages,
+                    &CallState::FinishPullClientToServerMessage,
+                    StacksVector::const_iterator>(this, stacks_.cbegin(),
+                                                  stacks_.cend());
+              },
+              []() -> ValueOrFailure<absl::optional<MessageHandle>> {
+                return absl::optional<MessageHandle>();
+              });
+        });
+  }
   // Server: Push server to client message
   // Returns a promise that resolves to a StatusFlag indicating success
-  GRPC_MUST_USE_RESULT auto PushServerToClientMessage(MessageHandle message);
+  GRPC_MUST_USE_RESULT auto PushServerToClientMessage(MessageHandle message) {
+    call_state_.BeginPushServerToClientMessage();
+    push_server_to_client_message_ = std::move(message);
+    return [this]() { return call_state_.PollPushServerToClientMessage(); };
+  }
   // Server: Fetch server to client message
   // Returns a promise that resolves to ValueOrFailure<MessageHandle>
-  GRPC_MUST_USE_RESULT auto PullServerToClientMessage();
+  GRPC_MUST_USE_RESULT auto PullServerToClientMessage() {
+    return TrySeq(
+        [this]() {
+          return call_state_.PollPullServerToClientMessageAvailable();
+        },
+        [this](bool message_available) {
+          return If(
+              message_available,
+              [this]() {
+                return Executor<
+                    absl::optional<MessageHandle>, MessageHandle,
+                    &CallFilters::push_server_to_client_message_,
+                    &filters_detail::StackData::server_to_client_messages,
+                    &CallState::FinishPullServerToClientMessage,
+                    StacksVector::const_reverse_iterator>(
+                    this, stacks_.crbegin(), stacks_.crend());
+              },
+              []() -> ValueOrFailure<absl::optional<MessageHandle>> {
+                return absl::optional<MessageHandle>();
+              });
+        });
+  }
   // Server: Indicate end of response
   // Closes the request entirely - no messages can be sent/received
   // If no server initial metadata has been sent, implies
@@ -1467,489 +1472,61 @@ class CallFilters {
   void PushServerTrailingMetadata(ServerMetadataHandle md);
   // Client: Fetch server trailing metadata
   // Returns a promise that resolves to ServerMetadataHandle
-  GRPC_MUST_USE_RESULT auto PullServerTrailingMetadata();
+  GRPC_MUST_USE_RESULT auto PullServerTrailingMetadata() {
+    return Map(
+        [this]() { return call_state_.PollServerTrailingMetadataAvailable(); },
+        [this](Empty) {
+          auto value = std::move(push_server_trailing_metadata_);
+          if (call_data_ != nullptr) {
+            for (auto it = stacks_.crbegin(); it != stacks_.crend(); ++it) {
+              value = filters_detail::RunServerTrailingMetadata(
+                  it->stack->data_.server_trailing_metadata,
+                  filters_detail::Offset(call_data_, it->call_data_offset),
+                  std::move(value));
+            }
+          }
+          call_state_.FinishPullServerTrailingMetadata();
+          return value;
+        });
+  }
   // Server: Wait for server trailing metadata to have been sent
   // Returns a promise that resolves to a StatusFlag indicating whether the
   // request was cancelled or not -- failure to send trailing metadata is
   // considered a cancellation, as is actual cancellation -- but not application
   // errors.
-  GRPC_MUST_USE_RESULT auto WasCancelled();
+  GRPC_MUST_USE_RESULT auto WasCancelled() {
+    return [this]() { return call_state_.PollWasCancelled(); };
+  }
   // Client & server: fill in final_info with the final status of the call.
   void Finalize(const grpc_call_final_info* final_info);
 
   std::string DebugString() const;
 
  private:
-  template <filters_detail::PipeState(CallFilters::*state_ptr),
-            void*(CallFilters::*push_ptr), typename T,
-            filters_detail::Layout<filters_detail::FallibleOperator<T>>(
-                filters_detail::StackData::*layout_ptr)>
-  class PipePromise {
-   public:
-    class Push {
-     public:
-      Push(CallFilters* filters, T x)
-          : filters_(filters), value_(std::move(x)) {
-        CHECK(value_ != nullptr);
-        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-          gpr_log(GPR_INFO, "BeginPush[%p|%p]: %s", &state(), this,
-                  state().DebugString().c_str());
-        }
-        CHECK_EQ(push_slot(), nullptr);
-        state().BeginPush();
-        push_slot() = this;
-      }
-      ~Push() {
-        if (filters_ != nullptr) {
-          if (value_ != nullptr) {
-            state().DropPush();
-          }
-          CHECK(push_slot() == this);
-          push_slot() = nullptr;
-        }
-      }
-
-      Push(const Push&) = delete;
-      Push& operator=(const Push&) = delete;
-      Push(Push&& other) noexcept
-          : filters_(std::exchange(other.filters_, nullptr)),
-            value_(std::move(other.value_)) {
-        if (filters_ != nullptr) {
-          DCHECK(push_slot() == &other);
-          push_slot() = this;
-        }
-      }
-
-      Push& operator=(Push&&) = delete;
-
-      Poll<StatusFlag> operator()() {
-        if (value_ == nullptr) {
-          CHECK_EQ(filters_, nullptr);
-          if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-            gpr_log(GPR_INFO, "Push[|%p]: already done", this);
-          }
-          return Success{};
-        }
-        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-          gpr_log(GPR_INFO, "Push[%p|%p]: %s", &state(), this,
-                  state().DebugString().c_str());
-        }
-        auto r = state().PollPush();
-        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-          if (r.pending()) {
-            gpr_log(GPR_INFO, "Push[%p|%p]: pending; %s", &state(), this,
-                    state().DebugString().c_str());
-          } else if (r.value().ok()) {
-            gpr_log(GPR_INFO, "Push[%p|%p]: success; %s", &state(), this,
-                    state().DebugString().c_str());
-          } else {
-            gpr_log(GPR_INFO, "Push[%p|%p]: failure; %s", &state(), this,
-                    state().DebugString().c_str());
-          }
-        }
-        if (r.ready()) {
-          push_slot() = nullptr;
-          filters_ = nullptr;
-        }
-        return r;
-      }
-
-      T TakeValue() {
-        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-          gpr_log(GPR_INFO, "Push[%p|%p]: take value; %s", &state(), this,
-                  state().DebugString().c_str());
-        }
-        CHECK(value_ != nullptr);
-        CHECK(filters_ != nullptr);
-        push_slot() = nullptr;
-        filters_ = nullptr;
-        return std::move(value_);
-      }
-
-      absl::string_view DebugString() const {
-        return value_ != nullptr ? " (not pulled)" : "";
-      }
-
-     private:
-      filters_detail::PipeState& state() { return filters_->*state_ptr; }
-      void*& push_slot() { return filters_->*push_ptr; }
-
-      CallFilters* filters_;
-      T value_;
-    };
-
-    static std::string DebugString(absl::string_view name,
-                                   const CallFilters* filters) {
-      auto* push = static_cast<Push*>(filters->*push_ptr);
-      return absl::StrCat(name, ":", (filters->*state_ptr).DebugString(),
-                          push == nullptr ? "" : push->DebugString());
-    }
-
-    class PullMaybe {
-     public:
-      explicit PullMaybe(CallFilters* filters) : filters_(filters) {}
-      ~PullMaybe() {
-        if (filters_ != nullptr) {
-          state().DropPull();
-        }
-      }
-
-      PullMaybe(const PullMaybe&) = delete;
-      PullMaybe& operator=(const PullMaybe&) = delete;
-      PullMaybe(PullMaybe&& other) noexcept
-          : filters_(std::exchange(other.filters_, nullptr)),
-            executor_(std::move(other.executor_)) {}
-      PullMaybe& operator=(PullMaybe&&) = delete;
-
-      Poll<ValueOrFailure<absl::optional<T>>> operator()() {
-        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-          gpr_log(GPR_INFO, "PullMaybe[%p|%p]: %s executor:%d", &state(), this,
-                  state().DebugString().c_str(), executor_.IsRunning());
-        }
-        if (executor_.IsRunning()) {
-          auto c = state().PollClosed();
-          if (c.ready() && c.value()) {
-            filters_->CancelDueToFailedPipeOperation();
-            return Failure{};
-          }
-          return FinishOperationExecutor(executor_.Step(filters_->call_data_));
-        }
-        auto p = state().PollPull();
-        auto* r = p.value_if_ready();
-        if (r == nullptr) return Pending{};
-        if (!r->ok()) {
-          filters_->CancelDueToFailedPipeOperation();
-          return Failure{};
-        }
-        if (!**r) return absl::nullopt;
-        return FinishOperationExecutor(executor_.Start(
-            layout(), push()->TakeValue(), filters_->call_data_));
-      }
-
-     private:
-      filters_detail::PipeState& state() { return filters_->*state_ptr; }
-      Push* push() { return static_cast<Push*>(filters_->*push_ptr); }
-      const filters_detail::Layout<filters_detail::FallibleOperator<T>>*
-      layout() {
-        return &(filters_->stack_->data_.*layout_ptr);
-      }
-
-      Poll<ValueOrFailure<absl::optional<T>>> FinishOperationExecutor(
-          Poll<filters_detail::ResultOr<T>> p) {
-        auto* r = p.value_if_ready();
-        if (r == nullptr) return Pending{};
-        DCHECK(!executor_.IsRunning());
-        state().AckPull();
-        if (r->ok != nullptr) return std::move(r->ok);
-        filters_->PushServerTrailingMetadata(std::move(r->error));
-        return Failure{};
-      }
-
-      CallFilters* filters_;
-      filters_detail::OperationExecutor<T> executor_;
-    };
-
-    template <std::vector<filters_detail::HalfCloseOperator>(
-        filters_detail::StackData::*half_close_layout_ptr)>
-    class PullMessage {
-     public:
-      explicit PullMessage(CallFilters* filters) : filters_(filters) {}
-      ~PullMessage() {
-        if (filters_ != nullptr) {
-          state().DropPull();
-        }
-      }
-
-      PullMessage(const PullMessage&) = delete;
-      PullMessage& operator=(const PullMessage&) = delete;
-      PullMessage(PullMessage&& other) noexcept
-          : filters_(std::exchange(other.filters_, nullptr)),
-            executor_(std::move(other.executor_)) {}
-      PullMessage& operator=(PullMessage&&) = delete;
-
-      Poll<ValueOrFailure<absl::optional<MessageHandle>>> operator()() {
-        CHECK(filters_ != nullptr);
-        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-          gpr_log(GPR_INFO, "PullMessage[%p|%p]: %s executor:%d", &state(),
-                  this, state().DebugString().c_str(), executor_.IsRunning());
-        }
-        if (executor_.IsRunning()) {
-          auto c = state().PollClosed();
-          if (c.ready() && c.value()) {
-            filters_->CancelDueToFailedPipeOperation();
-            return Failure{};
-          }
-          return FinishOperationExecutor(executor_.Step(filters_->call_data_));
-        }
-        auto p = state().PollPull();
-        auto* r = p.value_if_ready();
-        if (r == nullptr) {
-          if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-            gpr_log(GPR_INFO, "PullMessage[%p] pending: %s executor:%d",
-                    &state(), state().DebugString().c_str(),
-                    executor_.IsRunning());
-          }
-          return Pending{};
-        }
-        if (!r->ok()) {
-          filters_->CancelDueToFailedPipeOperation();
-          return Failure{};
-        }
-        if (!**r) {
-          if (half_close_layout_ptr != nullptr) {
-            filters_detail::RunHalfClose(
-                filters_->stack_->data_.*half_close_layout_ptr,
-                filters_->call_data_);
-          }
-          return absl::nullopt;
-        }
-        CHECK(filters_ != nullptr);
-        return FinishOperationExecutor(executor_.Start(
-            layout(), push()->TakeValue(), filters_->call_data_));
-      }
-
-     private:
-      filters_detail::PipeState& state() { return filters_->*state_ptr; }
-      Push* push() { return static_cast<Push*>(filters_->*push_ptr); }
-      const filters_detail::Layout<filters_detail::FallibleOperator<T>>*
-      layout() {
-        return &(filters_->stack_->data_.*layout_ptr);
-      }
-
-      Poll<ValueOrFailure<absl::optional<MessageHandle>>>
-      FinishOperationExecutor(Poll<filters_detail::ResultOr<T>> p) {
-        auto* r = p.value_if_ready();
-        if (r == nullptr) return Pending{};
-        DCHECK(!executor_.IsRunning());
-        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-          gpr_log(GPR_INFO, "PullMessage[%p|%p] executor done: %s", &state(),
-                  this, state().DebugString().c_str());
-        }
-        state().AckPull();
-        if (r->ok != nullptr) return std::move(r->ok);
-        filters_->PushServerTrailingMetadata(std::move(r->error));
-        return Failure{};
-      }
-
-      CallFilters* filters_;
-      filters_detail::OperationExecutor<T> executor_;
-    };
-  };
-
-  class PullClientInitialMetadataPromise {
-   public:
-    explicit PullClientInitialMetadataPromise(CallFilters* filters)
-        : filters_(filters) {}
-
-    PullClientInitialMetadataPromise(const PullClientInitialMetadataPromise&) =
-        delete;
-    PullClientInitialMetadataPromise& operator=(
-        const PullClientInitialMetadataPromise&) = delete;
-    PullClientInitialMetadataPromise(
-        PullClientInitialMetadataPromise&& other) noexcept
-        : filters_(std::exchange(other.filters_, nullptr)),
-          executor_(std::move(other.executor_)) {}
-    PullClientInitialMetadataPromise& operator=(
-        PullClientInitialMetadataPromise&&) = delete;
-
-    Poll<ValueOrFailure<ClientMetadataHandle>> operator()() {
-      if (executor_.IsRunning()) {
-        return FinishOperationExecutor(executor_.Step(filters_->call_data_));
-      }
-      auto p = state().PollPull();
-      auto* r = p.value_if_ready();
-      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-        gpr_log(GPR_INFO, "%s",
-                r == nullptr
-                    ? "PENDING"
-                    : (r->ok() ? (r->value() ? "TRUE" : "FALSE") : "FAILURE"));
-      }
-      if (r == nullptr) return Pending{};
-      if (!r->ok()) {
-        filters_->CancelDueToFailedPipeOperation();
-        return Failure{};
-      }
-      CHECK(filters_->client_initial_metadata_ != nullptr);
-      return FinishOperationExecutor(executor_.Start(
-          &filters_->stack_->data_.client_initial_metadata,
-          std::move(filters_->client_initial_metadata_), filters_->call_data_));
-    }
-
-   private:
-    filters_detail::PipeState& state() {
-      return filters_->client_initial_metadata_state_;
-    }
-
-    Poll<ValueOrFailure<ClientMetadataHandle>> FinishOperationExecutor(
-        Poll<filters_detail::ResultOr<ClientMetadataHandle>> p) {
-      auto* r = p.value_if_ready();
-      if (r == nullptr) return Pending{};
-      DCHECK(!executor_.IsRunning());
-      state().AckPull();
-      if (r->ok != nullptr) return std::move(r->ok);
-      filters_->PushServerTrailingMetadata(std::move(r->error));
-      return Failure{};
-    }
+  void CancelDueToFailedPipeOperation(SourceLocation but_where = {});
 
-    CallFilters* filters_;
-    filters_detail::OperationExecutor<ClientMetadataHandle> executor_;
+  struct AddedStack {
+    explicit AddedStack(RefCountedPtr<Stack> stack)
+        : call_data_offset(std::numeric_limits<size_t>::max()),
+          stack(std::move(stack)) {}
+    size_t call_data_offset;
+    RefCountedPtr<Stack> stack;
   };
 
-  class PullServerTrailingMetadataPromise {
-   public:
-    explicit PullServerTrailingMetadataPromise(CallFilters* filters)
-        : filters_(filters) {}
-
-    PullServerTrailingMetadataPromise(
-        const PullServerTrailingMetadataPromise&) = delete;
-    PullServerTrailingMetadataPromise& operator=(
-        const PullServerTrailingMetadataPromise&) = delete;
-    PullServerTrailingMetadataPromise(
-        PullServerTrailingMetadataPromise&& other) noexcept
-        : filters_(std::exchange(other.filters_, nullptr)),
-          executor_(std::move(other.executor_)) {}
-    PullServerTrailingMetadataPromise& operator=(
-        PullServerTrailingMetadataPromise&&) = delete;
-
-    Poll<ServerMetadataHandle> operator()() {
-      if (executor_.IsRunning()) {
-        auto r = executor_.Step(filters_->call_data_);
-        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-          if (r.pending()) {
-            gpr_log(GPR_INFO,
-                    "%s PullServerTrailingMetadata[%p]: Pending(but executing)",
-                    GetContext<Activity>()->DebugTag().c_str(), filters_);
-          } else {
-            gpr_log(GPR_INFO, "%s PullServerTrailingMetadata[%p]: Ready: %s",
-                    GetContext<Activity>()->DebugTag().c_str(), filters_,
-                    r.value()->DebugString().c_str());
-          }
-        }
-        return r;
-      }
-      if (filters_->server_trailing_metadata_ == nullptr) {
-        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-          gpr_log(GPR_INFO,
-                  "%s PullServerTrailingMetadata[%p]: Pending(not pushed)",
-                  GetContext<Activity>()->DebugTag().c_str(), filters_);
-        }
-        return filters_->server_trailing_metadata_waiter_.pending();
-      }
-      // If no stack has been set, we can just return the result of the call
-      if (filters_->stack_ == nullptr) {
-        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-          gpr_log(GPR_INFO,
-                  "%s PullServerTrailingMetadata[%p]: Ready(no-stack): %s",
-                  GetContext<Activity>()->DebugTag().c_str(), filters_,
-                  filters_->server_trailing_metadata_->DebugString().c_str());
-        }
-        return std::move(filters_->server_trailing_metadata_);
-      }
-      // Otherwise we need to process it through all the filters.
-      auto r = executor_.Start(
-          &filters_->stack_->data_.server_trailing_metadata,
-          std::move(filters_->server_trailing_metadata_), filters_->call_data_);
-      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-        if (r.pending()) {
-          gpr_log(GPR_INFO,
-                  "%s PullServerTrailingMetadata[%p]: Pending(but executing)",
-                  GetContext<Activity>()->DebugTag().c_str(), filters_);
-        } else {
-          gpr_log(GPR_INFO, "%s PullServerTrailingMetadata[%p]: Ready: %s",
-                  GetContext<Activity>()->DebugTag().c_str(), filters_,
-                  r.value()->DebugString().c_str());
-        }
-      }
-      return r;
-    }
+  using StacksVector = absl::InlinedVector<AddedStack, 2>;
 
-   private:
-    CallFilters* filters_;
-    filters_detail::InfallibleOperationExecutor<ServerMetadataHandle> executor_;
-  };
-
-  void CancelDueToFailedPipeOperation(SourceLocation but_where = {});
+  StacksVector stacks_;
 
-  RefCountedPtr<Stack> stack_;
-
-  filters_detail::PipeState client_initial_metadata_state_{
-      filters_detail::PipeState::StartPushed{}};
-  filters_detail::PipeState server_initial_metadata_state_;
-  filters_detail::PipeState client_to_server_message_state_;
-  filters_detail::PipeState server_to_client_message_state_;
-  IntraActivityWaiter server_trailing_metadata_waiter_;
-  Latch<bool> cancelled_;
+  CallState call_state_;
 
   void* call_data_;
-  ClientMetadataHandle client_initial_metadata_;
-
-  // The following void*'s are pointers to a `Push` object (from above).
-  // They are used to track the current push operation for each pipe.
-  // It would be lovely for them to be typed pointers, but that would require
-  // a recursive type definition since the location of this field needs to be
-  // a template argument to the `Push` object itself.
-  void* server_initial_metadata_push_ = nullptr;
-  void* client_to_server_message_push_ = nullptr;
-  void* server_to_client_message_push_ = nullptr;
-
-  ServerMetadataHandle server_trailing_metadata_;
-
-  using ServerInitialMetadataPromises =
-      PipePromise<&CallFilters::server_initial_metadata_state_,
-                  &CallFilters::server_initial_metadata_push_,
-                  ServerMetadataHandle,
-                  &filters_detail::StackData::server_initial_metadata>;
-  using ClientToServerMessagePromises =
-      PipePromise<&CallFilters::client_to_server_message_state_,
-                  &CallFilters::client_to_server_message_push_, MessageHandle,
-                  &filters_detail::StackData::client_to_server_messages>;
-  using ServerToClientMessagePromises =
-      PipePromise<&CallFilters::server_to_client_message_state_,
-                  &CallFilters::server_to_client_message_push_, MessageHandle,
-                  &filters_detail::StackData::server_to_client_messages>;
+  ClientMetadataHandle push_client_initial_metadata_;
+  ServerMetadataHandle push_server_initial_metadata_;
+  MessageHandle push_client_to_server_message_;
+  MessageHandle push_server_to_client_message_;
+  ServerMetadataHandle push_server_trailing_metadata_;
 };
 
-inline auto CallFilters::PullClientInitialMetadata() {
-  return PullClientInitialMetadataPromise(this);
-}
-
-inline auto CallFilters::PushServerInitialMetadata(ServerMetadataHandle md) {
-  CHECK(md != nullptr);
-  return [p = ServerInitialMetadataPromises::Push{
-              this, std::move(md)}]() mutable { return p(); };
-}
-
-inline auto CallFilters::PullServerInitialMetadata() {
-  return ServerInitialMetadataPromises::PullMaybe{this};
-}
-
-inline auto CallFilters::PushClientToServerMessage(MessageHandle message) {
-  CHECK(message != nullptr);
-  return [p = ClientToServerMessagePromises::Push{
-              this, std::move(message)}]() mutable { return p(); };
-}
-
-inline auto CallFilters::PullClientToServerMessage() {
-  return ClientToServerMessagePromises::PullMessage<
-      &filters_detail::StackData::client_to_server_half_close>{this};
-}
-
-inline auto CallFilters::PushServerToClientMessage(MessageHandle message) {
-  CHECK(message != nullptr);
-  return [p = ServerToClientMessagePromises::Push{
-              this, std::move(message)}]() mutable { return p(); };
-}
-
-inline auto CallFilters::PullServerToClientMessage() {
-  return ServerToClientMessagePromises::PullMessage<nullptr>{this};
-}
-
-inline auto CallFilters::PullServerTrailingMetadata() {
-  return PullServerTrailingMetadataPromise(this);
-}
-
-inline auto CallFilters::WasCancelled() { return cancelled_.Wait(); }
-
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_TRANSPORT_CALL_FILTERS_H