grpc 1.68.1 → 1.71.0

data/src/core/util/lru_cache.h

@@ -18,13 +18,13 @@
 #define GRPC_SRC_CORE_UTIL_LRU_CACHE_H
 
 #include <list>
+#include <optional>
 #include <tuple>
 #include <utility>
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
-#include "absl/types/optional.h"
 
 namespace grpc_core {
 
@@ -39,7 +39,7 @@ class LruCache {
   }
 
   // Returns the value for key, or nullopt if not present.
-  absl::optional<Value> Get(Key key);
+  std::optional<Value> Get(Key key);
 
   // If key is present in the cache, returns the corresponding value.
   // Otherwise, inserts a new entry in the map, calling create() to
@@ -72,9 +72,9 @@ class LruCache {
 //
 
 template <typename Key, typename Value>
-absl::optional<Value> LruCache<Key, Value>::Get(Key key) {
+std::optional<Value> LruCache<Key, Value>::Get(Key key) {
   auto it = cache_.find(key);
-  if (it == cache_.end()) return absl::nullopt;
+  if (it == cache_.end()) return std::nullopt;
   // Found the entry.  Move the entry to the end of the LRU list.
   auto new_lru_it = lru_list_.insert(lru_list_.end(), *it->second.lru_iterator);
   lru_list_.erase(it->second.lru_iterator);

data/src/core/util/match.h

@@ -18,8 +18,8 @@
 #include <grpc/support/port_platform.h>
 
 #include <utility>
+#include <variant>
 
-#include "absl/types/variant.h"
 #include "src/core/util/overload.h"
 
 namespace grpc_core {
@@ -47,9 +47,9 @@ struct MatchPointerExtractor {
 ///         [](int i) { puts("hoorah"); },
 ///         [](string s) { puts("boo"); });
 template <typename... Fs, typename T0, typename... Ts>
-auto Match(const absl::variant<T0, Ts...>& value, Fs... fs)
+auto Match(const std::variant<T0, Ts...>& value, Fs... fs)
     -> decltype(std::declval<OverloadType<Fs...>>()(std::declval<T0>())) {
-  return absl::visit(Overload(std::move(fs)...), value);
+  return std::visit(Overload(std::move(fs)...), value);
 }
 
 /// A version of Match that takes a mutable pointer to a variant and calls its
@@ -62,11 +62,11 @@ auto Match(const absl::variant<T0, Ts...>& value, Fs... fs)
 ///                [](string* s) { *s = "foo"; });
 ///   // v now contains 1.
 template <typename... Fs, typename T0, typename... Ts>
-auto MatchMutable(absl::variant<T0, Ts...>* value, Fs... fs)
+auto MatchMutable(std::variant<T0, Ts...>* value, Fs... fs)
     -> decltype(std::declval<OverloadType<Fs...>>()(std::declval<T0*>())) {
-  return absl::visit(detail::MatchPointerExtractor<Fs...>{OverloadType<Fs...>(
-                         std::move(fs)...)},
-                     *value);
+  return std::visit(detail::MatchPointerExtractor<Fs...>{OverloadType<Fs...>(
+                        std::move(fs)...)},
+                    *value);
 }
 
 }  // namespace grpc_core

data/src/core/util/matchers.cc

@@ -294,8 +294,7 @@ bool HeaderMatcher::operator==(const HeaderMatcher& other) const {
   }
 }
 
-bool HeaderMatcher::Match(
-    const absl::optional<absl::string_view>& value) const {
+bool HeaderMatcher::Match(const std::optional<absl::string_view>& value) const {
   bool match;
   if (type_ == Type::kPresent) {
     match = value.has_value() == present_match_;

data/src/core/util/matchers.h

@@ -19,11 +19,11 @@
 #include <stdint.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "re2/re2.h"
 
 namespace grpc_core {
@@ -91,20 +91,15 @@ class HeaderMatcher {
   // the corresponding StringMatcher::Type enum values, so that it's safe to
   // convert by casting when delegating to StringMatcher.
   static_assert(static_cast<StringMatcher::Type>(Type::kExact) ==
-                    StringMatcher::Type::kExact,
-                "");
+                StringMatcher::Type::kExact);
   static_assert(static_cast<StringMatcher::Type>(Type::kPrefix) ==
-                    StringMatcher::Type::kPrefix,
-                "");
+                StringMatcher::Type::kPrefix);
   static_assert(static_cast<StringMatcher::Type>(Type::kSuffix) ==
-                    StringMatcher::Type::kSuffix,
-                "");
+                StringMatcher::Type::kSuffix);
   static_assert(static_cast<StringMatcher::Type>(Type::kSafeRegex) ==
-                    StringMatcher::Type::kSafeRegex,
-                "");
+                StringMatcher::Type::kSafeRegex);
   static_assert(static_cast<StringMatcher::Type>(Type::kContains) ==
-                    StringMatcher::Type::kContains,
-                "");
+                StringMatcher::Type::kContains);
 
   // Creates HeaderMatcher instance. Returns error status on failure.
   static absl::StatusOr<HeaderMatcher> Create(absl::string_view name, Type type,
@@ -139,7 +134,7 @@ class HeaderMatcher {
   // Valid for kSafeRegex.
   RE2* regex_matcher() const { return matcher_.regex_matcher(); }
 
-  bool Match(const absl::optional<absl::string_view>& value) const;
+  bool Match(const std::optional<absl::string_view>& value) const;
 
   std::string ToString() const;
 

data/src/core/util/posix/env.cc

@@ -26,9 +26,9 @@
 
 namespace grpc_core {
 
-absl::optional<std::string> GetEnv(const char* name) {
+std::optional<std::string> GetEnv(const char* name) {
   char* result = getenv(name);
-  if (result == nullptr) return absl::nullopt;
+  if (result == nullptr) return std::nullopt;
   return result;
 }
 

data/src/core/util/posix/sync.cc

@@ -28,7 +28,6 @@
 #include <time.h>
 
 #include "absl/log/check.h"
-#include "src/core/util/crash.h"
 
 void gpr_mu_init(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED

data/src/core/util/posix/time.cc

@@ -32,7 +32,6 @@
 #include <grpc/support/time.h>
 
 #include "absl/log/check.h"
-#include "src/core/util/crash.h"
 
 static struct timespec timespec_from_gpr(gpr_timespec gts) {
   struct timespec rv;

data/src/core/util/ref_counted.h

@@ -284,6 +284,7 @@ template <typename Child, typename Impl = PolymorphicRefCount,
 class RefCounted : public Impl {
  public:
   using RefCountedChildType = Child;
+  using RefCountedUnrefBehaviorType = UnrefBehavior;
 
   // Not copyable nor movable.
   RefCounted(const RefCounted&) = delete;

data/src/core/util/ref_counted_ptr.h

@@ -20,8 +20,8 @@
 #define GRPC_SRC_CORE_UTIL_REF_COUNTED_PTR_H
 
 #include <grpc/support/port_platform.h>
-#include <stddef.h>
 
+#include <cstddef>
 #include <iosfwd>
 #include <type_traits>
 #include <utility>

data/src/core/util/ring_buffer.h

@@ -20,8 +20,7 @@
 #include <array>
 #include <cstddef>
 #include <iterator>
-
-#include "absl/types/optional.h"
+#include <optional>
 
 namespace grpc_core {
 
@@ -93,9 +92,9 @@ class RingBuffer {
   }
 
   // Returns the data of the first element in the buffer and removes it from
-  // the buffer. If the buffer is empty, returns absl::nullopt.
-  absl::optional<T> PopIfNotEmpty() {
-    if (!size_) return absl::nullopt;
+  // the buffer. If the buffer is empty, returns std::nullopt.
+  std::optional<T> PopIfNotEmpty() {
+    if (!size_) return std::nullopt;
     T data = std::move(data_[head_]);
     --size_;
     head_ = (head_ + 1) % kCapacity;

data/src/core/util/status_helper.cc

@@ -156,12 +156,11 @@ void StatusSetInt(absl::Status* status, StatusIntProperty key, intptr_t value) {
                      absl::Cord(std::to_string(value)));
 }
 
-absl::optional<intptr_t> StatusGetInt(const absl::Status& status,
-                                      StatusIntProperty key) {
-  absl::optional<absl::Cord> p =
-      status.GetPayload(GetStatusIntPropertyUrl(key));
+std::optional<intptr_t> StatusGetInt(const absl::Status& status,
+                                     StatusIntProperty key) {
+  auto p = status.GetPayload(GetStatusIntPropertyUrl(key));
   if (p.has_value()) {
-    absl::optional<absl::string_view> sv = p->TryFlat();
+    auto sv = p->TryFlat();
     intptr_t value;
     if (sv.has_value()) {
       if (absl::SimpleAtoi(*sv, &value)) {
@@ -181,10 +180,9 @@ void StatusSetStr(absl::Status* status, StatusStrProperty key,
   status->SetPayload(GetStatusStrPropertyUrl(key), absl::Cord(value));
 }
 
-absl::optional<std::string> StatusGetStr(const absl::Status& status,
-                                         StatusStrProperty key) {
-  absl::optional<absl::Cord> p =
-      status.GetPayload(GetStatusStrPropertyUrl(key));
+std::optional<std::string> StatusGetStr(const absl::Status& status,
+                                        StatusStrProperty key) {
+  auto p = status.GetPayload(GetStatusStrPropertyUrl(key));
   if (p.has_value()) {
     return std::string(*p);
   }
@@ -199,12 +197,11 @@ void StatusSetTime(absl::Status* status, StatusTimeProperty key,
                      absl::Cord(std::move(time_str)));
 }
 
-absl::optional<absl::Time> StatusGetTime(const absl::Status& status,
-                                         StatusTimeProperty key) {
-  absl::optional<absl::Cord> p =
-      status.GetPayload(GetStatusTimePropertyUrl(key));
+std::optional<absl::Time> StatusGetTime(const absl::Status& status,
+                                        StatusTimeProperty key) {
+  auto p = status.GetPayload(GetStatusTimePropertyUrl(key));
   if (p.has_value()) {
-    absl::optional<absl::string_view> sv = p->TryFlat();
+    auto sv = p->TryFlat();
     absl::Time time;
     if (sv.has_value()) {
       if (absl::ParseTime(absl::RFC3339_full, sv.value(), &time, nullptr)) {
@@ -227,8 +224,7 @@ void StatusAddChild(absl::Status* status, absl::Status child) {
   size_t buf_len = 0;
   char* buf = google_rpc_Status_serialize(msg, arena.ptr(), &buf_len);
   // Append (msg-length and msg) to children payload
-  absl::optional<absl::Cord> old_children =
-      status->GetPayload(kChildrenPropertyUrl);
+  auto old_children = status->GetPayload(kChildrenPropertyUrl);
   absl::Cord children;
   if (old_children.has_value()) {
     children = *old_children;
@@ -241,7 +237,7 @@ void StatusAddChild(absl::Status* status, absl::Status child) {
 }
 
 std::vector<absl::Status> StatusGetChildren(absl::Status status) {
-  absl::optional<absl::Cord> children = status.GetPayload(kChildrenPropertyUrl);
+  auto children = status.GetPayload(kChildrenPropertyUrl);
   return children.has_value() ? ParseChildren(*children)
                               : std::vector<absl::Status>();
 }
@@ -256,7 +252,7 @@ std::string StatusToString(const absl::Status& status) {
     absl::StrAppend(&head, ":", status.message());
   }
   std::vector<std::string> kvs;
-  absl::optional<absl::Cord> children;
+  std::optional<absl::Cord> children;
   status.ForEachPayload([&](absl::string_view type_url,
                             const absl::Cord& payload) {
     if (absl::StartsWith(type_url, kTypeUrlPrefix)) {
@@ -295,7 +291,7 @@ std::string StatusToString(const absl::Status& status) {
                                    absl::CHexEscape(payload_view), "\""));
       }
     } else {
-      absl::optional<absl::string_view> payload_view = payload.TryFlat();
+      auto payload_view = payload.TryFlat();
       std::string payload_str = absl::CHexEscape(
           payload_view.has_value() ? *payload_view : std::string(payload));
       kvs.push_back(absl::StrCat(type_url, ":\"", payload_str, "\""));
@@ -318,7 +314,7 @@ std::string StatusToString(const absl::Status& status) {
 absl::Status AddMessagePrefix(absl::string_view prefix, absl::Status status) {
   absl::Status new_status(status.code(),
                           absl::StrCat(prefix, ": ", status.message()));
-  // TODO(roth): Remove this once we elimiate all status attributes.
+  // TODO(roth): Remove this once we eliminate all status attributes.
   status.ForEachPayload(
       [&](absl::string_view type_url, const absl::Cord& payload) {
         new_status.SetPayload(type_url, payload);
@@ -354,7 +350,7 @@ google_rpc_Status* StatusToProto(const absl::Status& status, upb_Arena* arena) {
     memcpy(type_url_buf, type_url.data(), type_url.size());
     google_protobuf_Any_set_type_url(
         any, upb_StringView_FromDataAndSize(type_url_buf, type_url.size()));
-    absl::optional<absl::string_view> v_view = payload.TryFlat();
+    auto v_view = payload.TryFlat();
     if (v_view.has_value()) {
       google_protobuf_Any_set_value(
           any, upb_StringView_FromDataAndSize(v_view->data(), v_view->size()));

data/src/core/util/status_helper.h

@@ -22,13 +22,13 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
-#include "absl/types/optional.h"
 #include "src/core/util/debug_location.h"
 
 extern "C" {
@@ -92,15 +92,15 @@ void StatusSetInt(absl::Status* status, StatusIntProperty key, intptr_t value);
 
 /// Gets the int property from the status
 GRPC_MUST_USE_RESULT
-absl::optional<intptr_t> StatusGetInt(const absl::Status& status,
-                                      StatusIntProperty key);
+std::optional<intptr_t> StatusGetInt(const absl::Status& status,
+                                     StatusIntProperty key);
 
 /// Sets the str property to the status
 void StatusSetStr(absl::Status* status, StatusStrProperty key,
                   absl::string_view value);
 
 /// Gets the str property from the status
-GRPC_MUST_USE_RESULT absl::optional<std::string> StatusGetStr(
+GRPC_MUST_USE_RESULT std::optional<std::string> StatusGetStr(
     const absl::Status& status, StatusStrProperty key);
 
 /// Sets the time property to the status
@@ -108,7 +108,7 @@ void StatusSetTime(absl::Status* status, StatusTimeProperty key,
                    absl::Time time);
 
 /// Gets the time property from the status
-GRPC_MUST_USE_RESULT absl::optional<absl::Time> StatusGetTime(
+GRPC_MUST_USE_RESULT std::optional<absl::Time> StatusGetTime(
     const absl::Status& status, StatusTimeProperty key);
 
 /// Adds a child status to status

data/src/core/util/string.cc

@@ -183,7 +183,7 @@ int gpr_ltoa(long value, char* output) {
 
   sign = value < 0 ? -1 : 1;
   while (value) {
-    output[i++] = static_cast<char>('0' + sign * (value % 10));
+    output[i++] = static_cast<char>('0' + (sign * (value % 10)));
     value /= 10;
   }
   if (sign < 0) output[i++] = '-';
@@ -204,7 +204,7 @@ int int64_ttoa(int64_t value, char* output) {
 
   sign = value < 0 ? -1 : 1;
   while (value) {
-    output[i++] = static_cast<char>('0' + sign * (value % 10));
+    output[i++] = static_cast<char>('0' + (sign * (value % 10)));
     value /= 10;
   }
   if (sign < 0) output[i++] = '-';

data/src/core/util/sync_abseil.cc

@@ -30,7 +30,6 @@
 #include "absl/synchronization/mutex.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
-#include "src/core/util/crash.h"
 #include "src/core/util/time_util.h"
 
 void gpr_mu_init(gpr_mu* mu) {

data/src/core/util/table.h

@@ -155,19 +155,6 @@ void DestructIfNotNull(T* p) {
   if (p) p->~T();
 }
 
-// Helper function... just ignore the initializer list passed into it.
-// Allows doing 'statements' via parameter pack expansion in C++11 - given
-// template <typename... Ts>:
-//  do_these_things({(foo<Ts>(), 1)});
-// will execute foo<T>() for each T in Ts.
-// In this example we also leverage the comma operator to make the resultant
-// type of each statement be a consistant int so that C++ type deduction works
-// as we'd like (note that in the expression (a, 1) in C++, the 'result' of the
-// expression is the value after the right-most ',' -- in this case 1, with a
-// executed as a side effect.
-template <typename T>
-void do_these_things(std::initializer_list<T>) {}
-
 }  // namespace table_detail
 
 // A Table<Ts> is much like a tuple<optional<Ts>...> - a set of values that are
@@ -438,41 +425,39 @@ class Table {
   // destructor.
   template <size_t... I>
   void Destruct(absl::index_sequence<I...>) {
-    table_detail::do_these_things<int>(
-        {(table_detail::DestructIfNotNull(get<I>()), 1)...});
+    (table_detail::DestructIfNotNull(get<I>()), ...);
   }
 
   // For each field (element I=0, 1, ...) copy that field into this table -
   // or_clear as per CopyIf().
   template <bool or_clear, size_t... I>
   void Copy(absl::index_sequence<I...>, const Table& rhs) {
-    table_detail::do_these_things<int>({(CopyIf<or_clear, I>(rhs), 1)...});
+    (CopyIf<or_clear, I>(rhs), ...);
   }
 
   // For each field (element I=0, 1, ...) move that field into this table -
   // or_clear as per MoveIf().
   template <bool or_clear, size_t... I>
   void Move(absl::index_sequence<I...>, Table&& rhs) {
-    table_detail::do_these_things<int>(
-        {(MoveIf<or_clear, I>(std::forward<Table>(rhs)), 1)...});
+    (MoveIf<or_clear, I>(std::forward<Table>(rhs)), ...);
   }
 
   // For each field (element I=0, 1, ...) if that field is present, call f.
   template <typename F, size_t... I>
   void ForEachImpl(F f, absl::index_sequence<I...>) const {
-    table_detail::do_these_things<int>({(CallIf<I>(&f), 1)...});
+    (CallIf<I>(&f), ...);
   }
 
   // For each field (element I=0, 1, ...) if that field is present, call f. If
   // f returns false, remove the field from the table.
   template <typename F, size_t... I>
   void FilterInImpl(F f, absl::index_sequence<I...>) {
-    table_detail::do_these_things<int>({(FilterIf<I>(&f), 1)...});
+    (FilterIf<I>(&f), ...);
   }
 
   template <size_t... I>
   void ClearAllImpl(absl::index_sequence<I...>) {
-    table_detail::do_these_things<int>({(clear<I>(), 1)...});
+    (clear<I>(), ...);
   }
 
   // Bit field indicating which elements are set.

data/src/core/util/time.cc

@@ -84,7 +84,7 @@ GPR_ATTRIBUTE_NOINLINE std::pair<int64_t, gpr_cycle_counter> InitTime() {
     g_process_epoch_cycles.store(process_epoch_cycles,
                                  std::memory_order_relaxed);
   }
-  return std::make_pair(process_epoch_seconds, process_epoch_cycles);
+  return std::pair(process_epoch_seconds, process_epoch_cycles);
 }
 
 gpr_timespec StartTime() {
@@ -120,9 +120,9 @@ gpr_timespec MillisecondsAsTimespec(int64_t millis, gpr_clock_type clock_type) {
 int64_t TimespanToMillisRoundUp(gpr_timespec ts) {
   CHECK(ts.clock_type == GPR_TIMESPAN);
   double x = GPR_MS_PER_SEC * static_cast<double>(ts.tv_sec) +
-             static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS +
-             static_cast<double>(GPR_NS_PER_SEC - 1) /
-                 static_cast<double>(GPR_NS_PER_SEC);
+             (static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS) +
+             (static_cast<double>(GPR_NS_PER_SEC - 1) /
+              static_cast<double>(GPR_NS_PER_SEC));
   if (x <= static_cast<double>(std::numeric_limits<int64_t>::min())) {
     return std::numeric_limits<int64_t>::min();
   }
@@ -135,7 +135,7 @@ int64_t TimespanToMillisRoundUp(gpr_timespec ts) {
 int64_t TimespanToMillisRoundDown(gpr_timespec ts) {
   CHECK(ts.clock_type == GPR_TIMESPAN);
   double x = GPR_MS_PER_SEC * static_cast<double>(ts.tv_sec) +
-             static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS;
+             (static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS);
   if (x <= static_cast<double>(std::numeric_limits<int64_t>::min())) {
     return std::numeric_limits<int64_t>::min();
   }

data/src/core/util/time.h

@@ -21,10 +21,10 @@
 #include <stdint.h>
 
 #include <limits>
+#include <optional>
 #include <ostream>
 #include <string>
 
-#include "absl/types/optional.h"
 #include "src/core/util/time_precise.h"
 #include "src/core/util/useful.h"
 
@@ -171,13 +171,13 @@ class ScopedTimeCache final : public Timestamp::ScopedSource {
   Timestamp Now() override;
 
   void InvalidateCache() override {
-    cached_time_ = absl::nullopt;
+    cached_time_ = std::nullopt;
     Timestamp::ScopedSource::InvalidateCache();
   }
   void TestOnlySetNow(Timestamp now) { cached_time_ = now; }
 
  private:
-  absl::optional<Timestamp> cached_time_;
+  std::optional<Timestamp> cached_time_;
 };
 
 // Duration represents a span of time.
@@ -227,11 +227,11 @@ class Duration {
   }
 
   static constexpr Duration MicrosecondsRoundUp(int64_t micros) {
-    return Duration(micros / GPR_US_PER_MS + (micros % GPR_US_PER_MS != 0));
+    return Duration((micros / GPR_US_PER_MS) + (micros % GPR_US_PER_MS != 0));
   }
 
   static constexpr Duration NanosecondsRoundUp(int64_t nanos) {
-    return Duration(nanos / GPR_NS_PER_MS + (nanos % GPR_NS_PER_MS != 0));
+    return Duration((nanos / GPR_NS_PER_MS) + (nanos % GPR_NS_PER_MS != 0));
   }
 
   constexpr bool operator==(Duration other) const {

data/src/core/util/time_precise.cc

@@ -28,7 +28,6 @@
 #include <algorithm>
 
 #include "absl/log/log.h"
-#include "src/core/util/crash.h"
 #include "src/core/util/time_precise.h"
 
 #ifndef GPR_CYCLE_COUNTER_CUSTOM

data/src/core/util/type_list.h

@@ -25,8 +25,64 @@ struct Typelist {
 
   template <typename C>
   using PushFront = Typelist<C, A...>;
+
+  template <typename C>
+  using PushBack = Typelist<A..., C>;
+};
+
+namespace typelist_detail {
+template <typename T>
+struct ReverseTpl;
+
+template <typename A>
+struct ReverseTpl<Typelist<A>> {
+  using Result = Typelist<A>;
 };
 
+template <typename A, typename... Rest>
+struct ReverseTpl<Typelist<A, Rest...>> {
+  using Result =
+      typename ReverseTpl<Typelist<Rest...>>::Result::template PushBack<A>;
+};
+}  // namespace typelist_detail
+
+template <typename... A>
+using Reverse = typename typelist_detail::ReverseTpl<Typelist<A...>>::Result;
+
+// A compile time list of values
+template <auto... A>
+struct Valuelist {
+  template <template <auto...> class T>
+  using Instantiate = T<A...>;
+
+  template <auto C>
+  using PushFront = Valuelist<C, A...>;
+
+  template <auto C>
+  using PushBack = Valuelist<A..., C>;
+};
+
+namespace valuelist_detail {
+template <typename T>
+struct ReverseTpl;
+
+template <auto A>
+struct ReverseTpl<Valuelist<A>> {
+  using Result = Valuelist<A>;
+};
+
+template <auto A, auto... Rest>
+struct ReverseTpl<Valuelist<A, Rest...>> {
+  using Result =
+      typename ReverseTpl<Valuelist<Rest...>>::Result::template PushBack<A>;
+};
+
+}  // namespace valuelist_detail
+
+template <auto... A>
+using ReverseValues =
+    typename valuelist_detail::ReverseTpl<Valuelist<A...>>::Result;
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_UTIL_TYPE_LIST_H

data/src/core/util/uri.cc

@@ -261,9 +261,9 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
     for (absl::string_view query_param : absl::StrSplit(tmp_query, '&')) {
       const std::pair<absl::string_view, absl::string_view> possible_kv =
           absl::StrSplit(query_param, absl::MaxSplits('=', 1));
-      if (possible_kv.first.empty()) continue;
-      query_param_pairs.push_back({PercentDecode(possible_kv.first),
-                                   PercentDecode(possible_kv.second)});
+      auto& [key, value] = possible_kv;
+      if (key.empty()) continue;
+      query_param_pairs.push_back({PercentDecode(key), PercentDecode(value)});
     }
     if (offset == remaining.npos) {
       remaining = "";
@@ -348,10 +348,22 @@ struct QueryParameterFormatter {
 
 std::string URI::ToString() const {
   std::vector<std::string> parts = {PercentEncode(scheme_, IsSchemeChar), ":"};
-  if (!authority_.empty()) {
+  // If path starts with '//' we need to encode the authority to ensure that
+  // we can round-trip the URI through a parse/encode/parse loop.
+  if (!authority_.empty() || absl::StartsWith(path_, "//")) {
     parts.emplace_back("//");
     parts.emplace_back(PercentEncode(authority_, IsAuthorityChar));
   }
+  parts.emplace_back(EncodedPathAndQueryParams());
+  if (!fragment_.empty()) {
+    parts.push_back("#");
+    parts.push_back(PercentEncode(fragment_, IsQueryOrFragmentChar));
+  }
+  return absl::StrJoin(parts, "");
+}
+
+std::string URI::EncodedPathAndQueryParams() const {
+  std::vector<std::string> parts;
   if (!path_.empty()) {
     parts.emplace_back(PercentEncode(path_, IsPathChar));
   }
@@ -360,10 +372,6 @@ std::string URI::ToString() const {
     parts.push_back(
         absl::StrJoin(query_parameter_pairs_, "&", QueryParameterFormatter()));
   }
-  if (!fragment_.empty()) {
-    parts.push_back("#");
-    parts.push_back(PercentEncode(fragment_, IsQueryOrFragmentChar));
-  }
   return absl::StrJoin(parts, "");
 }