grpc 1.56.2 → 1.58.0

data/src/core/lib/iomgr/vsock.h

@@ -0,0 +1,38 @@
+//
+//
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_LIB_IOMGR_VSOCK_H
+#define GRPC_SRC_CORE_LIB_IOMGR_VSOCK_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/support/string_util.h>
+
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+
+absl::StatusOr<std::vector<grpc_resolved_address>> grpc_resolve_vsock_address(
+    absl::string_view name);
+
+int grpc_is_vsock(const grpc_resolved_address* resolved_addr);
+
+#endif /* GRPC_SRC_CORE_LIB_IOMGR_VSOCK_H */

data/src/core/lib/iomgr/wakeup_fd_posix.h

@@ -81,12 +81,9 @@ extern int grpc_allow_pipe_wakeup_fd;
 
 #define GRPC_WAKEUP_FD_GET_READ_FD(fd_info) ((fd_info)->read_fd)
 
-grpc_error_handle grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info)
-    GRPC_MUST_USE_RESULT;
-grpc_error_handle grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info)
-    GRPC_MUST_USE_RESULT;
-grpc_error_handle grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info)
-    GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info);
+grpc_error_handle grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info);
+grpc_error_handle grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info);
 void grpc_wakeup_fd_destroy(grpc_wakeup_fd* fd_info);
 
 // Defined in some specialized implementation's .c file, or by

data/src/core/lib/load_balancing/delegating_helper.h

@@ -0,0 +1,115 @@
+//
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_LIB_LOAD_BALANCING_DELEGATING_HELPER_H
+#define GRPC_SRC_CORE_LIB_LOAD_BALANCING_DELEGATING_HELPER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/connectivity_state.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/load_balancing/lb_policy.h"
+#include "src/core/lib/load_balancing/subchannel_interface.h"
+#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/security/credentials/credentials.h"
+
+namespace grpc_core {
+
+/// A helper for use in parent policies.  All methods delegate to a
+/// parent policy's helper unless otherwise overridden.
+class LoadBalancingPolicy::DelegatingChannelControlHelper
+    : public LoadBalancingPolicy::ChannelControlHelper {
+ public:
+  RefCountedPtr<SubchannelInterface> CreateSubchannel(
+      ServerAddress address, const ChannelArgs& args) override {
+    return parent_helper()->CreateSubchannel(std::move(address), args);
+  }
+
+  void UpdateState(grpc_connectivity_state state, const absl::Status& status,
+                   RefCountedPtr<SubchannelPicker> picker) override {
+    parent_helper()->UpdateState(state, status, std::move(picker));
+  }
+
+  void RequestReresolution() override {
+    parent_helper()->RequestReresolution();
+  }
+
+  absl::string_view GetAuthority() override {
+    return parent_helper()->GetAuthority();
+  }
+
+  RefCountedPtr<grpc_channel_credentials> GetChannelCredentials() override {
+    return parent_helper()->GetChannelCredentials();
+  }
+
+  RefCountedPtr<grpc_channel_credentials> GetUnsafeChannelCredentials()
+      override {
+    return parent_helper()->GetUnsafeChannelCredentials();
+  }
+
+  grpc_event_engine::experimental::EventEngine* GetEventEngine() override {
+    return parent_helper()->GetEventEngine();
+  }
+
+  void AddTraceEvent(TraceSeverity severity,
+                     absl::string_view message) override {
+    parent_helper()->AddTraceEvent(severity, message);
+  }
+
+ private:
+  /// Returns the parent helper that we should delegate to by default.
+  virtual ChannelControlHelper* parent_helper() const = 0;
+};
+
+/// A delegating helper that owns a ref to the parent policy.
+template <typename ParentPolicy>
+class LoadBalancingPolicy::ParentOwningDelegatingChannelControlHelper
+    : public LoadBalancingPolicy::DelegatingChannelControlHelper {
+ public:
+  explicit ParentOwningDelegatingChannelControlHelper(
+      RefCountedPtr<ParentPolicy> parent)
+      : parent_(std::move(parent)) {}
+
+  ~ParentOwningDelegatingChannelControlHelper() override {
+    parent_.reset(DEBUG_LOCATION, "Helper");
+  }
+
+ protected:
+  ParentPolicy* parent() const {
+    return static_cast<ParentPolicy*>(parent_.get());
+  }
+
+  ChannelControlHelper* parent_helper() const override {
+    return parent_->channel_control_helper();
+  }
+
+ private:
+  RefCountedPtr<LoadBalancingPolicy> parent_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_LOAD_BALANCING_DELEGATING_HELPER_H

data/src/core/lib/load_balancing/lb_policy.h

@@ -35,6 +35,7 @@
 #include "absl/types/variant.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
 #include <grpc/impl/connectivity_state.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h"
@@ -297,6 +298,20 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// Returns the channel authority.
     virtual absl::string_view GetAuthority() = 0;
 
+    /// Returns the channel credentials from the parent channel.  This can
+    /// be used to create a control-plane channel inside an LB policy.
+    virtual RefCountedPtr<grpc_channel_credentials> GetChannelCredentials() = 0;
+
+    /// Returns the UNSAFE ChannelCredentials used to construct the channel,
+    /// including bearer tokens.  LB policies should generally have no use for
+    /// these credentials, and use of them is heavily discouraged.  These must
+    /// be used VERY carefully to avoid sending bearer tokens to untrusted
+    /// servers, as the server could then impersonate the client.  Generally,
+    /// it is safe to use these credentials only when communicating with the
+    /// backends.
+    virtual RefCountedPtr<grpc_channel_credentials>
+    GetUnsafeChannelCredentials() = 0;
+
     /// Returns the EventEngine to use for timers and async work.
     virtual grpc_event_engine::experimental::EventEngine* GetEventEngine() = 0;
 
@@ -306,6 +321,11 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
                                absl::string_view message) = 0;
   };
 
