grpc 1.71.0 → 1.74.0

data/third_party/abseil-cpp/absl/strings/str_replace.cc

@@ -37,8 +37,8 @@ using FixedMapping =
 // occurred.
 int ApplySubstitutions(
     absl::string_view s,
-    absl::Nonnull<std::vector<strings_internal::ViableSubstitution>*> subs_ptr,
-    absl::Nonnull<std::string*> result_ptr) {
+    std::vector<strings_internal::ViableSubstitution>* absl_nonnull subs_ptr,
+    std::string* absl_nonnull result_ptr) {
   auto& subs = *subs_ptr;
   int substitutions = 0;
   size_t pos = 0;
@@ -83,7 +83,7 @@ std::string StrReplaceAll(absl::string_view s,
 }
 
 int StrReplaceAll(strings_internal::FixedMapping replacements,
-                  absl::Nonnull<std::string*> target) {
+                  std::string* absl_nonnull target) {
   return StrReplaceAll<strings_internal::FixedMapping>(replacements, target);
 }
 

data/third_party/abseil-cpp/absl/strings/str_replace.h

@@ -66,7 +66,7 @@ ABSL_NAMESPACE_BEGIN
 //        {"$who", "Bob"},
 //        {"#Noun", "Apples"}});
 //   EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
-ABSL_MUST_USE_RESULT std::string StrReplaceAll(
+[[nodiscard]] std::string StrReplaceAll(
     absl::string_view s,
     std::initializer_list<std::pair<absl::string_view, absl::string_view>>
         replacements);
@@ -114,7 +114,7 @@ std::string StrReplaceAll(absl::string_view s,
 int StrReplaceAll(
     std::initializer_list<std::pair<absl::string_view, absl::string_view>>
         replacements,
-    absl::Nonnull<std::string*> target);
+    std::string* absl_nonnull target);
 
 // Overload of `StrReplaceAll()` to replace patterns within a given output
 // string *in place* with replacements provided within a container of key/value
@@ -130,7 +130,7 @@ int StrReplaceAll(
 //  EXPECT_EQ("if (ptr &lt; &amp;foo)", s);
 template <typename StrToStrMapping>
 int StrReplaceAll(const StrToStrMapping& replacements,
-                  absl::Nonnull<std::string*> target);
+                  std::string* absl_nonnull target);
 
 // Implementation details only, past this point.
 namespace strings_internal {
@@ -187,8 +187,8 @@ std::vector<ViableSubstitution> FindSubstitutions(
 }
 
 int ApplySubstitutions(absl::string_view s,
-                       absl::Nonnull<std::vector<ViableSubstitution>*> subs_ptr,
-                       absl::Nonnull<std::string*> result_ptr);
+                       std::vector<ViableSubstitution>* absl_nonnull subs_ptr,
+                       std::string* absl_nonnull result_ptr);
 
 }  // namespace strings_internal
 
@@ -204,7 +204,7 @@ std::string StrReplaceAll(absl::string_view s,
 
 template <typename StrToStrMapping>
 int StrReplaceAll(const StrToStrMapping& replacements,
-                  absl::Nonnull<std::string*> target) {
+                  std::string* absl_nonnull target) {
   auto subs = strings_internal::FindSubstitutions(*target, replacements);
   if (subs.empty()) return 0;
 

data/third_party/abseil-cpp/absl/strings/str_split.h

@@ -444,8 +444,10 @@ using EnableSplitIfString =
 // behavior works for:
 //
 // 1) All standard STL containers including `std::vector`, `std::list`,
-//    `std::deque`, `std::set`,`std::multiset`, 'std::map`, and `std::multimap`
+//    `std::deque`, `std::set`,`std::multiset`, 'std::map`, and `std::multimap`.
 // 2) `std::pair` (which is not actually a container). See below.
+// 3) `std::array`, which is a container but has different behavior due to its
+//    fixed size. See below.
 //
 // Example:
 //
@@ -487,6 +489,21 @@ using EnableSplitIfString =
 //   std::pair<std::string, std::string> p = absl::StrSplit("a,b,c", ',');
 //   // p.first == "a", p.second == "b"       // "c" is omitted.
 //
+//
+// Splitting to `std::array` is similar to splitting to `std::pair`, but for
+// N elements instead of two; missing elements are filled with the empty string
+// and extra elements are discarded.
+//
+// Examples:
+//
+//   // Stores first two split strings as the elements in a std::array.
+//   std::array<std::string, 2> a = absl::StrSplit("a,b,c", ',');
+//   // a[0] == "a", a[1] == "b"   // "c" is omitted.
+//
+//   // The second element is empty.
+//   std::array<std::string, 2> a = absl::StrSplit("a,", ',');
+//   // a[0] == "a", a[1] == ""
+//
 // The `StrSplit()` function can be used multiple times to perform more
 // complicated splitting logic, such as intelligently parsing key-value pairs.
 //

data/third_party/abseil-cpp/absl/strings/string_view.cc

@@ -30,10 +30,10 @@ namespace {
 
 // This is significantly faster for case-sensitive matches with very
 // few possible matches.
-absl::Nullable<const char*> memmatch(absl::Nullable<const char*> phaystack,
-                                     size_t haylen,
-                                     absl::Nullable<const char*> pneedle,
-                                     size_t neelen) {
+const char* absl_nullable memmatch(const char* absl_nullable phaystack,
+                                   size_t haylen,
+                                   const char* absl_nullable pneedle,
+                                   size_t neelen) {
   if (0 == neelen) {
     return phaystack;  // even if haylen is 0
   }
@@ -233,11 +233,6 @@ string_view::size_type string_view::find_last_not_of(
   return npos;
 }
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr string_view::size_type string_view::npos;
-constexpr string_view::size_type string_view::kMaxSize;
-#endif
-
 ABSL_NAMESPACE_END
 }  // namespace absl
 

data/third_party/abseil-cpp/absl/strings/string_view.h

@@ -159,15 +159,15 @@ ABSL_NAMESPACE_BEGIN
 //
 //   absl::string_view() == absl::string_view("", 0)
 //   absl::string_view(nullptr, 0) == absl::string_view("abcdef"+6, 0)
-class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
+class ABSL_ATTRIBUTE_VIEW string_view {
  public:
   using traits_type = std::char_traits<char>;
   using value_type = char;
-  using pointer = absl::Nullable<char*>;
-  using const_pointer = absl::Nullable<const char*>;
+  using pointer = char* absl_nullable;
+  using const_pointer = const char* absl_nullable;
   using reference = char&;
   using const_reference = const char&;
-  using const_iterator = absl::Nullable<const char*>;
+  using const_iterator = const char* absl_nullable;
   using iterator = const_iterator;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
   using reverse_iterator = const_reverse_iterator;
@@ -197,16 +197,15 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
   // instead (see below).
   // The length check is skipped since it is unnecessary and causes code bloat.
   constexpr string_view(  // NOLINT(runtime/explicit)
-      absl::Nonnull<const char*> str)
+      const char* absl_nonnull str)
       : ptr_(str), length_(str ? StrlenInternal(str) : 0) {}
 
-  // Implicit constructor of a `string_view` from a `const char*` and length.
-  constexpr string_view(absl::Nullable<const char*> data, size_type len)
+  // Constructor of a `string_view` from a `const char*` and length.
+  constexpr string_view(const char* absl_nullable data, size_type len)
       : ptr_(data), length_(CheckLengthInternal(len)) {}
 
-  // NOTE: Harmlessly omitted to work around gdb bug.
-  //   constexpr string_view(const string_view&) noexcept = default;
-  //   string_view& operator=(const string_view&) noexcept = default;
+  constexpr string_view(const string_view&) noexcept = default;
+  string_view& operator=(const string_view&) noexcept = default;
 
   // Iterators
 
@@ -293,7 +292,8 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
   // Returns the ith element of the `string_view` using the array operator.
   // Note that this operator does not perform any bounds checking.
   constexpr const_reference operator[](size_type i) const {
-    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
+    ABSL_HARDENING_ASSERT(i < size());
+    return ptr_[i];
   }
 
   // string_view::at()
@@ -302,25 +302,26 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
   // and an exception of type `std::out_of_range` will be thrown on invalid
   // access.
   constexpr const_reference at(size_type i) const {
-    return ABSL_PREDICT_TRUE(i < size())
-               ? ptr_[i]
-               : ((void)base_internal::ThrowStdOutOfRange(
-                      "absl::string_view::at"),
-                  ptr_[i]);
+    if (ABSL_PREDICT_FALSE(i >= size())) {
+      base_internal::ThrowStdOutOfRange("absl::string_view::at");
+    }
+    return ptr_[i];
   }
 
   // string_view::front()
   //
   // Returns the first element of a `string_view`.
   constexpr const_reference front() const {
-    return ABSL_HARDENING_ASSERT(!empty()), ptr_[0];
+    ABSL_HARDENING_ASSERT(!empty());
+    return ptr_[0];
   }
 
   // string_view::back()
   //
   // Returns the last element of a `string_view`.
   constexpr const_reference back() const {
-    return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1];
+    ABSL_HARDENING_ASSERT(!empty());
+    return ptr_[size() - 1];
   }
 
   // string_view::data()
@@ -394,11 +395,10 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
   // `pos > size`.
   // Use absl::ClippedSubstr if you need a truncating substr operation.
   constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
-    return ABSL_PREDICT_FALSE(pos > length_)
-               ? (base_internal::ThrowStdOutOfRange(
-                      "absl::string_view::substr"),
-                  string_view())
-               : string_view(ptr_ + pos, Min(n, length_ - pos));
+    if (ABSL_PREDICT_FALSE(pos > length_)) {
+      base_internal::ThrowStdOutOfRange("absl::string_view::substr");
+    }
+    return string_view(ptr_ + pos, (std::min)(n, length_ - pos));
   }
 
   // string_view::compare()
@@ -409,10 +409,10 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
   // is greater than `x`.
   constexpr int compare(string_view x) const noexcept {
     return CompareImpl(length_, x.length_,
-                       Min(length_, x.length_) == 0
+                       (std::min)(length_, x.length_) == 0
                            ? 0
                            : ABSL_INTERNAL_STRING_VIEW_MEMCMP(
-                                 ptr_, x.ptr_, Min(length_, x.length_)));
+                                 ptr_, x.ptr_, (std::min)(length_, x.length_)));
   }
 
   // Overload of `string_view::compare()` for comparing a substring of the
@@ -430,21 +430,21 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
 
   // Overload of `string_view::compare()` for comparing a `string_view` and a
   // a different C-style string `s`.
-  constexpr int compare(absl::Nonnull<const char*> s) const {
+  constexpr int compare(const char* absl_nonnull s) const {
     return compare(string_view(s));
   }
 
   // Overload of `string_view::compare()` for comparing a substring of the
   // `string_view` and a different string C-style string `s`.
   constexpr int compare(size_type pos1, size_type count1,
-                        absl::Nonnull<const char*> s) const {
+                        const char* absl_nonnull s) const {
     return substr(pos1, count1).compare(string_view(s));
   }
 
   // Overload of `string_view::compare()` for comparing a substring of the
   // `string_view` and a substring of a different C-style string `s`.
   constexpr int compare(size_type pos1, size_type count1,
-                        absl::Nonnull<const char*> s, size_type count2) const {
+                        const char* absl_nonnull s, size_type count2) const {
     return substr(pos1, count1).compare(string_view(s, count2));
   }
 
@@ -463,14 +463,14 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
 
   // Overload of `string_view::find()` for finding a substring of a different
   // C-style string `s` within the `string_view`.
-  size_type find(absl::Nonnull<const char*> s, size_type pos,
+  size_type find(const char* absl_nonnull s, size_type pos,
                  size_type count) const {
     return find(string_view(s, count), pos);
   }
 
   // Overload of `string_view::find()` for finding a different C-style string
   // `s` within the `string_view`.
-  size_type find(absl::Nonnull<const char *> s, size_type pos = 0) const {
+  size_type find(const char* absl_nonnull s, size_type pos = 0) const {
     return find(string_view(s), pos);
   }
 
@@ -487,14 +487,14 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
 
   // Overload of `string_view::rfind()` for finding a substring of a different
   // C-style string `s` within the `string_view`.
-  size_type rfind(absl::Nonnull<const char*> s, size_type pos,
+  size_type rfind(const char* absl_nonnull s, size_type pos,
                   size_type count) const {
     return rfind(string_view(s, count), pos);
   }
 
   // Overload of `string_view::rfind()` for finding a different C-style string
   // `s` within the `string_view`.
-  size_type rfind(absl::Nonnull<const char*> s, size_type pos = npos) const {
+  size_type rfind(const char* absl_nonnull s, size_type pos = npos) const {
     return rfind(string_view(s), pos);
   }
 
@@ -513,15 +513,14 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
 
   // Overload of `string_view::find_first_of()` for finding a substring of a
   // different C-style string `s` within the `string_view`.
-  size_type find_first_of(absl::Nonnull<const char*> s, size_type pos,
+  size_type find_first_of(const char* absl_nonnull s, size_type pos,
                           size_type count) const {
     return find_first_of(string_view(s, count), pos);
   }
 
   // Overload of `string_view::find_first_of()` for finding a different C-style
   // string `s` within the `string_view`.
-  size_type find_first_of(absl::Nonnull<const char*> s,
-                          size_type pos = 0) const {
+  size_type find_first_of(const char* absl_nonnull s, size_type pos = 0) const {
     return find_first_of(string_view(s), pos);
   }
 
@@ -540,14 +539,14 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
 
   // Overload of `string_view::find_last_of()` for finding a substring of a
   // different C-style string `s` within the `string_view`.
-  size_type find_last_of(absl::Nonnull<const char*> s, size_type pos,
+  size_type find_last_of(const char* absl_nonnull s, size_type pos,
                          size_type count) const {
     return find_last_of(string_view(s, count), pos);
   }
 
   // Overload of `string_view::find_last_of()` for finding a different C-style
   // string `s` within the `string_view`.
-  size_type find_last_of(absl::Nonnull<const char*> s,
+  size_type find_last_of(const char* absl_nonnull s,
                          size_type pos = npos) const {
     return find_last_of(string_view(s), pos);
   }
@@ -565,14 +564,14 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
 
   // Overload of `string_view::find_first_not_of()` for finding a substring of a
   // different C-style string `s` within the `string_view`.
-  size_type find_first_not_of(absl::Nonnull<const char*> s, size_type pos,
+  size_type find_first_not_of(const char* absl_nonnull s, size_type pos,
                               size_type count) const {
     return find_first_not_of(string_view(s, count), pos);
   }
 
   // Overload of `string_view::find_first_not_of()` for finding a different
   // C-style string `s` within the `string_view`.
-  size_type find_first_not_of(absl::Nonnull<const char*> s,
+  size_type find_first_not_of(const char* absl_nonnull s,
                               size_type pos = 0) const {
     return find_first_not_of(string_view(s), pos);
   }
@@ -591,14 +590,14 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
 
   // Overload of `string_view::find_last_not_of()` for finding a substring of a
   // different C-style string `s` within the `string_view`.
-  size_type find_last_not_of(absl::Nonnull<const char*> s, size_type pos,
+  size_type find_last_not_of(const char* absl_nonnull s, size_type pos,
                              size_type count) const {
     return find_last_not_of(string_view(s, count), pos);
   }
 
   // Overload of `string_view::find_last_not_of()` for finding a different
   // C-style string `s` within the `string_view`.
-  size_type find_last_not_of(absl::Nonnull<const char*> s,
+  size_type find_last_not_of(const char* absl_nonnull s,
                              size_type pos = npos) const {
     return find_last_not_of(string_view(s), pos);
   }
@@ -659,7 +658,7 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
   // The constructor from std::string delegates to this constructor.
   // See the comment on that constructor for the rationale.
   struct SkipCheckLengthTag {};
-  string_view(absl::Nullable<const char*> data, size_type len,
+  string_view(const char* absl_nullable data, size_type len,
               SkipCheckLengthTag) noexcept
       : ptr_(data), length_(len) {}
 
@@ -667,10 +666,11 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
       (std::numeric_limits<difference_type>::max)();
 
   static constexpr size_type CheckLengthInternal(size_type len) {
-    return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
+    ABSL_HARDENING_ASSERT(len <= kMaxSize);
+    return len;
   }
 
-  static constexpr size_type StrlenInternal(absl::Nonnull<const char*> str) {
+  static constexpr size_type StrlenInternal(const char* absl_nonnull str) {
 #if defined(_MSC_VER) && !defined(__clang__)
     // MSVC 2017+ can evaluate this at compile-time.
     const char* begin = str;
@@ -688,10 +688,6 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
 #endif
   }
 
-  static constexpr size_t Min(size_type length_a, size_type length_b) {
-    return length_a < length_b ? length_a : length_b;
-  }
-
   static constexpr int CompareImpl(size_type length_a, size_type length_b,
                                    int compare_result) {
     return compare_result == 0 ? static_cast<int>(length_a > length_b) -
@@ -699,7 +695,7 @@ class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
                                : (compare_result < 0 ? -1 : 1);
   }
 
-  absl::Nullable<const char*> ptr_;
+  const char* absl_nullable ptr_;
   size_type length_;
 };
 
@@ -760,7 +756,7 @@ inline string_view ClippedSubstr(string_view s, size_t pos,
 // Creates an `absl::string_view` from a pointer `p` even if it's null-valued.
 // This function should be used where an `absl::string_view` can be created from
 // a possibly-null pointer.
-constexpr string_view NullSafeStringView(absl::Nullable<const char*> p) {
+constexpr string_view NullSafeStringView(const char* absl_nullable p) {
   return p ? string_view(p) : string_view();
 }
 

data/third_party/abseil-cpp/absl/strings/strip.h

@@ -24,6 +24,7 @@
 #include <cstddef>
 #include <string>
 
+#include "absl/base/attributes.h"
 #include "absl/base/macros.h"
 #include "absl/base/nullability.h"
 #include "absl/strings/ascii.h"
@@ -44,8 +45,8 @@ ABSL_NAMESPACE_BEGIN
 //   absl::string_view input("abc");
 //   EXPECT_TRUE(absl::ConsumePrefix(&input, "a"));
 //   EXPECT_EQ(input, "bc");
-inline bool ConsumePrefix(absl::Nonnull<absl::string_view*> str,
-                          absl::string_view expected) {
+inline constexpr bool ConsumePrefix(absl::string_view* absl_nonnull str,
+                                    absl::string_view expected) {
   if (!absl::StartsWith(*str, expected)) return false;
   str->remove_prefix(expected.size());
   return true;
@@ -61,8 +62,8 @@ inline bool ConsumePrefix(absl::Nonnull<absl::string_view*> str,
 //   absl::string_view input("abcdef");
 //   EXPECT_TRUE(absl::ConsumeSuffix(&input, "def"));
 //   EXPECT_EQ(input, "abc");
-inline bool ConsumeSuffix(absl::Nonnull<absl::string_view*> str,
-                          absl::string_view expected) {
+inline constexpr bool ConsumeSuffix(absl::string_view* absl_nonnull str,
+                                    absl::string_view expected) {
   if (!absl::EndsWith(*str, expected)) return false;
   str->remove_suffix(expected.size());
   return true;
@@ -73,8 +74,9 @@ inline bool ConsumeSuffix(absl::Nonnull<absl::string_view*> str,
 // Returns a view into the input string `str` with the given `prefix` removed,
 // but leaving the original string intact. If the prefix does not match at the
 // start of the string, returns the original string instead.
-ABSL_MUST_USE_RESULT inline absl::string_view StripPrefix(
-    absl::string_view str, absl::string_view prefix) {
+[[nodiscard]] inline constexpr absl::string_view StripPrefix(
+    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND,
+    absl::string_view prefix) {
   if (absl::StartsWith(str, prefix)) str.remove_prefix(prefix.size());
   return str;
 }
@@ -84,8 +86,9 @@ ABSL_MUST_USE_RESULT inline absl::string_view StripPrefix(
 // Returns a view into the input string `str` with the given `suffix` removed,
 // but leaving the original string intact. If the suffix does not match at the
 // end of the string, returns the original string instead.
-ABSL_MUST_USE_RESULT inline absl::string_view StripSuffix(
-    absl::string_view str, absl::string_view suffix) {
+[[nodiscard]] inline constexpr absl::string_view StripSuffix(
+    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND,
+    absl::string_view suffix) {
   if (absl::EndsWith(str, suffix)) str.remove_suffix(suffix.size());
   return str;
 }

data/third_party/abseil-cpp/absl/strings/substitute.cc

@@ -35,9 +35,10 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace substitute_internal {
 
-void SubstituteAndAppendArray(
-    absl::Nonnull<std::string*> output, absl::string_view format,
-    absl::Nullable<const absl::string_view*> args_array, size_t num_args) {
+void SubstituteAndAppendArray(std::string* absl_nonnull output,
+                              absl::string_view format,
+                              const absl::string_view* absl_nullable args_array,
+                              size_t num_args) {
   // Determine total size needed.
   size_t size = 0;
   for (size_t i = 0; i < format.size(); i++) {
@@ -109,7 +110,7 @@ void SubstituteAndAppendArray(
   assert(target == output->data() + output->size());
 }
 
-Arg::Arg(absl::Nullable<const void*> value) {
+Arg::Arg(const void* absl_nullable value) {
   static_assert(sizeof(scratch_) >= sizeof(value) * 2 + 2,
                 "fix sizeof(scratch_)");
   if (value == nullptr) {