grpc 1.48.0 → 1.50.0

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

@@ -0,0 +1,82 @@
+//
+// Copyright 2015 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_CORE_LIB_LOAD_BALANCING_LB_POLICY_REGISTRY_H
+#define GRPC_CORE_LIB_LOAD_BALANCING_LB_POLICY_REGISTRY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <map>
+#include <memory>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/json/json.h"
+#include "src/core/lib/load_balancing/lb_policy.h"
+#include "src/core/lib/load_balancing/lb_policy_factory.h"
+
+namespace grpc_core {
+
+class LoadBalancingPolicyRegistry {
+ public:
+  /// Methods used to create and populate the LoadBalancingPolicyRegistry.
+  /// NOT THREAD SAFE -- to be used only during global gRPC
+  /// initialization and shutdown.
+  class Builder {
+   public:
+    /// Registers an LB policy factory.  The factory will be used to create an
+    /// LB policy whose name matches that of the factory.
+    void RegisterLoadBalancingPolicyFactory(
+        std::unique_ptr<LoadBalancingPolicyFactory> factory);
+
+    LoadBalancingPolicyRegistry Build();
+
+   private:
+    std::map<absl::string_view, std::unique_ptr<LoadBalancingPolicyFactory>>
+        factories_;
+  };
+
+  /// Creates an LB policy of the type specified by \a name.
+  OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
+      absl::string_view name, LoadBalancingPolicy::Args args) const;
+
+  /// Returns true if the LB policy factory specified by \a name exists in this
+  /// registry. If the load balancing policy requires a config to be specified
+  /// then sets \a requires_config to true.
+  bool LoadBalancingPolicyExists(absl::string_view name,
+                                 bool* requires_config) const;
+
+  /// Returns a parsed object of the load balancing policy to be used from a
+  /// LoadBalancingConfig array \a json.
+  absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
+  ParseLoadBalancingConfig(const Json& json) const;
+
+ private:
+  LoadBalancingPolicyFactory* GetLoadBalancingPolicyFactory(
+      absl::string_view name) const;
+  absl::StatusOr<Json::Object::const_iterator> ParseLoadBalancingConfigHelper(
+      const Json& lb_config_array) const;
+
+  std::map<absl::string_view, std::unique_ptr<LoadBalancingPolicyFactory>>
+      factories_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_LOAD_BALANCING_LB_POLICY_REGISTRY_H

data/src/core/{ext/filters/client_channel → lib/load_balancing}/subchannel_interface.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_H
+#ifndef GRPC_CORE_LIB_LOAD_BALANCING_SUBCHANNEL_INTERFACE_H
+#define GRPC_CORE_LIB_LOAD_BALANCING_SUBCHANNEL_INTERFACE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -25,8 +25,8 @@
 #include "absl/status/status.h"
 
 #include <grpc/impl/codegen/connectivity_state.h>
-#include <grpc/impl/codegen/grpc_types.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
@@ -98,7 +98,7 @@ class SubchannelInterface : public RefCounted<SubchannelInterface> {
       std::unique_ptr<DataWatcherInterface> watcher) = 0;
 
   // TODO(roth): Need a better non-grpc-specific abstraction here.
-  virtual const grpc_channel_args* channel_args() = 0;
+  virtual ChannelArgs channel_args() = 0;
 };
 
 // A class that delegates to another subchannel, to be used in cases
@@ -124,7 +124,7 @@ class DelegatingSubchannel : public SubchannelInterface {
     wrapped_subchannel_->RequestConnection();
   }
   void ResetBackoff() override { wrapped_subchannel_->ResetBackoff(); }