+  class DelegatingChannelControlHelper;
+
+  template <typename ParentPolicy>
+  class ParentOwningDelegatingChannelControlHelper;
+
   /// Interface for configuration data used by an LB policy implementation.
   /// Individual implementations will create a subclass that adds methods to
   /// return the parameters they need.

data/src/core/lib/load_balancing/subchannel_interface.h

@@ -97,6 +97,9 @@ class SubchannelInterface : public DualRefCounted<SubchannelInterface> {
   // Registers a new data watcher.
   virtual void AddDataWatcher(
       std::unique_ptr<DataWatcherInterface> watcher) = 0;
+
+  // Cancels a data watch.
+  virtual void CancelDataWatcher(DataWatcherInterface* watcher) = 0;
 };
 
 // A class that delegates to another subchannel, to be used in cases
@@ -125,6 +128,9 @@ class DelegatingSubchannel : public SubchannelInterface {
   void AddDataWatcher(std::unique_ptr<DataWatcherInterface> watcher) override {
     wrapped_subchannel_->AddDataWatcher(std::move(watcher));
   }
+  void CancelDataWatcher(DataWatcherInterface* watcher) override {
+    wrapped_subchannel_->CancelDataWatcher(watcher);
+  }
 
  private:
   RefCountedPtr<SubchannelInterface> wrapped_subchannel_;

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

@@ -17,384 +17,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <array>
-#include <cassert>
-#include <new>
-#include <tuple>
-#include <utility>
-
-#include "absl/meta/type_traits.h"
-#include "absl/utility/utility.h"
-
 #include "src/core/lib/gprpp/construct_destruct.h"
-#include "src/core/lib/promise/detail/promise_factory.h"
-#include "src/core/lib/promise/detail/promise_like.h"
-#include "src/core/lib/promise/detail/switch.h"
 #include "src/core/lib/promise/poll.h"
 
 namespace grpc_core {
 namespace promise_detail {
 
-// Helper for SeqState to evaluate some common types to all partial
-// specializations.
-template <template <typename> class Traits, typename FPromise, typename FNext>
-struct SeqStateTypes {
-  // Our current promise.
-  using Promise = FPromise;
-  // The result of our current promise.
-  using PromiseResult = typename Promise::Result;
-  // Traits around the result of our promise.
-  using PromiseResultTraits = Traits<PromiseResult>;
-  // Wrap the factory callable in our factory wrapper to deal with common edge
-  // cases. We use the 'unwrapped type' from the traits, so for instance, TrySeq
-  // can pass back a T from a StatusOr<T>.
-  using Next = promise_detail::OncePromiseFactory<
-      typename PromiseResultTraits::UnwrappedType, FNext>;
-};
-
-// One state in a sequence.
-// A state contains the current promise, and the promise factory to turn the
-// result of the current promise into the next state's promise. We play a shell
-// game such that the prior state and our current promise are kept in a union,
-// and the next promise factory is kept alongside in the state struct.
-// Recursively this guarantees that the next functions get initialized once, and
-// destroyed once, and don't need to be moved around in between, which avoids a
-// potential O(n**2) loop of next factory moves had we used a variant of states
-// here. The very first state does not have a prior state, and so that state has
-// a partial specialization below. The final state does not have a next state;
-// that state is inlined in BasicSeq since that was simpler to type.
-template <template <typename> class Traits, char I, typename... Fs>
-struct SeqState {
-  // The state evaluated before this state.
-  using PriorState = SeqState<Traits, I - 1, Fs...>;
-  // Initialization from callables.
-  explicit SeqState(std::tuple<Fs*...> fs)
-      : next_factory(std::move(*std::get<I + 1>(fs))) {
-    new (&prior) PriorState(fs);
-  }
-  // Move constructor - assumes we're in the initial state (move prior) as it's
-  // illegal to move a promise after polling it.
-  SeqState(SeqState&& other) noexcept
-      : next_factory(std::move(other.next_factory)) {
-    new (&prior) PriorState(std::move(other.prior));
-  }
-  // Copy constructor - assumes we're in the initial state (move prior) as it's
-  // illegal to move a promise after polling it.
-  SeqState(const SeqState& other) : next_factory(other.next_factory) {
-    new (&prior) PriorState(std::move(other.prior));
-  }
-  // Empty destructor - we instead destruct the innards in BasicSeq manually
-  // depending on state.
-  ~SeqState() {}
-  // Evaluate the current promise, next promise factory types for this state.
-  // The current promise is the next promise from the prior state.
-  // The next factory callable is from the callables passed in:
-  // Fs[0] is the initial promise, Fs[1] is the state 0 next factory, Fs[2] is
-  // the state 1 next factory, etc...
-  using Types = SeqStateTypes<
-      Traits, typename PriorState::Types::Next::Promise,
-      typename std::tuple_element<I + 1, std::tuple<Fs...>>::type>;
-  // Storage for either the current promise or the prior state.
-  union {
-    // If we're in the prior state.
-    GPR_NO_UNIQUE_ADDRESS PriorState prior;
-    // The callables representing our promise.
-    GPR_NO_UNIQUE_ADDRESS typename Types::Promise current_promise;
-  };
-  // Storage for the next promise factory.
-  GPR_NO_UNIQUE_ADDRESS typename Types::Next next_factory;
-};
-
-// Partial specialization of SeqState above for the first state - it has no
-// prior state, so we take the first callable from the template arg list and use
-// it as a promise.
-template <template <typename> class Traits, typename... Fs>
-struct SeqState<Traits, 0, Fs...> {
-  // Initialization from callables.
-  explicit SeqState(std::tuple<Fs*...> args)
-      : current_promise(std::move(*std::get<0>(args))),
-        next_factory(std::move(*std::get<1>(args))) {}
-  // Move constructor - it's assumed we're in this state (see above).
-  SeqState(SeqState&& other) noexcept
-      : current_promise(std::move(other.current_promise)),
-        next_factory(std::move(other.next_factory)) {}
-  // Copy constructor - it's assumed we're in this state (see above).
-  SeqState(const SeqState& other)
-      : current_promise(other.current_promise),
-        next_factory(other.next_factory) {}
-  // Empty destructor - we instead destruct the innards in BasicSeq manually
-  // depending on state.
-  ~SeqState() {}
-  // Evaluate the current promise, next promise factory types for this state.
-  // Our callable is the first element of Fs, wrapped in PromiseLike to handle
-  // some common edge cases. The next factory is the second element.
-  using Types = SeqStateTypes<
-      Traits,
-      PromiseLike<typename std::tuple_element<0, std::tuple<Fs...>>::type>,
-      typename std::tuple_element<1, std::tuple<Fs...>>::type>;
-  GPR_NO_UNIQUE_ADDRESS typename Types::Promise current_promise;
-  GPR_NO_UNIQUE_ADDRESS typename Types::Next next_factory;
-};
-
-// Helper to get a specific state index.
-// Calls the prior state, unless it's this state, in which case it returns
-// that.
-template <char I, template <typename> class Traits, char J, typename... Fs>
-struct GetSeqStateInner {
-  static SeqState<Traits, I, Fs...>* f(SeqState<Traits, J, Fs...>* p) {
-    return GetSeqStateInner<I, Traits, J - 1, Fs...>::f(&p->prior);
-  }
-};
-
-template <char I, template <typename> class Traits, typename... Fs>
-struct GetSeqStateInner<I, Traits, I, Fs...> {
-  static SeqState<Traits, I, Fs...>* f(SeqState<Traits, I, Fs...>* p) {
-    return p;
-  }
-};
-
-template <char I, template <typename> class Traits, char J, typename... Fs>
-absl::enable_if_t<I <= J, SeqState<Traits, I, Fs...>*> GetSeqState(
-    SeqState<Traits, J, Fs...>* p) {
-  return GetSeqStateInner<I, Traits, J, Fs...>::f(p);
-}
-
-template <template <typename> class Traits, char I, typename... Fs, typename T>
-auto CallNext(SeqState<Traits, I, Fs...>* state, T&& arg)
-    -> decltype(SeqState<Traits, I, Fs...>::Types::PromiseResultTraits::
-                    CallFactory(&state->next_factory, std::forward<T>(arg))) {
-  return SeqState<Traits, I, Fs...>::Types::PromiseResultTraits::CallFactory(
-      &state->next_factory, std::forward<T>(arg));
-}
-
-// A sequence under some traits for some set of callables Fs.
-// Fs[0] should be a promise-like object that yields a value.
-// Fs[1..] should be promise-factory-like objects that take the value from the
-// previous step and yield a promise. Note that most of the machinery in
-// PromiseFactory exists to make it possible for those promise-factory-like
-// objects to be anything that's convenient. Traits defines how we move from one
-// step to the next. Traits sets up the wrapping and escape handling for the
-// sequence. Promises return wrapped values that the trait can inspect and
-// unwrap before passing them to the next element of the sequence. The trait can
-// also interpret a wrapped value as an escape value, which terminates
-// evaluation of the sequence immediately yielding a result. Traits for type T
-// have the members:
-//  * type UnwrappedType - the type after removing wrapping from T (i.e. for
-//    TrySeq, T=StatusOr<U> yields UnwrappedType=U).
-//  * type WrappedType - the type after adding wrapping if it doesn't already
-//    exist (i.e. for TrySeq if T is not Status/StatusOr/void, then
-//    WrappedType=StatusOr<T>; if T is Status then WrappedType=Status (it's
-//    already wrapped!))
-//  * template <typename Next> void CallFactory(Next* next_factory, T&& value) -
-//    call promise factory next_factory with the result of unwrapping value, and
-//    return the resulting promise.
-//  * template <typename Result, typename RunNext> Poll<Result>
-//    CheckResultAndRunNext(T prior, RunNext run_next) - examine the value of
-//    prior, and decide to escape or continue. If escaping, return the final
-//    sequence value of type Poll<Result>. If continuing, return the value of
-//    run_next(std::move(prior)).
-template <template <typename> class Traits, typename... Fs>
-class BasicSeq {
- private:
-  // Number of states in the sequence - we'll refer to this some!
-  static constexpr char N = sizeof...(Fs);
-
-  // Current state.
-  static_assert(N < 128, "Long sequence... please revisit BasicSeq");
-  char state_ = 0;
-  // The penultimate state contains all the preceding states too.
-  using PenultimateState = SeqState<Traits, N - 2, Fs...>;
-  // The final state is simply the final promise, which is the next promise from
-  // the penultimate state.
-  using FinalPromise = typename PenultimateState::Types::Next::Promise;
-  union {
-    GPR_NO_UNIQUE_ADDRESS PenultimateState penultimate_state_;
-    GPR_NO_UNIQUE_ADDRESS FinalPromise final_promise_;
-  };
-  using FinalPromiseResult = typename FinalPromise::Result;
-  using Result = typename Traits<FinalPromiseResult>::WrappedType;
-
-  // Get a state by index.
-  template <char I>
-      absl::enable_if_t < I<N - 2, SeqState<Traits, I, Fs...>*> state() {
-    return GetSeqState<I>(&penultimate_state_);
-  }
-
-  template <char I>
-  absl::enable_if_t<I == N - 2, PenultimateState*> state() {
-    return &penultimate_state_;
-  }
-
-  // Get the next state's promise.
-  template <char I>
-  auto next_promise() -> absl::enable_if_t<
-      I != N - 2,
-      decltype(&GetSeqState<I + 1>(static_cast<PenultimateState*>(nullptr))
-                    ->current_promise)> {
-    return &GetSeqState<I + 1>(&penultimate_state_)->current_promise;
-  }
-
-  template <char I>
-  absl::enable_if_t<I == N - 2, FinalPromise*> next_promise() {
-    return &final_promise_;
-  }
-
-  // Callable to advance the state to the next one after I given the result from
-  // state I.
-  template <char I>
-  struct RunNext {
-    BasicSeq* s;
-    template <typename T>
-    Poll<Result> operator()(T&& value) {
-      auto* prior = s->state<I>();
-      using StateType = absl::remove_reference_t<decltype(*prior)>;
-      // Destroy the promise that just completed.
-      Destruct(&prior->current_promise);
-      // Construct the next promise by calling the next promise factory.
-      // We need to ask the traits to do this to deal with value
-      // wrapping/unwrapping.
-      auto n = StateType::Types::PromiseResultTraits::CallFactory(
-          &prior->next_factory, std::forward<T>(value));
-      // Now we also no longer need the factory, so we can destroy that.
-      Destruct(&prior->next_factory);
-      // Constructing the promise for the new state will use the memory
-      // previously occupied by the promise & next factory of the old state.
-      Construct(s->next_promise<I>(), std::move(n));
-      // Store the state counter.
-      s->state_ = I + 1;
-      // Recursively poll the new current state.
-      return s->RunState<I + 1>();
-    }
-  };
-
-  // Poll the current state, advance it if necessary.
-  template <char I>
-  absl::enable_if_t<I != N - 1, Poll<Result>> RunState() {
-    // Get a pointer to the state object.
-    auto* s = state<I>();
-    // Poll the current promise in this state.
-    auto r = s->current_promise();
-    // If we are still pending, say so by returning.
-    if (r.pending()) return Pending();
-    // Current promise is ready, as the traits to do the next thing.
-    // That may be returning - eg if TrySeq sees an error.
-    // Or it may be by calling the callable we hand down - RunNext - which
-    // will advance the state and call the next promise.
-    return Traits<
-        typename absl::remove_reference_t<decltype(*s)>::Types::PromiseResult>::
-        template CheckResultAndRunNext<Result>(std::move(r.value()),
-                                               RunNext<I>{this});
-  }
-
-  // Specialization of RunState to run the final state.
-  template <char I>
-  absl::enable_if_t<I == N - 1, Poll<Result>> RunState() {
-    // Poll the final promise.
-    auto r = final_promise_();
-    // If we are still pending, say so by returning.
-    if (r.pending()) return Pending();
-    // We are complete, return the (wrapped) result.
-    return Result(std::move(r.value()));
-  }
-
-  // For state numbered I, destruct the current promise and the next promise
-  // factory, and recursively destruct the next promise factories for future
-  // states (since they also still exist).
-  template <char I>
-  absl::enable_if_t<I != N - 1, void>
-  DestructCurrentPromiseAndSubsequentFactories() {
-    Destruct(&GetSeqState<I>(&penultimate_state_)->current_promise);
-    DestructSubsequentFactories<I>();
-  }
-
-  template <char I>
-  absl::enable_if_t<I == N - 1, void>
-  DestructCurrentPromiseAndSubsequentFactories() {
-    Destruct(&final_promise_);
-  }
-
-  // For state I, destruct the next promise factory, and recursively the next
-  // promise factories after.
-  template <char I>
-  absl::enable_if_t<I != N - 1, void> DestructSubsequentFactories() {
-    Destruct(&GetSeqState<I>(&penultimate_state_)->next_factory);
-    DestructSubsequentFactories<I + 1>();
-  }
-
-  template <char I>
-  absl::enable_if_t<I == N - 1, void> DestructSubsequentFactories() {}
-
-  // Placate older compilers by wrapping RunState in a struct so that their
-  // parameter unpacking can work.
-  template <char I>
-  struct RunStateStruct {
-    BasicSeq* s;
-    Poll<Result> operator()() { return s->RunState<I>(); }
-  };
-
-  // Similarly placate those compilers for
-  // DestructCurrentPromiseAndSubsequentFactories
-  template <char I>
-  struct DestructCurrentPromiseAndSubsequentFactoriesStruct {
-    BasicSeq* s;
-    void operator()() {
-      return s->DestructCurrentPromiseAndSubsequentFactories<I>();
-    }
-  };
-
-  // Run the current state (and possibly later states if that one finishes).
-  // Single argument is a type that encodes the integer sequence 0, 1, 2, ...,
-  // N-1 as a type, but which uses no memory. This is used to expand out
-  // RunState instances using a template unpack to pass to Switch, which encodes
-  // a switch statement over the various cases. This ultimately gives us a
-  // Duff's device like mechanic for evaluating sequences.
-  template <char... I>
-  Poll<Result> Run(absl::integer_sequence<char, I...>) {
-    return Switch<Poll<Result>>(state_, RunStateStruct<I>{this}...);
-  }
-
-  // Run the appropriate destructors for a given state.
-  // Single argument is a type that encodes the integer sequence 0, 1, 2, ...,
-  // N-1 as a type, but which uses no memory. This is used to expand out
-  // DestructCurrentPromiseAndSubsequentFactories instances to pass to Switch,
-  // which can choose the correct instance at runtime to destroy everything.
-  template <char... I>
-  void RunDestruct(absl::integer_sequence<char, I...>) {
-    Switch<void>(
-        state_, DestructCurrentPromiseAndSubsequentFactoriesStruct<I>{this}...);
-  }
-
- public:
-  // Construct a sequence given the callables that will control it.
-  explicit BasicSeq(Fs... fs) : penultimate_state_(std::make_tuple(&fs...)) {}
-  // No assignment... we don't need it (but if we ever find a good case, then
-  // it's ok to implement).
-  BasicSeq& operator=(const BasicSeq&) = delete;
-  // Copy construction - only for state 0.
-  // It's illegal to copy a Promise after polling it - if we are in state>0 we
-  // *must* have been polled.
-  BasicSeq(const BasicSeq& other) {
-    assert(other.state_ == 0);
-    new (&penultimate_state_) PenultimateState(other.penultimate_state_);
-  }
-  // Move construction - only for state 0.
-  // It's illegal to copy a Promise after polling it - if we are in state>0 we
-  // *must* have been polled.
-  BasicSeq(BasicSeq&& other) noexcept {
-    assert(other.state_ == 0);
-    new (&penultimate_state_)
-        PenultimateState(std::move(other.penultimate_state_));
-  }
-  // Destruct based on current state.
-  ~BasicSeq() { RunDestruct(absl::make_integer_sequence<char, N>()); }
-
-  // Poll the sequence once.
-  Poll<Result> operator()() {
-    return Run(absl::make_integer_sequence<char, N>());
-  }
-};
-
-// As above, but models a sequence of unknown size
+// Models a sequence of unknown size
 // At each element, the accumulator A and the current value V is passed to some
 // function of type IterTraits::Factory as f(V, IterTraits::Argument); f is
 // expected to return a promise that resolves to IterTraits::Wrapped.