grpc 1.57.0 → 1.58.0.pre1

data/third_party/abseil-cpp/absl/strings/internal/str_format/arg.cc

@@ -106,7 +106,7 @@ class IntDigits {
     char *p = storage_ + sizeof(storage_);
     do {
       p -= 2;
-      numbers_internal::PutTwoDigits(static_cast<size_t>(v % 100), p);
+      numbers_internal::PutTwoDigits(static_cast<uint32_t>(v % 100), p);
       v /= 100;
     } while (v);
     if (p[0] == '0') {
@@ -278,24 +278,6 @@ bool ConvertIntImplInnerSlow(const IntDigits &as_digits,
   return true;
 }
 
-template <typename T,
-          typename std::enable_if<(std::is_integral<T>::value &&
-                                   std::is_signed<T>::value) ||
-                                      std::is_same<T, int128>::value,
-                                  int>::type = 0>
-constexpr auto ConvertV(T) {
-  return FormatConversionCharInternal::d;
-}
-
-template <typename T,
-          typename std::enable_if<(std::is_integral<T>::value &&
-                                   std::is_unsigned<T>::value) ||
-                                      std::is_same<T, uint128>::value,
-                                  int>::type = 0>
-constexpr auto ConvertV(T) {
-  return FormatConversionCharInternal::u;
-}
-
 template <typename T>
 bool ConvertFloatArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
   if (conv.conversion_char() == FormatConversionCharInternal::v) {
@@ -332,10 +314,6 @@ bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
   using U = typename MakeUnsigned<T>::type;
   IntDigits as_digits;
 
-  if (conv.conversion_char() == FormatConversionCharInternal::v) {
-    conv.set_conversion_char(ConvertV(T{}));
-  }
-
   // This odd casting is due to a bug in -Wswitch behavior in gcc49 which causes
   // it to complain about a switch/case type mismatch, even though both are
   // FormatConverionChar.  Likely this is because at this point
@@ -361,6 +339,7 @@ bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
 
     case static_cast<uint8_t>(FormatConversionCharInternal::d):
     case static_cast<uint8_t>(FormatConversionCharInternal::i):
+    case static_cast<uint8_t>(FormatConversionCharInternal::v):
       as_digits.PrintAsDec(v);
       break;
 
@@ -482,18 +461,18 @@ CharConvertResult FormatConvertImpl(char v, const FormatConversionSpecImpl conv,
                                     FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
-CharConvertResult FormatConvertImpl(signed char v,
-                                    const FormatConversionSpecImpl conv,
-                                    FormatSinkImpl *sink) {
+
+// ==================== Ints ====================
+IntegralConvertResult FormatConvertImpl(signed char v,
+                                        const FormatConversionSpecImpl conv,
+                                        FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
-CharConvertResult FormatConvertImpl(unsigned char v,
-                                    const FormatConversionSpecImpl conv,
-                                    FormatSinkImpl *sink) {
+IntegralConvertResult FormatConvertImpl(unsigned char v,
+                                        const FormatConversionSpecImpl conv,
+                                        FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
-
-// ==================== Ints ====================
 IntegralConvertResult FormatConvertImpl(short v,  // NOLINT
                                         const FormatConversionSpecImpl conv,
                                         FormatSinkImpl *sink) {

data/third_party/abseil-cpp/absl/strings/internal/str_format/arg.h

@@ -279,14 +279,14 @@ FloatingConvertResult FormatConvertImpl(long double v,
 // Chars.
 CharConvertResult FormatConvertImpl(char v, FormatConversionSpecImpl conv,
                                     FormatSinkImpl* sink);
-CharConvertResult FormatConvertImpl(signed char v,
-                                    FormatConversionSpecImpl conv,
-                                    FormatSinkImpl* sink);
-CharConvertResult FormatConvertImpl(unsigned char v,
-                                    FormatConversionSpecImpl conv,
-                                    FormatSinkImpl* sink);
 
 // Ints.
+IntegralConvertResult FormatConvertImpl(signed char v,
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(unsigned char v,
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
 IntegralConvertResult FormatConvertImpl(short v,  // NOLINT
                                         FormatConversionSpecImpl conv,
                                         FormatSinkImpl* sink);
@@ -441,7 +441,7 @@ class FormatArgImpl {
   // For everything else:
   //   - Decay char* and char arrays into `const char*`
   //   - Decay any other pointer to `const void*`
-  //   - Decay all enums to their underlying type.
+  //   - Decay all enums to the integral promotion of their underlying type.
   //   - Decay function pointers to void*.
   template <typename T, typename = void>
   struct DecayType {
@@ -461,7 +461,7 @@ class FormatArgImpl {
                        !str_format_internal::HasUserDefinedConvert<T>::value &&
                        !strings_internal::HasAbslStringify<T>::value &&
                        std::is_enum<T>::value>::type> {
-    using type = typename std::underlying_type<T>::type;
+    using type = decltype(+typename std::underlying_type<T>::type());
   };
 
  public:

data/third_party/abseil-cpp/absl/strings/internal/str_format/bind.h

@@ -21,6 +21,7 @@
 #include <string>
 
 #include "absl/base/port.h"
+#include "absl/container/inlined_vector.h"
 #include "absl/strings/internal/str_format/arg.h"
 #include "absl/strings/internal/str_format/checker.h"
 #include "absl/strings/internal/str_format/parser.h"
@@ -177,17 +178,7 @@ class Streamable {
  public:
   Streamable(const UntypedFormatSpecImpl& format,
              absl::Span<const FormatArgImpl> args)
-      : format_(format) {
-    if (args.size() <= ABSL_ARRAYSIZE(few_args_)) {
-      for (size_t i = 0; i < args.size(); ++i) {
-        few_args_[i] = args[i];
-      }
-      args_ = absl::MakeSpan(few_args_, args.size());
-    } else {
-      many_args_.assign(args.begin(), args.end());
-      args_ = many_args_;
-    }
-  }
+      : format_(format), args_(args.begin(), args.end()) {}
 
   std::ostream& Print(std::ostream& os) const;
 
@@ -197,12 +188,7 @@ class Streamable {
 
  private:
   const UntypedFormatSpecImpl& format_;
-  absl::Span<const FormatArgImpl> args_;
-  // if args_.size() is 4 or less:
-  FormatArgImpl few_args_[4] = {FormatArgImpl(0), FormatArgImpl(0),
-                                FormatArgImpl(0), FormatArgImpl(0)};
-  // if args_.size() is more than 4:
-  std::vector<FormatArgImpl> many_args_;
+  absl::InlinedVector<FormatArgImpl, 4> args_;
 };
 
 // for testing
@@ -211,8 +197,7 @@ std::string Summarize(UntypedFormatSpecImpl format,
 bool BindWithPack(const UnboundConversion* props,
                   absl::Span<const FormatArgImpl> pack, BoundConversion* bound);
 
-bool FormatUntyped(FormatRawSinkImpl raw_sink,
-                   UntypedFormatSpecImpl format,
+bool FormatUntyped(FormatRawSinkImpl raw_sink, UntypedFormatSpecImpl format,
                    absl::Span<const FormatArgImpl> args);
 
 std::string& AppendPack(std::string* out, UntypedFormatSpecImpl format,
@@ -231,7 +216,7 @@ int SnprintF(char* output, size_t size, UntypedFormatSpecImpl format,
 template <typename T>
 class StreamedWrapper {
  public:
-  explicit StreamedWrapper(const T& v) : v_(v) { }
+  explicit StreamedWrapper(const T& v) : v_(v) {}
 
  private:
   template <typename S>

data/third_party/abseil-cpp/absl/strings/internal/str_format/constexpr_parser.h

@@ -323,6 +323,7 @@ constexpr const char* ConsumeConversion(const char* pos, const char* const end,
     if (ABSL_PREDICT_FALSE(c == 'v')) return nullptr;
     if (ABSL_PREDICT_FALSE(!tag.is_conv())) return nullptr;
   }
+#undef ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR
 
   assert(CheckFastPathSetting(*conv));
   (void)(&CheckFastPathSetting);

data/third_party/abseil-cpp/absl/strings/internal/str_format/extension.h

@@ -273,7 +273,7 @@ struct FormatConversionSpecImplFriend;
 
 class FormatConversionSpecImpl {
  public:
-  // Width and precison are not specified, no flags are set.
+  // Width and precision are not specified, no flags are set.
   bool is_basic() const { return flags_ == Flags::kBasic; }
   bool has_left_flag() const { return FlagsContains(flags_, Flags::kLeft); }
   bool has_show_pos_flag() const {

data/third_party/abseil-cpp/absl/strings/internal/str_format/float_conversion.cc

@@ -711,12 +711,12 @@ bool IncrementNibble(size_t nibble_index, Int* n) {
   constexpr size_t kShift = sizeof(Int) * 8 - 1;
   constexpr size_t kNumNibbles = sizeof(Int) * 8 / 4;
   Int before = *n >> kShift;
-  // Here we essentially want to take the number 1 and move it into the requsted
-  // nibble, then add it to *n to effectively increment the nibble. However,
-  // ASan will complain if we try to shift the 1 beyond the limits of the Int,
-  // i.e., if the nibble_index is out of range. So therefore we check for this
-  // and if we are out of range we just add 0 which leaves *n unchanged, which
-  // seems like the reasonable thing to do in that case.
+  // Here we essentially want to take the number 1 and move it into the
+  // requested nibble, then add it to *n to effectively increment the nibble.
+  // However, ASan will complain if we try to shift the 1 beyond the limits of
+  // the Int, i.e., if the nibble_index is out of range. So therefore we check
+  // for this and if we are out of range we just add 0 which leaves *n
+  // unchanged, which seems like the reasonable thing to do in that case.
   *n += ((nibble_index >= kNumNibbles)
              ? 0
              : (Int{1} << static_cast<int>(nibble_index * 4)));
@@ -937,7 +937,7 @@ void FormatA(const HexFloatTypeParams float_traits, Int mantissa, int exp,
 
   // =============== Exponent ==================
   constexpr size_t kBufSizeForExpDecRepr =
-      numbers_internal::kFastToBufferSize  // requred for FastIntToBuffer
+      numbers_internal::kFastToBufferSize  // required for FastIntToBuffer
       + 1                                  // 'p' or 'P'
       + 1;                                 // '+' or '-'
   char exp_buffer[kBufSizeForExpDecRepr];
@@ -1015,7 +1015,7 @@ struct Buffer {
     --end;
   }
 
-  char &back() {
+  char &back() const {
     assert(begin < end);
     return end[-1];
   }
@@ -1102,7 +1102,7 @@ void PrintExponent(int exp, char e, Buffer *out) {
 template <typename Float, typename Int>
 constexpr bool CanFitMantissa() {
   return
-#if defined(__clang__) && !defined(__SSE3__)
+#if defined(__clang__) && (__clang_major__ < 9) && !defined(__SSE3__)
       // Workaround for clang bug: https://bugs.llvm.org/show_bug.cgi?id=38289
       // Casting from long double to uint64_t is miscompiled and drops bits.
       (!std::is_same<Float, long double>::value ||

data/third_party/abseil-cpp/absl/strings/internal/str_split_internal.h

@@ -235,6 +235,24 @@ struct SplitterIsConvertibleTo
           HasMappedType<C>::value> {
 };
 
+template <typename StringType, typename Container, typename = void>
+struct ShouldUseLifetimeBound : std::false_type {};
+
+template <typename StringType, typename Container>
+struct ShouldUseLifetimeBound<
+    StringType, Container,
+    std::enable_if_t<
+        std::is_same<StringType, std::string>::value &&
+        std::is_same<typename Container::value_type, absl::string_view>::value>>
+    : std::true_type {};
+
+template <typename StringType, typename First, typename Second>
+using ShouldUseLifetimeBoundForPair = std::integral_constant<
+    bool, std::is_same<StringType, std::string>::value &&
+              (std::is_same<First, absl::string_view>::value ||
+               std::is_same<Second, absl::string_view>::value)>;
+
+
 // This class implements the range that is returned by absl::StrSplit(). This
 // class has templated conversion operators that allow it to be implicitly
 // converted to a variety of types that the caller may have specified on the
@@ -281,10 +299,24 @@ class Splitter {
 
   // An implicit conversion operator that is restricted to only those containers
   // that the splitter is convertible to.
-  template <typename Container,
-            typename = typename std::enable_if<
-                SplitterIsConvertibleTo<Container>::value>::type>
-  operator Container() const {  // NOLINT(runtime/explicit)
+  template <
+      typename Container,
+      std::enable_if_t<ShouldUseLifetimeBound<StringType, Container>::value &&
+                           SplitterIsConvertibleTo<Container>::value,
+                       std::nullptr_t> = nullptr>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  operator Container() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return ConvertToContainer<Container, typename Container::value_type,
+                              HasMappedType<Container>::value>()(*this);
+  }
+
+  template <
+      typename Container,
+      std::enable_if_t<!ShouldUseLifetimeBound<StringType, Container>::value &&
+                           SplitterIsConvertibleTo<Container>::value,
+                       std::nullptr_t> = nullptr>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  operator Container() const {
     return ConvertToContainer<Container, typename Container::value_type,
                               HasMappedType<Container>::value>()(*this);
   }
@@ -293,8 +325,27 @@ class Splitter {
   // strings returned by the begin() iterator. Either/both of .first and .second
   // will be constructed with empty strings if the iterator doesn't have a
   // corresponding value.
+  template <typename First, typename Second,
+            std::enable_if_t<
+                ShouldUseLifetimeBoundForPair<StringType, First, Second>::value,
+                std::nullptr_t> = nullptr>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  operator std::pair<First, Second>() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return ConvertToPair<First, Second>();
+  }
+
+  template <typename First, typename Second,
+            std::enable_if_t<!ShouldUseLifetimeBoundForPair<StringType, First,
+                                                            Second>::value,
+                             std::nullptr_t> = nullptr>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  operator std::pair<First, Second>() const {
+    return ConvertToPair<First, Second>();
+  }
+
+ private:
   template <typename First, typename Second>
-  operator std::pair<First, Second>() const {  // NOLINT(runtime/explicit)
+  std::pair<First, Second> ConvertToPair() const {
     absl::string_view first, second;
     auto it = begin();
     if (it != end()) {
@@ -306,7 +357,6 @@ class Splitter {
     return {First(first), Second(second)};
   }
 
- private:
   // ConvertToContainer is a functor converting a Splitter to the requested
   // Container of ValueType. It is specialized below to optimize splitting to
   // certain combinations of Container and ValueType.

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

@@ -14,6 +14,12 @@
 
 #include "absl/strings/match.h"
 
+#include <algorithm>
+#include <cstdint>
+
+#include "absl/base/internal/endian.h"
+#include "absl/numeric/bits.h"
+#include "absl/strings/ascii.h"
 #include "absl/strings/internal/memutil.h"
 
 namespace absl {
@@ -27,6 +33,27 @@ bool EqualsIgnoreCase(absl::string_view piece1,
   // memcasecmp uses absl::ascii_tolower().
 }
 
+bool StrContainsIgnoreCase(absl::string_view haystack,
+                           absl::string_view needle) noexcept {
+  while (haystack.size() >= needle.size()) {
+    if (StartsWithIgnoreCase(haystack, needle)) return true;
+    haystack.remove_prefix(1);
+  }
+  return false;
+}
+
+bool StrContainsIgnoreCase(absl::string_view haystack,
+                           char needle) noexcept {
+  char upper_needle = absl::ascii_toupper(static_cast<unsigned char>(needle));
+  char lower_needle = absl::ascii_tolower(static_cast<unsigned char>(needle));
+  if (upper_needle == lower_needle) {
+    return StrContains(haystack, needle);
+  } else {
+    const char both_cstr[3] = {lower_needle, upper_needle, '\0'};
+    return haystack.find_first_of(both_cstr) != absl::string_view::npos;
+  }
+}
+
 bool StartsWithIgnoreCase(absl::string_view text,
                           absl::string_view prefix) noexcept {
   return (text.size() >= prefix.size()) &&
@@ -39,5 +66,65 @@ bool EndsWithIgnoreCase(absl::string_view text,
          EqualsIgnoreCase(text.substr(text.size() - suffix.size()), suffix);
 }
 
+absl::string_view FindLongestCommonPrefix(absl::string_view a,
+                                          absl::string_view b) {
+  const absl::string_view::size_type limit = std::min(a.size(), b.size());
+  const char* const pa = a.data();
+  const char* const pb = b.data();
+  absl::string_view::size_type count = (unsigned) 0;
+
+  if (ABSL_PREDICT_FALSE(limit < 8)) {
+    while (ABSL_PREDICT_TRUE(count + 2 <= limit)) {
+      uint16_t xor_bytes = absl::little_endian::Load16(pa + count) ^
+                           absl::little_endian::Load16(pb + count);
+      if (ABSL_PREDICT_FALSE(xor_bytes != 0)) {
+        if (ABSL_PREDICT_TRUE((xor_bytes & 0xff) == 0)) ++count;
+        return absl::string_view(pa, count);
+      }
+      count += 2;
+    }
+    if (ABSL_PREDICT_TRUE(count != limit)) {
+      if (ABSL_PREDICT_TRUE(pa[count] == pb[count])) ++count;
+    }
+    return absl::string_view(pa, count);
+  }
+
+  do {
+    uint64_t xor_bytes = absl::little_endian::Load64(pa + count) ^
+                         absl::little_endian::Load64(pb + count);
+    if (ABSL_PREDICT_FALSE(xor_bytes != 0)) {
+      count += static_cast<uint64_t>(absl::countr_zero(xor_bytes) >> 3);
+      return absl::string_view(pa, count);
+    }
+    count += 8;
+  } while (ABSL_PREDICT_TRUE(count + 8 < limit));
+
+  count = limit - 8;
+  uint64_t xor_bytes = absl::little_endian::Load64(pa + count) ^
+                       absl::little_endian::Load64(pb + count);
+  if (ABSL_PREDICT_TRUE(xor_bytes != 0)) {
+    count += static_cast<uint64_t>(absl::countr_zero(xor_bytes) >> 3);
+    return absl::string_view(pa, count);
+  }
+  return absl::string_view(pa, limit);
+}
+
+absl::string_view FindLongestCommonSuffix(absl::string_view a,
+                                          absl::string_view b) {
+  const absl::string_view::size_type limit = std::min(a.size(), b.size());
+  if (limit == 0) return absl::string_view();
+
+  const char* pa = a.data() + a.size() - 1;
+  const char* pb = b.data() + b.size() - 1;
+  absl::string_view::size_type count = (unsigned) 0;
+  while (count < limit && *pa == *pb) {
+    --pa;
+    --pb;
+    ++count;
+  }
+
+  return absl::string_view(++pa, count);
+}
+
 ABSL_NAMESPACE_END
 }  // namespace absl

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

@@ -72,6 +72,15 @@ inline bool EndsWith(absl::string_view text,
           memcmp(text.data() + (text.size() - suffix.size()), suffix.data(),
                  suffix.size()) == 0);
 }
+// StrContainsIgnoreCase()
+//
+// Returns whether a given ASCII string `haystack` contains the ASCII substring
+// `needle`, ignoring case in the comparison.
+bool StrContainsIgnoreCase(absl::string_view haystack,
+                           absl::string_view needle) noexcept;
+
+bool StrContainsIgnoreCase(absl::string_view haystack,
+                           char needle) noexcept;
 
 // EqualsIgnoreCase()
 //
@@ -94,6 +103,16 @@ bool StartsWithIgnoreCase(absl::string_view text,
 bool EndsWithIgnoreCase(absl::string_view text,
                         absl::string_view suffix) noexcept;
 
+// Yields the longest prefix in common between both input strings.
+// Pointer-wise, the returned result is a subset of input "a".
+absl::string_view FindLongestCommonPrefix(absl::string_view a,
+                                          absl::string_view b);
+
+// Yields the longest suffix in common between both input strings.
+// Pointer-wise, the returned result is a subset of input "a".
+absl::string_view FindLongestCommonSuffix(absl::string_view a,
+                                          absl::string_view b);
+
 ABSL_NAMESPACE_END
 }  // namespace absl