grpc 1.46.3 → 1.53.1

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

@@ -12,15 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_CONTEXT_H
-#define GRPC_CORE_LIB_PROMISE_CONTEXT_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_CONTEXT_H
+#define GRPC_SRC_CORE_LIB_PROMISE_CONTEXT_H
 
 #include <grpc/support/port_platform.h>
 
 #include <type_traits>
 #include <utility>
 
-#include "src/core/lib/gpr/tls.h"
+#include <grpc/support/log.h>
 
 namespace grpc_core {
 
@@ -29,7 +29,7 @@ namespace grpc_core {
 // not contain any members, only exist.
 // The reason for avoiding this is that context types each use a thread local.
 template <typename T>
-struct ContextType;
+struct ContextType;  // IWYU pragma: keep
 
 namespace promise_detail {
 
@@ -45,12 +45,11 @@ class Context : public ContextType<T> {
 
  private:
   T* const old_;
-  static GPR_THREAD_LOCAL(T*) current_;
+  static thread_local T* current_;
 };
 
 template <typename T>
-GPR_THREAD_LOCAL(T*)
-Context<T>::current_;
+thread_local T* Context<T>::current_;
 
 template <typename T, typename F>
 class WithContext {
@@ -69,18 +68,26 @@ class WithContext {
 
 }  // namespace promise_detail
 
-// Retrieve the current value of a context.
+// Return true if a context of type T is currently active.
+template <typename T>
+bool HasContext() {
+  return promise_detail::Context<T>::get() != nullptr;
+}
+
+// Retrieve the current value of a context, or abort if the value is unset.
 template <typename T>
 T* GetContext() {
-  return promise_detail::Context<T>::get();
+  auto* p = promise_detail::Context<T>::get();
+  GPR_ASSERT(p != nullptr);
+  return p;
 }
 
 // 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
 
-#endif  // GRPC_CORE_LIB_PROMISE_CONTEXT_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_CONTEXT_H

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

@@ -0,0 +1,197 @@
+// Copyright 2021 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_PROMISE_DETAIL_BASIC_JOIN_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_JOIN_H
+
+#include <grpc/support/port_platform.h>
+
+#include <assert.h>
+#include <stddef.h>
+
+#include <array>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/utility/utility.h"
+
+#include "src/core/lib/gprpp/bitset.h"
+#include "src/core/lib/gprpp/construct_destruct.h"
+#include "src/core/lib/promise/detail/promise_like.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+namespace promise_detail {
+
+// This union can either be a functor, or the result of the functor (after
+// mapping via a trait). Allows us to remember the result of one joined functor
+// until the rest are ready.
+template <typename Traits, typename F>
+union Fused {
+  explicit Fused(F&& f) : f(std::forward<F>(f)) {}
+  explicit Fused(PromiseLike<F>&& f) : f(std::forward<PromiseLike<F>>(f)) {}
+  ~Fused() {}
+  // Wrap the functor in a PromiseLike to handle immediately returning functors
+  // and the like.
+  using Promise = PromiseLike<F>;
+  GPR_NO_UNIQUE_ADDRESS Promise f;
+  // Compute the result type: We take the result of the promise, and pass it via
+  // our traits, so that, for example, TryJoin and take a StatusOr<T> and just
+  // store a T.
+  using Result = typename Traits::template ResultType<typename Promise::Result>;
+  GPR_NO_UNIQUE_ADDRESS Result result;
+};
+
+// A join gets composed of joints... these are just wrappers around a Fused for
+// their data, with some machinery as methods to get the system working.
+template <typename Traits, size_t kRemaining, typename... Fs>
+struct Joint : public Joint<Traits, kRemaining - 1, Fs...> {
+  // The index into Fs for this Joint
+  static constexpr size_t kIdx = sizeof...(Fs) - kRemaining;
+  // The next join (the one we derive from)
+  using NextJoint = Joint<Traits, kRemaining - 1, Fs...>;
+  // From Fs, extract the functor for this joint.
+  using F = typename std::tuple_element<kIdx, std::tuple<Fs...>>::type;
+  // Generate the Fused type for this functor.
+  using Fsd = Fused<Traits, F>;
+  GPR_NO_UNIQUE_ADDRESS Fsd fused;
+  // Figure out what kind of bitmask will be used by the outer join.
+  using Bits = BitSet<sizeof...(Fs)>;
+  // Initialize from a tuple of pointers to Fs
+  explicit Joint(std::tuple<Fs*...> fs)
+      : NextJoint(fs), fused(std::move(*std::get<kIdx>(fs))) {}
+  // Copy: assume that the Fuse is still in the promise state (since it's not
+  // legal to copy after the first poll!)
+  Joint(const Joint& j) : NextJoint(j), fused(j.fused.f) {}
+  // Move: assume that the Fuse is still in the promise state (since it's not
+  // legal to move after the first poll!)
+  Joint(Joint&& j) noexcept
+      : NextJoint(std::forward<NextJoint>(j)), fused(std::move(j.fused.f)) {}
+  // Destruct: check bits to see if we're in promise or result state, and call
+  // the appropriate destructor. Recursively, call up through the join.
+  void DestructAll(const Bits& bits) {
+    if (!bits.is_set(kIdx)) {
+      Destruct(&fused.f);
+    } else {
+      Destruct(&fused.result);
+    }
+    NextJoint::DestructAll(bits);
+  }
+  // Poll all joints up, and then call finally.
+  template <typename F>
+  auto Run(Bits* bits, F finally) -> decltype(finally()) {
+    // If we're still in the promise state...
+    if (!bits->is_set(kIdx)) {
+      // Poll the promise
+      auto r = fused.f();
+      if (auto* p = r.value_if_ready()) {
+        // If it's done, then ask the trait to unwrap it and store that result
+        // in the Fused, and continue the iteration. Note that OnResult could
+        // instead choose to return a value instead of recursing through the
+        // iteration, in that case we continue returning the same result up.
+        // Here is where TryJoin can escape out.
+        return Traits::OnResult(
+            std::move(*p), [this, bits, &finally](typename Fsd::Result result) {
+              bits->set(kIdx);
+              Destruct(&fused.f);
+              Construct(&fused.result, std::move(result));
+              return NextJoint::Run(bits, std::move(finally));
+            });
+      }
+    }
+    // That joint is still pending... we'll still poll the result of the joints.
+    return NextJoint::Run(bits, std::move(finally));
+  }
+};
+
+// Terminating joint... for each of the recursions, do the thing we're supposed
+// to do at the end.
+template <typename Traits, typename... Fs>
+struct Joint<Traits, 0, Fs...> {
+  explicit Joint(std::tuple<Fs*...>) {}
+  Joint(const Joint&) {}
+  Joint(Joint&&) noexcept {}
+  template <typename T>
+  void DestructAll(const T&) {}
+  template <typename F>
+  auto Run(BitSet<sizeof...(Fs)>*, F finally) -> decltype(finally()) {
+    return finally();
+  }
+};
+
+template <typename Traits, typename... Fs>
+class BasicJoin {
+ private:
+  // How many things are we joining?
+  static constexpr size_t N = sizeof...(Fs);
+  // Bitset: if a bit is 0, that joint is still in promise state. If it's 1,
+  // then the joint has a result.
+  GPR_NO_UNIQUE_ADDRESS BitSet<N> state_;
+  // The actual joints, wrapped in an anonymous union to give us control of
+  // construction/destruction.
+  union {
+    GPR_NO_UNIQUE_ADDRESS Joint<Traits, sizeof...(Fs), Fs...> joints_;
+  };
+
+  // Access joint index I
+  template <size_t I>
+  Joint<Traits, sizeof...(Fs) - I, Fs...>* GetJoint() {
+    return static_cast<Joint<Traits, sizeof...(Fs) - I, Fs...>*>(&joints_);
+  }
+
+  // The tuple of results of all our promises
+  using Tuple = std::tuple<typename Fused<Traits, Fs>::Result...>;
+
+  // Collect up all the results and construct a tuple.
+  template <size_t... I>
+  Tuple Finish(absl::index_sequence<I...>) {
+    return Tuple(std::move(GetJoint<I>()->fused.result)...);
+  }
+
+ public:
+  explicit BasicJoin(Fs&&... fs) : joints_(std::tuple<Fs*...>(&fs...)) {}
+  BasicJoin& operator=(const BasicJoin&) = delete;
+  // Copy a join - only available before polling.
+  BasicJoin(const BasicJoin& other) {
+    assert(other.state_.none());
+    Construct(&joints_, other.joints_);
+  }
+  // Move a join - only available before polling.
+  BasicJoin(BasicJoin&& other) noexcept {
+    assert(other.state_.none());
+    Construct(&joints_, std::move(other.joints_));
+  }
+  ~BasicJoin() { joints_.DestructAll(state_); }
+  using Result = decltype(Traits::Wrap(std::declval<Tuple>()));
+  // Poll the join
+  Poll<Result> operator()() {
+    // Poll the joints...
+    return joints_.Run(&state_, [this]() -> Poll<Result> {
+      // If all of them are completed, collect the results, and then ask our
+      // traits to wrap them - allowing for example TryJoin to turn tuple<A,B,C>
+      // into StatusOr<tuple<A,B,C>>.
+      if (state_.all()) {
+        return Traits::Wrap(Finish(absl::make_index_sequence<N>()));
+      } else {
+        return Pending();
+      }
+    });
+  }
+};
+
+}  // namespace promise_detail
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_JOIN_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H
-#define GRPC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H
 
 #include <grpc/support/port_platform.h>
 
@@ -24,18 +24,16 @@
 #include <utility>
 
 #include "absl/meta/type_traits.h"
-#include "absl/types/variant.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 {
-template <typename F>
-class PromiseLike;
 
 // Helper for SeqState to evaluate some common types to all partial
 // specializations.
@@ -50,7 +48,7 @@ struct SeqStateTypes {
   // 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::PromiseFactory<
+  using Next = promise_detail::OncePromiseFactory<
       typename PromiseResultTraits::UnwrappedType, FNext>;
 };
 
@@ -277,18 +275,15 @@ class BasicSeq {
     // Poll the current promise in this state.
     auto r = s->current_promise();
     // If we are still pending, say so by returning.
-    if (absl::holds_alternative<Pending>(r)) {
-      return Pending();
-    }
+    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(absl::get<kPollReadyIdx>(std::move(r))),
-            RunNext<I>{this});
+        template CheckResultAndRunNext<Result>(std::move(r.value()),
+                                               RunNext<I>{this});
   }
 
   // Specialization of RunState to run the final state.
@@ -297,11 +292,9 @@ class BasicSeq {
     // Poll the final promise.
     auto r = final_promise_();
     // If we are still pending, say so by returning.
-    if (absl::holds_alternative<Pending>(r)) {
-      return Pending();
-    }
+    if (r.pending()) return Pending();
     // We are complete, return the (wrapped) result.
-    return Result(std::move(absl::get<kPollReadyIdx>(std::move(r))));
+    return Result(std::move(r.value()));
   }
 
   // For state numbered I, destruct the current promise and the next promise
@@ -403,20 +396,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));
@@ -465,9 +460,9 @@ class BasicSeqIter {
  private:
   Poll<Wrapped> PollNonEmpty() {
     Poll<Wrapped> r = state_();
-    if (absl::holds_alternative<Pending>(r)) return r;
-    return Traits<Wrapped>::template CheckResultAndRunNext<Wrapped>(
-        std::move(absl::get<Wrapped>(r)), [this](Wrapped arg) -> Poll<Wrapped> {
+    if (r.pending()) return r;
+    return Traits::template CheckResultAndRunNext<Wrapped>(
+        std::move(r.value()), [this](Wrapped arg) -> Poll<Wrapped> {
           auto next = cur_;
           ++next;
           if (next == end_) {
@@ -476,21 +471,21 @@ 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_;
   };
 };
 
 }  // namespace promise_detail
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_DETAIL_PROMISE_FACTORY_H
-#define GRPC_CORE_LIB_PROMISE_DETAIL_PROMISE_FACTORY_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_FACTORY_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_FACTORY_H
 
 #include <grpc/support/port_platform.h>
 
@@ -23,7 +23,6 @@
 #include "absl/meta/type_traits.h"
 
 #include "src/core/lib/promise/detail/promise_like.h"
-#include "src/core/lib/promise/poll.h"
 
 // PromiseFactory is an adaptor class.
 //
@@ -76,6 +75,20 @@ struct ResultOfT<F(Args...),
   using T = decltype(std::declval<RemoveCVRef<F>>()(std::declval<Args>()...));
 };
 
+template <typename F, typename... Args>
+struct ResultOfT<F(Args...)&,
+                 absl::void_t<decltype(std::declval<RemoveCVRef<F>>()(
+                     std::declval<Args>()...))>> {
+  using T = decltype(std::declval<RemoveCVRef<F>>()(std::declval<Args>()...));
+};
+
+template <typename F, typename... Args>
+struct ResultOfT<const F(Args...)&,
+                 absl::void_t<decltype(std::declval<RemoveCVRef<F>>()(
+                     std::declval<Args>()...))>> {
+  using T = decltype(std::declval<RemoveCVRef<F>>()(std::declval<Args>()...));
+};
+
 template <typename T>
 using ResultOf = typename ResultOfT<T>::T;
 
@@ -129,6 +142,14 @@ PromiseFactoryImpl(F&& f, A&& arg) {
   return f(std::forward<A>(arg));
 }
 
+// Given a callable(A) -> Promise<T>, name it a PromiseFactory and use it.
+template <typename A, typename F>
+absl::enable_if_t<IsVoidCallable<ResultOf<F(A)>>::value,
+                  PromiseLike<decltype(std::declval<F>()(std::declval<A>()))>>
+PromiseFactoryImpl(F& f, A&& arg) {
+  return f(std::forward<A>(arg));
+}
+
 // Given a callable() -> Promise<T>, promote it to a
 // PromiseFactory(A) -> Promise<T> by dropping the first argument.
 template <typename A, typename F>
@@ -147,7 +168,7 @@ PromiseFactoryImpl(F&& f) {
 };
 
 template <typename A, typename F>
-class PromiseFactory {
+class OncePromiseFactory {
  private:
   GPR_NO_UNIQUE_ADDRESS F f_;
 
@@ -156,34 +177,60 @@ class PromiseFactory {
   using Promise =
       decltype(PromiseFactoryImpl(std::move(f_), std::declval<A>()));
 
-  explicit PromiseFactory(F f) : f_(std::move(f)) {}
+  explicit OncePromiseFactory(F f) : f_(std::move(f)) {}
 
-  Promise Once(Arg&& a) {
+  Promise Make(Arg&& a) {
     return PromiseFactoryImpl(std::move(f_), std::forward<Arg>(a));
   }
+};
 
-  Promise Repeated(Arg&& a) const {
+template <typename F>
+class OncePromiseFactory<void, F> {
+ private:
+  GPR_NO_UNIQUE_ADDRESS F f_;
+
+ public:
+  using Arg = void;
+  using Promise = decltype(PromiseFactoryImpl(std::move(f_)));
+
+  explicit OncePromiseFactory(F f) : f_(std::move(f)) {}
+
+  Promise Make() { return PromiseFactoryImpl(std::move(f_)); }
+};
+
+template <typename A, typename F>
+class RepeatedPromiseFactory {
+ private:
+  GPR_NO_UNIQUE_ADDRESS F f_;
+
+ public:
+  using Arg = A;
+  using Promise = decltype(PromiseFactoryImpl(f_, std::declval<A>()));
+
+  explicit RepeatedPromiseFactory(F f) : f_(std::move(f)) {}
+
+  Promise Make(Arg&& a) const {
     return PromiseFactoryImpl(f_, std::forward<Arg>(a));
   }
+  Promise Make(Arg&& a) { return PromiseFactoryImpl(f_, std::forward<Arg>(a)); }
 };
 
 template <typename F>
-class PromiseFactory<void, F> {
+class RepeatedPromiseFactory<void, F> {
  private:
   GPR_NO_UNIQUE_ADDRESS F f_;
 
  public:
   using Arg = void;
-  using Promise = decltype(PromiseFactoryImpl(std::move(f_)));
-
-  explicit PromiseFactory(F f) : f_(std::move(f)) {}
+  using Promise = decltype(PromiseFactoryImpl(f_));
 
-  Promise Once() { return PromiseFactoryImpl(std::move(f_)); }
+  explicit RepeatedPromiseFactory(F f) : f_(std::move(f)) {}
 
-  Promise Repeated() const { return PromiseFactoryImpl(f_); }
+  Promise Make() const { return PromiseFactoryImpl(f_); }
+  Promise Make() { return PromiseFactoryImpl(f_); }
 };
 
 }  // namespace promise_detail
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_DETAIL_PROMISE_FACTORY_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_FACTORY_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_DETAIL_PROMISE_LIKE_H
-#define GRPC_CORE_LIB_PROMISE_DETAIL_PROMISE_LIKE_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_LIKE_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_LIKE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -82,4 +82,4 @@ using RemoveCVRef = absl::remove_cv_t<absl::remove_reference_t<T>>;
 }  // namespace promise_detail
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_DETAIL_PROMISE_LIKE_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_LIKE_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_DETAIL_STATUS_H
-#define GRPC_CORE_LIB_PROMISE_DETAIL_STATUS_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_STATUS_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_STATUS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -45,6 +45,34 @@ inline absl::Status IntoStatus(absl::Status* status) {
 // can participate in TrySeq as result types that affect control flow.
 inline bool IsStatusOk(const absl::Status& status) { return status.ok(); }
 
+template <typename To, typename From>
+struct StatusCastImpl;
+
+template <typename To>
+struct StatusCastImpl<To, To> {
+  static To Cast(To&& t) { return std::move(t); }
+};
+
+template <typename To>
+struct StatusCastImpl<To, const To&> {
+  static To Cast(const To& t) { return t; }
+};
+
+template <typename T>
+struct StatusCastImpl<absl::StatusOr<T>, absl::Status> {
+  static absl::StatusOr<T> Cast(absl::Status&& t) { return std::move(t); }
+};
+
+template <typename T>
+struct StatusCastImpl<absl::StatusOr<T>, const absl::Status&> {
+  static absl::StatusOr<T> Cast(const absl::Status& t) { return t; }
+};
+
+template <typename To, typename From>
+To StatusCast(From&& from) {
+  return StatusCastImpl<To, From>::Cast(std::forward<From>(from));
+}
+
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_DETAIL_STATUS_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_STATUS_H

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

@@ -1,25 +1,25 @@
-/*
- * Copyright 2021 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.
- */
+//
+// Copyright 2021 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.
+//
 
-/*
- * Automatically generated by tools/codegen/core/gen_switch.py
- */
+//
+// Automatically generated by tools/codegen/core/gen_switch.py
+//
 
-#ifndef GRPC_CORE_LIB_PROMISE_DETAIL_SWITCH_H
-#define GRPC_CORE_LIB_PROMISE_DETAIL_SWITCH_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_SWITCH_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_SWITCH_H
 
 #include <grpc/support/port_platform.h>
 
@@ -1452,4 +1452,4 @@ R Switch(char idx, F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7,
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_DETAIL_SWITCH_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_SWITCH_H