-  const grpc_channel_args* channel_args() override {
+  ChannelArgs channel_args() override {
     return wrapped_subchannel_->channel_args();
   }
   void AddDataWatcher(std::unique_ptr<DataWatcherInterface> watcher) override {
@@ -137,4 +137,4 @@ class DelegatingSubchannel : public SubchannelInterface {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_H
+#endif  // GRPC_CORE_LIB_LOAD_BALANCING_SUBCHANNEL_INTERFACE_H

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

@@ -28,12 +28,12 @@
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
-#include "absl/utility/utility.h"
 
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gprpp/construct_destruct.h"
+#include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/promise/context.h"
@@ -56,15 +56,25 @@ class Wakeable {
   inline ~Wakeable() {}
 };
 
+namespace activity_detail {
+struct Unwakeable final : public Wakeable {
+  void Wakeup() override {}
+  void Drop() override {}
+};
+static Unwakeable* unwakeable() {
+  return NoDestructSingleton<Unwakeable>::Get();
+}
+}  // namespace activity_detail
+
+class AtomicWaker;
+
 // An owning reference to a Wakeable.
 // This type is non-copyable but movable.
 class Waker {
  public:
   explicit Waker(Wakeable* wakeable) : wakeable_(wakeable) {}
-  Waker() : Waker(nullptr) {}
-  ~Waker() {
-    if (wakeable_ != nullptr) wakeable_->Drop();
-  }
+  Waker() : Waker(activity_detail::unwakeable()) {}
+  ~Waker() { wakeable_->Drop(); }
   Waker(const Waker&) = delete;
   Waker& operator=(const Waker&) = delete;
   Waker(Waker&& other) noexcept : wakeable_(other.Take()) {}
@@ -74,9 +84,7 @@ class Waker {
   }
 
   // Wake the underlying activity.
-  void Wakeup() {
-    if (auto* wakeable = Take()) wakeable->Wakeup();
-  }
+  void Wakeup() { Take()->Wakeup(); }
 
   template <typename H>
   friend H AbslHashValue(H h, const Waker& w) {
@@ -88,11 +96,50 @@ class Waker {
   }
 
  private:
-  Wakeable* Take() { return absl::exchange(wakeable_, nullptr); }
+  friend class AtomicWaker;
+
+  Wakeable* Take() {
+    return std::exchange(wakeable_, activity_detail::unwakeable());
+  }
 
   Wakeable* wakeable_;
 };
 
+// An atomic variant of Waker - this type is non-copyable and non-movable.
+class AtomicWaker {
+ public:
+  explicit AtomicWaker(Wakeable* wakeable) : wakeable_(wakeable) {}
+  AtomicWaker() : AtomicWaker(activity_detail::unwakeable()) {}
+  explicit AtomicWaker(Waker waker) : AtomicWaker(waker.Take()) {}
+  ~AtomicWaker() { wakeable_.load(std::memory_order_acquire)->Drop(); }
+  AtomicWaker(const AtomicWaker&) = delete;
+  AtomicWaker& operator=(const AtomicWaker&) = delete;
+  AtomicWaker(AtomicWaker&& other) noexcept = delete;
+  AtomicWaker& operator=(AtomicWaker&& other) noexcept = delete;
+
+  // Wake the underlying activity.
+  void Wakeup() { Take()->Wakeup(); }
+
+  // Return true if there is a not-unwakeable wakeable present.
+  bool Armed() const noexcept {
+    return wakeable_.load(std::memory_order_relaxed) !=
+           activity_detail::unwakeable();
+  }
+
+  // Set to some new waker
+  void Set(Waker waker) {
+    wakeable_.exchange(waker.Take(), std::memory_order_acq_rel)->Wakeup();
+  }
+
+ private:
+  Wakeable* Take() {
+    return wakeable_.exchange(activity_detail::unwakeable(),
+                              std::memory_order_acq_rel);
+  }
+
+  std::atomic<Wakeable*> wakeable_;
+};
+
 // An Activity tracks execution of a single promise.
 // It executes the promise under a mutex.
 // When the promise stalls, it registers the containing activity to be woken up
@@ -267,7 +314,7 @@ class FreestandingActivity : public Activity, private Wakeable {
   // Check if we got an internal wakeup since the last time this function was
   // called.
   ActionDuringRun GotActionDuringRun() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
-    return absl::exchange(action_during_run_, ActionDuringRun::kNone);
+    return std::exchange(action_during_run_, ActionDuringRun::kNone);
   }
 
   // Implementors of Wakeable::Wakeup should call this after the wakeup has

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

@@ -19,7 +19,7 @@
 
 #include <stdlib.h>
 
-#include <type_traits>
+#include <new>
 #include <utility>
 
 #include "absl/meta/type_traits.h"
@@ -32,59 +32,58 @@ namespace grpc_core {
 
 namespace arena_promise_detail {
 
-// Type erased promise stored in the arena.
 template <typename T>
-class ImplInterface {
- public:
+struct Vtable {
   // Poll the promise, once.
-  virtual Poll<T> PollOnce() = 0;
+  Poll<T> (*poll_once)(void** arg);
   // Destroy the underlying callable object if there is one.
   // Since we don't delete (the arena owns the memory) but we may need to call a
   // destructor, we expose this for when the ArenaPromise object is destroyed.
-  virtual void Destroy() = 0;
+  void (*destroy)(void** arg);
+};
 
- protected:
-  ~ImplInterface() = default;
+template <typename T>
+struct VtableAndArg {
+  const Vtable<T>* vtable;
+  void* arg;
 };
 
-// Implementation of ImplInterface for an empty object.
+// Implementation of Vtable for an empty object.
 // Used when an empty ArenaPromise is created, or when the ArenaPromise is moved
 // from. Since in either case these objects should not be polled, we simply
 // crash if it is.
 template <typename T>
-class NullImpl final : public ImplInterface<T> {
- public:
-  Poll<T> PollOnce() override {
-    abort();
-    GPR_UNREACHABLE_CODE(return Pending{});
-  }
-  void Destroy() override {}
-
-  static ImplInterface<T>* Get() {
-    static NullImpl<T> instance;
-    return &instance;
-  }
-
- private:
-  ~NullImpl() = default;
-};
+inline const Vtable<T>* null_impl() {
+  static const Vtable<T> vtable = {[](void**) -> Poll<T> {
+                                     abort();
+                                     GPR_UNREACHABLE_CODE(return Pending{});
+                                   },
+                                   [](void**) {}};
+  return &vtable;
+}
 
 // Implementation of ImplInterface for a callable object.
 template <typename T, typename Callable>
-class CallableImpl final : public ImplInterface<T> {
- public:
-  explicit CallableImpl(Callable&& callable) : callable_(std::move(callable)) {}
-  // Forward polls to the callable object.
-  Poll<T> PollOnce() override { return poll_cast<T>(callable_()); }
-  // Destroy destructs the callable object.
-  void Destroy() override { this->~CallableImpl(); }
-
- private:
-  // Should only be called by Destroy().
-  ~CallableImpl() = default;
+inline const Vtable<T>* allocated_callable_impl() {
+  static const Vtable<T> vtable = {
+      [](void** arg) -> Poll<T> {
+        return poll_cast<T>((*static_cast<Callable*>(*arg))());
+      },
+      [](void** arg) { static_cast<Callable*>(*arg)->~Callable(); }};
+  return &vtable;
+}
 
-  Callable callable_;
-};
+// Implementation of ImplInterface for a small callable object (one that fits
+// within the void* arg)
+template <typename T, typename Callable>
+inline const Vtable<T>* inlined_callable_impl() {
+  static const Vtable<T> vtable = {
+      [](void** arg) -> Poll<T> {
+        return poll_cast<T>((*reinterpret_cast<Callable*>(arg))());
+      },
+      [](void** arg) { reinterpret_cast<Callable*>(arg)->~Callable(); }};
+  return &vtable;
+}
 
 // If a callable object is empty we can substitute any instance of that callable
 // for the one we call (for how could we tell the difference)?
@@ -94,27 +93,12 @@ class CallableImpl final : public ImplInterface<T> {
 // (this comes up often when the promise only accesses context data from the
 // containing activity).
 template <typename T, typename Callable>
-class SharedImpl final : public ImplInterface<T>, private Callable {
- public:
-  // Call the callable, or at least an exact duplicate of it - if you have no
-  // members, all your instances look the same.
-  Poll<T> PollOnce() override { return Callable::operator()(); }
-  // Nothing to destroy.
-  void Destroy() override {}
-  // Return a pointer to the shared instance - these are singletons, and are
-  // needed just to get the vtable in place.
-  static SharedImpl* Get(Callable&& callable) {
-    static_assert(sizeof(SharedImpl) == sizeof(void*),
-                  "SharedImpl should be pointer sized");
-    static SharedImpl impl(std::forward<Callable>(callable));
-    return &impl;
-  }
-
- private:
-  explicit SharedImpl(Callable&& callable)
-      : Callable(std::forward<Callable>(callable)) {}
-  ~SharedImpl() = default;
-};
+inline const Vtable<T>* shared_callable_impl(Callable&& callable) {
+  static Callable instance = std::forward<Callable>(callable);
+  static const Vtable<T> vtable = {[](void**) -> Poll<T> { return instance(); },
+                                   [](void**) {}};
+  return &vtable;
+}
 
 // Redirector type: given a callable type, expose a Make() function that creates
 // the appropriate underlying implementation.
@@ -123,26 +107,41 @@ struct ChooseImplForCallable;
 
 template <typename T, typename Callable>
 struct ChooseImplForCallable<
-    T, Callable, absl::enable_if_t<!std::is_empty<Callable>::value>> {
-  static ImplInterface<T>* Make(Callable&& callable) {
-    return GetContext<Arena>()->template New<CallableImpl<T, Callable>>(
-        std::forward<Callable>(callable));
+    T, Callable,
+    absl::enable_if_t<!std::is_empty<Callable>::value &&
+                      (sizeof(Callable) > sizeof(void*))>> {
+  static void Make(Callable&& callable, VtableAndArg<T>* out) {
+    *out = {allocated_callable_impl<T, Callable>(),
+            GetContext<Arena>()->template New<Callable>(
+                std::forward<Callable>(callable))};
+  }
+};
+
+template <typename T, typename Callable>
+struct ChooseImplForCallable<
+    T, Callable,
+    absl::enable_if_t<!std::is_empty<Callable>::value &&
+                      (sizeof(Callable) <= sizeof(void*))>> {
+  static void Make(Callable&& callable, VtableAndArg<T>* out) {
+    out->vtable = inlined_callable_impl<T, Callable>();
+    new (&out->arg) Callable(std::forward<Callable>(callable));
   }
 };
 
 template <typename T, typename Callable>
 struct ChooseImplForCallable<
     T, Callable, absl::enable_if_t<std::is_empty<Callable>::value>> {
-  static ImplInterface<T>* Make(Callable&& callable) {
-    return SharedImpl<T, Callable>::Get(std::forward<Callable>(callable));
+  static void Make(Callable&& callable, VtableAndArg<T>* out) {
+    out->vtable =
+        shared_callable_impl<T, Callable>(std::forward<Callable>(callable));
   }
 };
 
 // Wrap ChooseImplForCallable with a friend approachable syntax.
 template <typename T, typename Callable>
-ImplInterface<T>* MakeImplForCallable(Callable&& callable) {
-  return ChooseImplForCallable<T, Callable>::Make(
-      std::forward<Callable>(callable));
+void MakeImplForCallable(Callable&& callable, VtableAndArg<T>* out) {
+  ChooseImplForCallable<T, Callable>::Make(std::forward<Callable>(callable),
+                                           out);
 }
 
 }  // namespace arena_promise_detail
@@ -159,38 +158,42 @@ class ArenaPromise {
             typename Ignored =
                 absl::enable_if_t<!std::is_same<Callable, ArenaPromise>::value>>
   // NOLINTNEXTLINE(google-explicit-constructor)
-  ArenaPromise(Callable&& callable)
-      : impl_(arena_promise_detail::MakeImplForCallable<T>(
-            std::forward<Callable>(callable))) {}
+  ArenaPromise(Callable&& callable) {
+    arena_promise_detail::MakeImplForCallable<T>(
+        std::forward<Callable>(callable), &vtable_and_arg_);
+  }
 
   // ArenaPromise is not copyable.
   ArenaPromise(const ArenaPromise&) = delete;
   ArenaPromise& operator=(const ArenaPromise&) = delete;
   // ArenaPromise is movable.
-  ArenaPromise(ArenaPromise&& other) noexcept : impl_(other.impl_) {
-    other.impl_ = arena_promise_detail::NullImpl<T>::Get();
+  ArenaPromise(ArenaPromise&& other) noexcept
+      : vtable_and_arg_(other.vtable_and_arg_) {
+    other.vtable_and_arg_.vtable = arena_promise_detail::null_impl<T>();
   }
   ArenaPromise& operator=(ArenaPromise&& other) noexcept {
-    impl_->Destroy();
-    impl_ = other.impl_;
-    other.impl_ = arena_promise_detail::NullImpl<T>::Get();
+    vtable_and_arg_.vtable->destroy(&vtable_and_arg_.arg);
+    vtable_and_arg_ = other.vtable_and_arg_;
+    other.vtable_and_arg_.vtable = arena_promise_detail::null_impl<T>();
     return *this;
   }
 
   // Destruction => call Destroy on the underlying impl object.
-  ~ArenaPromise() { impl_->Destroy(); }
+  ~ArenaPromise() { vtable_and_arg_.vtable->destroy(&vtable_and_arg_.arg); }
 
   // Expose the promise interface: a call operator that returns Poll<T>.
-  Poll<T> operator()() { return impl_->PollOnce(); }
+  Poll<T> operator()() {
+    return vtable_and_arg_.vtable->poll_once(&vtable_and_arg_.arg);
+  }
 
   bool has_value() const {
-    return impl_ != arena_promise_detail::NullImpl<T>::Get();
+    return vtable_and_arg_.vtable != arena_promise_detail::null_impl<T>();
   }
 
  private:
   // Underlying impl object.
-  arena_promise_detail::ImplInterface<T>* impl_ =
-      arena_promise_detail::NullImpl<T>::Get();
+  arena_promise_detail::VtableAndArg<T> vtable_and_arg_ = {
+      arena_promise_detail::null_impl<T>(), nullptr};
 };
 
 }  // namespace grpc_core

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

@@ -17,7 +17,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <type_traits>
 #include <utility>
 
 #include "src/core/lib/gpr/tls.h"
@@ -78,7 +77,7 @@ T* GetContext() {
 // Given a promise and a context, return a promise that has that context set.
 template <typename T, typename F>
 promise_detail::WithContext<T, F> WithContext(F f, T* context) {
-  return promise_detail::WithContext<T, F>(f, context);
+  return promise_detail::WithContext<T, F>(std::move(f), context);
 }
 
 }  // namespace grpc_core

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

@@ -17,11 +17,12 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <array>
 #include <cassert>
 #include <new>
 #include <tuple>
-#include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"
@@ -31,12 +32,29 @@
 #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 {
 
+// Given f0, ..., fn, call function idx and return the result.
+template <typename R, typename A, R (*... f)(A* arg)>
+class JumpTable {
+ public:
+  JumpTable() = delete;
+  JumpTable(const JumpTable&) = delete;
+
+  static R Run(size_t idx, A* arg) { return fs_[idx](arg); }
+
+ private:
+  using Fn = R (*)(A* arg);
+  static const Fn fs_[sizeof...(f)];
+};
+
+template <typename R, typename A, R (*... f)(A* arg)>
+const typename JumpTable<R, A, f...>::Fn
+    JumpTable<R, A, f...>::fs_[sizeof...(f)] = {f...};
+
 // Helper for SeqState to evaluate some common types to all partial
 // specializations.
 template <template <typename> class Traits, typename FPromise, typename FNext>
@@ -335,16 +353,14 @@ class BasicSeq {
   // parameter unpacking can work.
   template <char I>
   struct RunStateStruct {
-    BasicSeq* s;
-    Poll<Result> operator()() { return s->RunState<I>(); }
+    static Poll<Result> Run(BasicSeq* s) { return s->RunState<I>(); }
   };
 
   // Similarly placate those compilers for
   // DestructCurrentPromiseAndSubsequentFactories
   template <char I>
   struct DestructCurrentPromiseAndSubsequentFactoriesStruct {
-    BasicSeq* s;
-    void operator()() {
+    static void Run(BasicSeq* s) {
       return s->DestructCurrentPromiseAndSubsequentFactories<I>();
     }
   };
@@ -357,7 +373,8 @@ class BasicSeq {
   // 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}...);
+    return JumpTable<Poll<Result>, BasicSeq, RunStateStruct<I>::Run...>::Run(
+        state_, this);
   }
 
   // Run the appropriate destructors for a given state.
@@ -367,8 +384,9 @@ class BasicSeq {
   // 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}...);
+    JumpTable<void, BasicSeq,
+              DestructCurrentPromiseAndSubsequentFactoriesStruct<I>::Run...>::
+        Run(state_, this);
   }
 
  public:
@@ -403,20 +421,22 @@ class BasicSeq {
 
 // As above, but models a sequence of unknown size
 // At each element, the accumulator A and the current value V is passed to some
-// function of type F as f(V, A); f is expected to return a promise that
-// resolves to Traits::WrappedType.
-template <template <typename Wrapped> class Traits, typename F, typename Arg,
-          typename Iter>
+// function of type IterTraits::Factory as f(V, IterTraits::Argument); f is
+// expected to return a promise that resolves to IterTraits::Wrapped.
+template <class IterTraits>
 class BasicSeqIter {
  private:
-  using IterValue = decltype(*std::declval<Iter>());
-  using StateCreated = decltype(std::declval<F>()(std::declval<IterValue>(),
-                                                  std::declval<Arg>()));
-  using State = PromiseLike<StateCreated>;
-  using Wrapped = typename State::Result;
+  using Traits = typename IterTraits::Traits;
+  using Iter = typename IterTraits::Iter;
+  using Factory = typename IterTraits::Factory;
+  using Argument = typename IterTraits::Argument;
+  using IterValue = typename IterTraits::IterValue;
+  using StateCreated = typename IterTraits::StateCreated;
+  using State = typename IterTraits::State;
+  using Wrapped = typename IterTraits::Wrapped;
 
  public:
-  BasicSeqIter(Iter begin, Iter end, F f, Arg arg)
+  BasicSeqIter(Iter begin, Iter end, Factory f, Argument arg)
       : cur_(begin), end_(end), f_(std::move(f)) {
     if (cur_ == end_) {
       Construct(&result_, std::move(arg));
@@ -466,7 +486,7 @@ class BasicSeqIter {
   Poll<Wrapped> PollNonEmpty() {
     Poll<Wrapped> r = state_();
     if (absl::holds_alternative<Pending>(r)) return r;
-    return Traits<Wrapped>::template CheckResultAndRunNext<Wrapped>(
+    return Traits::template CheckResultAndRunNext<Wrapped>(
         std::move(absl::get<Wrapped>(r)), [this](Wrapped arg) -> Poll<Wrapped> {
           auto next = cur_;
           ++next;
@@ -476,17 +496,17 @@ class BasicSeqIter {
           cur_ = next;
           state_.~State();
           Construct(&state_,
-                    Traits<Wrapped>::CallSeqFactory(f_, *cur_, std::move(arg)));
+                    Traits::template CallSeqFactory(f_, *cur_, std::move(arg)));
           return PollNonEmpty();
         });
   }
 
   Iter cur_;
   const Iter end_;
-  GPR_NO_UNIQUE_ADDRESS F f_;
+  GPR_NO_UNIQUE_ADDRESS Factory f_;
   union {
     GPR_NO_UNIQUE_ADDRESS State state_;
-    GPR_NO_UNIQUE_ADDRESS Arg result_;
+    GPR_NO_UNIQUE_ADDRESS Argument result_;
   };
 };
 

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

@@ -17,7 +17,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"

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

@@ -20,7 +20,6 @@
 #include <stddef.h>
 
 #include <tuple>
-#include <type_traits>
 #include <utility>
 
 #include "absl/types/variant.h"