grpc 1.52.0.pre2 → 1.53.0.pre2

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

@@ -12,16 +12,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_PIPE_H
-#define GRPC_CORE_LIB_PROMISE_PIPE_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_PIPE_H
+#define GRPC_SRC_CORE_LIB_PROMISE_PIPE_H
 
 #include <grpc/support/port_platform.h>
 
 #include <stdint.h>
+#include <stdlib.h>
 
+#include <memory>
 #include <string>
+#include <type_traits>
 #include <utility>
 
+#include "absl/base/attributes.h"
 #include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
@@ -29,14 +33,19 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/if.h"
+#include "src/core/lib/promise/interceptor_list.h"
 #include "src/core/lib/promise/intra_activity_waiter.h"
+#include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/seq.h"
+#include "src/core/lib/promise/trace.h"
 #include "src/core/lib/resource_quota/arena.h"
 
-extern grpc_core::DebugOnlyTraceFlag grpc_trace_promise_pipe;
-
 namespace grpc_core {
 
 namespace pipe_detail {
@@ -56,21 +65,24 @@ struct Pipe;
 template <typename T>
 class NextResult final {
  public:
-  explicit NextResult(pipe_detail::Center<T>* center) : center_(center) {}
+  NextResult() : center_(nullptr) {}
+  explicit NextResult(RefCountedPtr<pipe_detail::Center<T>> center)
+      : center_(std::move(center)) {
+    GPR_ASSERT(center_ != nullptr);
+  }
+  explicit NextResult(bool cancelled)
+      : center_(nullptr), cancelled_(cancelled) {}
   ~NextResult();
   NextResult(const NextResult&) = delete;
   NextResult& operator=(const NextResult&) = delete;
-  NextResult(NextResult&& other) noexcept
-      : center_(std::exchange(other.center_, nullptr)) {}
-  NextResult& operator=(NextResult&& other) noexcept {
-    center_ = std::exchange(other.center_, nullptr);
-    return *this;
-  }
+  NextResult(NextResult&& other) noexcept = default;
+  NextResult& operator=(NextResult&& other) noexcept = default;
 
   using value_type = T;
 
   void reset();
   bool has_value() const;
+  // Only valid if has_value()
   const T& value() const {
     GPR_ASSERT(has_value());
     return **this;
@@ -81,9 +93,12 @@ class NextResult final {
   }
   const T& operator*() const;
   T& operator*();
+  // Only valid if !has_value()
+  bool cancelled() { return cancelled_; }
 
  private:
-  pipe_detail::Center<T>* center_;
+  RefCountedPtr<pipe_detail::Center<T>> center_;
+  bool cancelled_;
 };
 
 namespace pipe_detail {
@@ -96,71 +111,39 @@ class Next;
 // Center sits between a sender and a receiver to provide a one-deep buffer of
 // Ts
 template <typename T>
-class Center {
+class Center : public InterceptorList<T> {
  public:
   // Initialize with one send ref (held by PipeSender) and one recv ref (held by
   // PipeReceiver)
   Center() {
-    send_refs_ = 1;
-    recv_refs_ = 1;
+    refs_ = 2;
     value_state_ = ValueState::kEmpty;
   }
 
-  // Add one ref to the send side of this object, and return this.
-  Center* RefSend() {
-    if (grpc_trace_promise_pipe.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("RefSend").c_str());
-    }
-    send_refs_++;
-    GPR_ASSERT(send_refs_ != 0);
-    return this;
-  }
-
-  // Add one ref to the recv side of this object, and return this.
-  Center* RefRecv() {
-    if (grpc_trace_promise_pipe.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("RefRecv").c_str());
+  // Add one ref to this object, and return this.
+  void IncrementRefCount() {
+    if (grpc_trace_promise_primitives.enabled()) {
+      gpr_log(GPR_DEBUG, "%s", DebugOpString("IncrementRefCount").c_str());
     }
-    recv_refs_++;
-    GPR_ASSERT(recv_refs_ != 0);
-    return this;
+    refs_++;
+    GPR_DEBUG_ASSERT(refs_ != 0);
   }
 
-  // Drop a send side ref
-  // If no send refs remain, wake due to send closure
-  // If no refs remain, destroy this object
-  void UnrefSend() {
-    if (grpc_trace_promise_pipe.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("UnrefSend").c_str());
-    }
-    GPR_DEBUG_ASSERT(send_refs_ > 0);
-    send_refs_--;
-    if (0 == send_refs_) {
-      on_full_.Wake();
-      on_empty_.Wake();
-      if (0 == recv_refs_) {
-        this->~Center();
-      }
-    }
+  RefCountedPtr<Center> Ref() {
+    IncrementRefCount();
+    return RefCountedPtr<Center>(this);
   }
 
-  // Drop a recv side ref
-  // If no recv refs remain, wake due to recv closure
+  // Drop a ref
   // If no refs remain, destroy this object
-  void UnrefRecv() {
-    if (grpc_trace_promise_pipe.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("UnrefRecv").c_str());
+  void Unref() {
+    if (grpc_trace_promise_primitives.enabled()) {
+      gpr_log(GPR_DEBUG, "%s", DebugOpString("Unref").c_str());
     }
-    GPR_DEBUG_ASSERT(recv_refs_ > 0);
-    recv_refs_--;
-    if (0 == recv_refs_) {
-      on_full_.Wake();
-      on_empty_.Wake();
-      if (0 == send_refs_) {
-        this->~Center();
-      } else if (value_state_ == ValueState::kReady) {
-        ResetValue();
-      }
+    GPR_DEBUG_ASSERT(refs_ > 0);
+    refs_--;
+    if (0 == refs_) {
+      this->~Center();
     }
   }
 
@@ -169,26 +152,45 @@ class Center {
   // Return true if the value was pushed.
   // Return false if the recv end is closed.
   Poll<bool> Push(T* value) {
-    if (grpc_trace_promise_pipe.enabled()) {
+    if (grpc_trace_promise_primitives.enabled()) {
       gpr_log(GPR_INFO, "%s", DebugOpString("Push").c_str());
     }
-    GPR_DEBUG_ASSERT(send_refs_ != 0);
-    if (recv_refs_ == 0) return false;
-    if (value_state_ != ValueState::kEmpty) return on_empty_.pending();
-    value_state_ = ValueState::kReady;
-    value_ = std::move(*value);
-    on_full_.Wake();
-    return true;
+    GPR_DEBUG_ASSERT(refs_ != 0);
+    switch (value_state_) {
+      case ValueState::kClosed:
+      case ValueState::kReadyClosed:
+      case ValueState::kCancelled:
+        return false;
+      case ValueState::kReady:
+      case ValueState::kAcked:
+        return on_empty_.pending();
+      case ValueState::kEmpty:
+        value_state_ = ValueState::kReady;
+        value_ = std::move(*value);
+        on_full_.Wake();
+        return true;
+    }
+    GPR_UNREACHABLE_CODE(return false);
   }
 
   Poll<bool> PollAck() {
-    if (grpc_trace_promise_pipe.enabled()) {
+    if (grpc_trace_promise_primitives.enabled()) {
       gpr_log(GPR_INFO, "%s", DebugOpString("PollAck").c_str());
     }
-    GPR_DEBUG_ASSERT(send_refs_ != 0);
-    if (recv_refs_ == 0) return value_state_ == ValueState::kAcked;
-    if (value_state_ != ValueState::kAcked) return on_empty_.pending();
-    value_state_ = ValueState::kEmpty;
+    GPR_DEBUG_ASSERT(refs_ != 0);
+    switch (value_state_) {
+      case ValueState::kClosed:
+      case ValueState::kReadyClosed:
+      case ValueState::kCancelled:
+        return false;
+      case ValueState::kReady:
+      case ValueState::kEmpty:
+        return on_empty_.pending();
+      case ValueState::kAcked:
+        value_state_ = ValueState::kEmpty;
+        on_empty_.Wake();
+        return true;
+    }
     return true;
   }
 
@@ -196,47 +198,107 @@ class Center {
   // Return Pending if there is no value.
   // Return the value if one was retrieved.
   // Return nullopt if the send end is closed and no value had been pushed.
-  Poll<NextResult<T>> Next() {
-    if (grpc_trace_promise_pipe.enabled()) {
+  Poll<absl::optional<T>> Next() {
+    if (grpc_trace_promise_primitives.enabled()) {
       gpr_log(GPR_INFO, "%s", DebugOpString("Next").c_str());
     }
-    GPR_DEBUG_ASSERT(recv_refs_ != 0);
-    if (value_state_ != ValueState::kReady) {
-      if (send_refs_ == 0) return NextResult<T>(nullptr);
-      return on_full_.pending();
+    GPR_DEBUG_ASSERT(refs_ != 0);
+    switch (value_state_) {
+      case ValueState::kEmpty:
+      case ValueState::kAcked:
+        return on_full_.pending();
+      case ValueState::kReadyClosed:
+        this->ResetInterceptorList();
+        value_state_ = ValueState::kClosed;
+        ABSL_FALLTHROUGH_INTENDED;
+      case ValueState::kReady:
+        return std::move(value_);
+      case ValueState::kClosed:
+      case ValueState::kCancelled:
+        return absl::nullopt;
     }
-    return NextResult<T>(RefRecv());
+    GPR_UNREACHABLE_CODE(return absl::nullopt);
   }
 
   void AckNext() {
-    if (grpc_trace_promise_pipe.enabled()) {
+    if (grpc_trace_promise_primitives.enabled()) {
       gpr_log(GPR_INFO, "%s", DebugOpString("AckNext").c_str());
     }
-    GPR_DEBUG_ASSERT(value_state_ == ValueState::kReady);
-    value_state_ = ValueState::kAcked;
-    on_empty_.Wake();
-    UnrefRecv();
+    switch (value_state_) {
+      case ValueState::kReady:
+        value_state_ = ValueState::kAcked;
+        on_empty_.Wake();
+        break;
+      case ValueState::kReadyClosed:
+        this->ResetInterceptorList();
+        value_state_ = ValueState::kClosed;
+        break;
+      case ValueState::kClosed:
+      case ValueState::kCancelled:
+        break;
+      case ValueState::kEmpty:
+      case ValueState::kAcked:
+        abort();
+    }
+  }
+
+  void MarkClosed() {
+    if (grpc_trace_promise_primitives.enabled()) {
+      gpr_log(GPR_INFO, "%s", DebugOpString("MarkClosed").c_str());
+    }
+    switch (value_state_) {
+      case ValueState::kEmpty:
+      case ValueState::kAcked:
+        this->ResetInterceptorList();
+        value_state_ = ValueState::kClosed;
+        on_full_.Wake();
+        break;
+      case ValueState::kReady:
+        value_state_ = ValueState::kReadyClosed;
+        break;
+      case ValueState::kReadyClosed:
+      case ValueState::kClosed:
+      case ValueState::kCancelled:
+        break;
+    }
   }
 
+  void MarkCancelled() {
+    if (grpc_trace_promise_primitives.enabled()) {
+      gpr_log(GPR_INFO, "%s", DebugOpString("MarkCancelled").c_str());
+    }
+    switch (value_state_) {
+      case ValueState::kEmpty:
+      case ValueState::kAcked:
+      case ValueState::kReady:
+      case ValueState::kReadyClosed:
+        this->ResetInterceptorList();
+        value_state_ = ValueState::kCancelled;
+        on_full_.Wake();
+        break;
+      case ValueState::kClosed:
+        value_state_ = ValueState::kCancelled;
+        break;
+      case ValueState::kCancelled:
+        break;
+    }
+  }
+
+  bool cancelled() { return value_state_ == ValueState::kCancelled; }
+
   T& value() { return value_; }
   const T& value() const { return value_; }
 
- private:
   std::string DebugTag() {
-    return absl::StrCat(Activity::current()->DebugTag(), "PIPE[0x",
-                        reinterpret_cast<uintptr_t>(this), "]: ");
-  }
-  std::string DebugOpString(std::string op) {
-    return absl::StrCat(DebugTag(), op, " send_refs=", send_refs_,
-                        " recv_refs=", recv_refs_,
-                        " value_state=", ValueStateName(value_state_));
-  }
-  void ResetValue() {
-    // Fancy dance to move out of value in the off chance that we reclaim some
-    // memory earlier.
-    [](T) {}(std::move(value_));
-    value_state_ = ValueState::kEmpty;
+    if (auto* activity = Activity::current()) {
+      return absl::StrCat(activity->DebugTag(), " PIPE[0x",
+                          reinterpret_cast<uintptr_t>(this), "]: ");
+    } else {
+      return absl::StrCat("PIPE[0x", reinterpret_cast<uintptr_t>(this), "]: ");
+    }
   }
+
+ private:
   // State of value_.
   enum class ValueState : uint8_t {
     // No value is set, it's possible to send.
@@ -246,31 +308,52 @@ class Center {
     // Value has been received and acked, we can unblock senders and transition
     // to empty.
     kAcked,
+    // Pipe is closed successfully, no more values can be sent
+    kClosed,
+    // Pipe is closed successfully, no more values can be sent
+    // (but one value is queued and ready to be received)
+    kReadyClosed,
+    // Pipe is closed unsuccessfully, no more values can be sent
+    kCancelled,
   };
+
+  std::string DebugOpString(std::string op) {
+    return absl::StrCat(DebugTag(), op, " refs=", refs_,
+                        " value_state=", ValueStateName(value_state_),
+                        " on_empty=", on_empty_.DebugString().c_str(),
+                        " on_full=", on_full_.DebugString().c_str());
+  }
+
   static const char* ValueStateName(ValueState state) {
     switch (state) {
       case ValueState::kEmpty:
-        return "kEmpty";
+        return "Empty";
       case ValueState::kReady:
-        return "kReady";
+        return "Ready";
       case ValueState::kAcked:
-        return "kAcked";
+        return "Acked";
+      case ValueState::kClosed:
+        return "Closed";
+      case ValueState::kReadyClosed:
+        return "ReadyClosed";
+      case ValueState::kCancelled:
+        return "Cancelled";
     }
     GPR_UNREACHABLE_CODE(return "unknown");
   }
+
   T value_;
-  // Number of sending objects.
-  // 0 => send is closed.
-  // 1 ref each for PipeSender and Push.
-  uint8_t send_refs_ : 2;
-  // Number of receiving objects.
-  // 0 => recv is closed.
-  // 1 ref each for PipeReceiver, Next, and NextResult.
-  uint8_t recv_refs_ : 2;
+  // Number of refs
+  uint8_t refs_;
   // Current state of the value.
-  ValueState value_state_ : 2;
+  ValueState value_state_;
   IntraActivityWaiter on_empty_;
   IntraActivityWaiter on_full_;
+
+  // Make failure to destruct show up in ASAN builds.
+#ifndef NDEBUG
+  std::unique_ptr<int> asan_canary_ = std::make_unique<int>(0);
+#endif
 };
 
 }  // namespace pipe_detail
@@ -283,23 +366,18 @@ class PipeSender {
 
   PipeSender(const PipeSender&) = delete;
   PipeSender& operator=(const PipeSender&) = delete;
-
-  PipeSender(PipeSender&& other) noexcept : center_(other.center_) {
-    other.center_ = nullptr;
-  }
-  PipeSender& operator=(PipeSender&& other) noexcept {
-    if (center_ != nullptr) center_->UnrefSend();
-    center_ = other.center_;
-    other.center_ = nullptr;
-    return *this;
-  }
+  PipeSender(PipeSender&& other) noexcept = default;
+  PipeSender& operator=(PipeSender&& other) noexcept = default;
 
   ~PipeSender() {
-    if (center_ != nullptr) center_->UnrefSend();
+    if (center_ != nullptr) center_->MarkClosed();
   }
 
   void Close() {
-    if (auto* center = std::exchange(center_, nullptr)) center->UnrefSend();
+    if (center_ != nullptr) {
+      center_->MarkClosed();
+      center_.reset();
+    }
   }
 
   void Swap(PipeSender<T>* other) { std::swap(center_, other->center_); }
@@ -310,32 +388,37 @@ class PipeSender {
   // receiver is either closed or able to receive another message.
   PushType Push(T value);
 
+  template <typename Fn>
+  void InterceptAndMap(Fn f, DebugLocation from = {}) {
+    center_->PrependMap(std::move(f), from);
+  }
+
+  template <typename Fn, typename OnHalfClose>
+  void InterceptAndMap(Fn f, OnHalfClose cleanup_fn, DebugLocation from = {}) {
+    center_->PrependMapWithCleanup(std::move(f), std::move(cleanup_fn), from);
+  }
+
  private:
   friend struct Pipe<T>;
   explicit PipeSender(pipe_detail::Center<T>* center) : center_(center) {}
-  pipe_detail::Center<T>* center_;
+  RefCountedPtr<pipe_detail::Center<T>> center_;
+
+  // Make failure to destruct show up in ASAN builds.
+#ifndef NDEBUG
+  std::unique_ptr<int> asan_canary_ = std::make_unique<int>(0);
+#endif
 };
 
 // Receive end of a Pipe.
 template <typename T>
 class PipeReceiver {
  public:
-  using NextType = pipe_detail::Next<T>;
-
   PipeReceiver(const PipeReceiver&) = delete;
   PipeReceiver& operator=(const PipeReceiver&) = delete;
-
-  PipeReceiver(PipeReceiver&& other) noexcept : center_(other.center_) {
-    other.center_ = nullptr;
-  }
-  PipeReceiver& operator=(PipeReceiver&& other) noexcept {
-    if (center_ != nullptr) center_->UnrefRecv();
-    center_ = other.center_;
-    other.center_ = nullptr;
-    return *this;
-  }
+  PipeReceiver(PipeReceiver&& other) noexcept = default;
+  PipeReceiver& operator=(PipeReceiver&& other) noexcept = default;
   ~PipeReceiver() {
-    if (center_ != nullptr) center_->UnrefRecv();
+    if (center_ != nullptr) center_->MarkClosed();
   }
 
   void Swap(PipeReceiver<T>* other) { std::swap(center_, other->center_); }
@@ -345,12 +428,28 @@ class PipeReceiver {
   // message was received, or no value if the other end of the pipe was closed.
   // Blocks the promise until the receiver is either closed or a message is
   // available.
-  NextType Next();
+  auto Next();
+
+  template <typename Fn>
+  void InterceptAndMap(Fn f, DebugLocation from = {}) {
+    center_->AppendMap(std::move(f), from);
+  }
+
+  template <typename Fn, typename OnHalfClose>
+  void InterceptAndMapWithHalfClose(Fn f, OnHalfClose cleanup_fn,
+                                    DebugLocation from = {}) {
+    center_->AppendMapWithCleanup(std::move(f), std::move(cleanup_fn), from);
+  }
 
  private:
   friend struct Pipe<T>;
   explicit PipeReceiver(pipe_detail::Center<T>* center) : center_(center) {}
-  pipe_detail::Center<T>* center_;
+  RefCountedPtr<pipe_detail::Center<T>> center_;
+
+  // Make failure to destruct show up in ASAN builds.
+#ifndef NDEBUG
+  std::unique_ptr<int> asan_canary_ = std::make_unique<int>(0);
+#endif
 };
 
 namespace pipe_detail {
@@ -361,42 +460,33 @@ class Push {
  public:
   Push(const Push&) = delete;
   Push& operator=(const Push&) = delete;
-  Push(Push&& other) noexcept
-      : center_(other.center_), push_(std::move(other.push_)) {
-    other.center_ = nullptr;
-  }
-  Push& operator=(Push&& other) noexcept {
-    if (center_ != nullptr) center_->UnrefSend();
-    center_ = other.center_;
-    other.center_ = nullptr;
-    push_ = std::move(other.push_);
-    return *this;
-  }
-
-  ~Push() {
-    if (center_ != nullptr) center_->UnrefSend();
-  }
+  Push(Push&& other) noexcept = default;
+  Push& operator=(Push&& other) noexcept = default;
 
   Poll<bool> operator()() {
-    if (push_.has_value()) {
-      auto r = center_->Push(&*push_);
-      if (auto* ok = absl::get_if<bool>(&r)) {
-        push_.reset();
+    if (center_ == nullptr) return false;
+    if (auto* p = absl::get_if<T>(&state_)) {
+      auto r = center_->Push(p);
+      if (auto* ok = r.value_if_ready()) {
+        state_.template emplace<AwaitingAck>();
         if (!*ok) return false;
       } else {
         return Pending{};
       }
     }
-    GPR_DEBUG_ASSERT(!push_.has_value());
+    GPR_DEBUG_ASSERT(absl::holds_alternative<AwaitingAck>(state_));
     return center_->PollAck();
   }
 
  private:
+  struct AwaitingAck {};
+
   friend class PipeSender<T>;
-  explicit Push(pipe_detail::Center<T>* center, T push)
-      : center_(center), push_(std::move(push)) {}
-  Center<T>* center_;
-  absl::optional<T> push_;
+  explicit Push(RefCountedPtr<pipe_detail::Center<T>> center, T push)
+      : center_(std::move(center)), state_(std::move(push)) {}
+
+  RefCountedPtr<Center<T>> center_;
+  absl::variant<T, AwaitingAck> state_;
 };
 
 // Implementation of PipeReceiver::Next promise.
@@ -405,46 +495,56 @@ class Next {
  public:
   Next(const Next&) = delete;
   Next& operator=(const Next&) = delete;
-  Next(Next&& other) noexcept : center_(other.center_) {
-    other.center_ = nullptr;
-  }
-  Next& operator=(Next&& other) noexcept {
-    if (center_ != nullptr) center_->UnrefRecv();
-    center_ = other.center_;
-    other.center_ = nullptr;
-    return *this;
-  }
+  Next(Next&& other) noexcept = default;
+  Next& operator=(Next&& other) noexcept = default;
 
-  ~Next() {
-    if (center_ != nullptr) center_->UnrefRecv();
-  }
-
-  Poll<NextResult<T>> operator()() {
-    auto r = center_->Next();
-    if (!absl::holds_alternative<Pending>(r)) {
-      std::exchange(center_, nullptr)->UnrefRecv();
-    }
-    return r;
-  }
+  Poll<absl::optional<T>> operator()() { return center_->Next(); }
 
  private:
   friend class PipeReceiver<T>;
-  explicit Next(pipe_detail::Center<T>* center) : center_(center) {}
-  Center<T>* center_;
+  explicit Next(RefCountedPtr<Center<T>> center) : center_(std::move(center)) {}
+
+  RefCountedPtr<Center<T>> center_;
 };
 
 }  // namespace pipe_detail
 
 template <typename T>
 pipe_detail::Push<T> PipeSender<T>::Push(T value) {
-  return pipe_detail::Push<T>(center_->RefSend(), std::move(value));
+  return pipe_detail::Push<T>(center_ == nullptr ? nullptr : center_->Ref(),
+                              std::move(value));
 }
 
 template <typename T>
-pipe_detail::Next<T> PipeReceiver<T>::Next() {
-  return pipe_detail::Next<T>(center_->RefRecv());
+auto PipeReceiver<T>::Next() {
+  return Seq(
+      pipe_detail::Next<T>(center_->Ref()),
+      [center = center_->Ref()](absl::optional<T> value) {
+        bool open = value.has_value();
+        bool cancelled = center->cancelled();
+        return If(
+            open,
+            [center = std::move(center), value = std::move(value)]() mutable {
+              auto run_interceptors = center->Run(std::move(value));
+              return Map(std::move(run_interceptors),
+                         [center = std::move(center)](
+                             absl::optional<T> value) mutable {
+                           if (value.has_value()) {
+                             center->value() = std::move(*value);
+                             return NextResult<T>(std::move(center));
+                           } else {
+                             center->MarkCancelled();
+                             return NextResult<T>(true);
+                           }
+                         });
+            },
+            [cancelled]() { return NextResult<T>(cancelled); });
+      });
 }
 
+template <typename T>
+using PipeReceiverNextType = decltype(std::declval<PipeReceiver<T>>().Next());
+
 template <typename T>
 bool NextResult<T>::has_value() const {
   return center_ != nullptr;
@@ -467,7 +567,10 @@ NextResult<T>::~NextResult() {
 
 template <typename T>
 void NextResult<T>::reset() {
-  if (auto* p = std::exchange(center_, nullptr)) p->AckNext();
+  if (center_ != nullptr) {
+    center_->AckNext();
+    center_.reset();
+  }
 }
 
 // A Pipe is an intra-Activity communications channel that transmits T's from
@@ -502,4 +605,4 @@ struct Pipe {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_PIPE_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_PIPE_H