re2 1.24.1 → 1.25.0

package/vendor/abseil-cpp/absl/strings/cord_test.cc

@@ -24,6 +24,7 @@
 #include <iostream>
 #include <iterator>
 #include <limits>
+#include <optional>
 #include <random>
 #include <set>
 #include <sstream>
@@ -61,7 +62,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/compare.h"
-#include "absl/types/optional.h"
+#include "absl/types/span.h"
 
 // convenience local constants
 static constexpr auto FLAT = absl::cord_internal::FLAT;
@@ -416,7 +417,7 @@ TEST_P(CordTest, Assignment) {
   absl::Cord x(absl::string_view("hi there"));
   absl::Cord y(x);
   MaybeHarden(y);
-  ASSERT_EQ(x.ExpectedChecksum(), absl::nullopt);
+  ASSERT_EQ(x.ExpectedChecksum(), std::nullopt);
   ASSERT_EQ(std::string(x), "hi there");
   ASSERT_EQ(std::string(y), "hi there");
   ASSERT_TRUE(x == y);
@@ -618,7 +619,7 @@ TEST_P(CordTest, Subcord) {
                 std::string(sa))
           << a;
       if (pos != 0 || end_pos != a.size()) {
-        ASSERT_EQ(sa.ExpectedChecksum(), absl::nullopt);
+        ASSERT_EQ(sa.ExpectedChecksum(), std::nullopt);
       }
     }
   }
@@ -662,7 +663,7 @@ TEST_P(CordTest, Swap) {
   MaybeHarden(x);
   swap(x, y);
   if (UseCrc()) {
-    ASSERT_EQ(x.ExpectedChecksum(), absl::nullopt);
+    ASSERT_EQ(x.ExpectedChecksum(), std::nullopt);
     ASSERT_EQ(y.ExpectedChecksum(), 1);
   }
   ASSERT_EQ(x, absl::Cord(b));
@@ -670,7 +671,7 @@ TEST_P(CordTest, Swap) {
   x.swap(y);
   if (UseCrc()) {
     ASSERT_EQ(x.ExpectedChecksum(), 1);
-    ASSERT_EQ(y.ExpectedChecksum(), absl::nullopt);
+    ASSERT_EQ(y.ExpectedChecksum(), std::nullopt);
   }
   ASSERT_EQ(x, absl::Cord(a));
   ASSERT_EQ(y, absl::Cord(b));
@@ -735,6 +736,53 @@ TEST_P(CordTest, AppendToString) {
                                 "appending ", "to ", "a ", "string."})));
 }
 
+static void VerifyCopyToSpan(const absl::Cord& cord) {
+  // Test with span exactly the same size as the cord.
+  {
+    std::string dst(cord.size(), '\0');
+    size_t copied = absl::CopyCordToSpan(cord, absl::MakeSpan(dst));
+    EXPECT_EQ(copied, cord.size());
+    EXPECT_EQ(dst, cord);
+  }
+
+  // Test with span larger than the cord.
+  {
+    std::string dst(cord.size() + 10, 'x');
+    size_t copied = absl::CopyCordToSpan(cord, absl::MakeSpan(dst));
+    EXPECT_EQ(copied, cord.size());
+    EXPECT_EQ(absl::string_view(dst).substr(0, copied), cord);
+    if (cord.size() < dst.size()) {
+      absl::string_view tail = absl::string_view(dst).substr(copied);
+      EXPECT_EQ(tail, std::string(tail.size(), 'x'));
+    }
+  }
+
+  // Test with span smaller than the cord.
+  {
+    size_t target_size = cord.size() / 2;
+    std::string dst(target_size, '\0');
+    size_t copied = absl::CopyCordToSpan(cord, absl::MakeSpan(dst));
+    EXPECT_EQ(copied, target_size);
+    EXPECT_EQ(dst, std::string(cord).substr(0, target_size));
+  }
+
+  // Test with empty span.
+  {
+    char c = 'x';
+    size_t copied = absl::CopyCordToSpan(cord, absl::MakeSpan(&c, 0));
+    EXPECT_EQ(copied, 0);
+    EXPECT_EQ(c, 'x');
+  }
+}
+
+TEST_P(CordTest, CopyToSpan) {
+  VerifyCopyToSpan(absl::Cord());  // Empty cords cannot be hardened.
+  VerifyCopyToSpan(MaybeHardened(absl::Cord("small cord")));
+  VerifyCopyToSpan(MaybeHardened(
+      absl::MakeFragmentedCord({"fragmented ", "cord ", "to ", "test ",
+                                "copying ", "to ", "a ", "span."})));
+}
+
 TEST_P(CordTest, AppendEmptyBuffer) {
   absl::Cord cord;
   cord.Append(absl::CordBuffer());
@@ -1072,7 +1120,7 @@ TEST_P(CordTest, TryFlatSubstrFlat) {
 TEST_P(CordTest, TryFlatConcat) {
   absl::Cord c = absl::MakeFragmentedCord({"hel", "lo"});
   MaybeHarden(c);
-  EXPECT_EQ(c.TryFlat(), absl::nullopt);
+  EXPECT_EQ(c.TryFlat(), std::nullopt);
 }
 
 TEST_P(CordTest, TryFlatExternal) {
@@ -1766,6 +1814,34 @@ TEST_P(CordTest, ConstructFromExternalMoveOnlyReleaser) {
   EXPECT_TRUE(invoked);
 }
 
+TEST_P(CordTest, ConstructFromExternalNonConstReleaser) {
+  struct Releaser {
+    explicit Releaser(bool* invoked) : invoked(invoked) {}
+    // Non const method.
+    void operator()(absl::string_view) { *invoked = true; }
+
+    bool* invoked;
+  };
+
+  bool invoked = false;
+  (void)MaybeHardened(absl::MakeCordFromExternal("dummy", Releaser(&invoked)));
+  EXPECT_TRUE(invoked);
+}
+
+TEST_P(CordTest, ConstructFromExternalNonConstNoArgReleaser) {
+  struct Releaser {
+    explicit Releaser(bool* invoked) : invoked(invoked) {}
+    // Non const method.
+    void operator()() { *invoked = true; }
+
+    bool* invoked;
+  };
+
+  bool invoked = false;
+  (void)MaybeHardened(absl::MakeCordFromExternal("dummy", Releaser(&invoked)));
+  EXPECT_TRUE(invoked);
+}
+
 TEST_P(CordTest, ConstructFromExternalNoArgLambda) {
   bool invoked = false;
   (void)MaybeHardened(
@@ -3138,13 +3214,13 @@ TEST_P(CordTest, ExpectedChecksum) {
           continue;
         }
 
-        EXPECT_EQ(c2.ExpectedChecksum(), absl::nullopt);
+        EXPECT_EQ(c2.ExpectedChecksum(), std::nullopt);
 
         if (mutator.CanUndo()) {
           // Undoing an operation should not restore the checksum
           mutator.Undo(c2);
           EXPECT_EQ(c2, base_value);
-          EXPECT_EQ(c2.ExpectedChecksum(), absl::nullopt);
+          EXPECT_EQ(c2.ExpectedChecksum(), std::nullopt);
         }
       }
 
@@ -3254,7 +3330,7 @@ TEST_P(CordTest, ChecksummedEmptyCord) {
       // Not a mutation
       continue;
     }
-    EXPECT_EQ(c2.ExpectedChecksum(), absl::nullopt);
+    EXPECT_EQ(c2.ExpectedChecksum(), std::nullopt);
 
     if (mutator.CanUndo()) {
       mutator.Undo(c2);

package/vendor/abseil-cpp/absl/strings/escaping.cc

@@ -30,6 +30,7 @@
 #include "absl/base/internal/unaligned_access.h"
 #include "absl/base/macros.h"
 #include "absl/base/nullability.h"
+#include "absl/base/optimization.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/charset.h"
 #include "absl/strings/internal/append_and_overwrite.h"
@@ -179,14 +180,17 @@ bool CUnescapeInternal(absl::string_view src, bool leave_nulls_escaped,
                  absl::ascii_isxdigit(static_cast<unsigned char>(src[p + 1]))) {
             // Arbitrarily many hex digits
             ch = (ch << 4) + hex_digit_to_int(src[++p]);
-          }
-          if (ch > 0xFF) {
-            if (error != nullptr) {
-              *error = "Value of \\" +
-                       std::string(src.substr(hex_start, p + 1 - hex_start)) +
-                       " exceeds 0xff";
+            // If ch was 0xFF at the start of this loop, the most can it can be
+            // here is (0xFF << 4) + 0xF, which is 4095, thus ch cannot overflow
+            // 32-bits here. The check below is sufficient.
+            if (ch > 0xFF) {
+              if (error != nullptr) {
+                *error = "Value of \\" +
+                         std::string(src.substr(hex_start, p + 1 - hex_start)) +
+                         " exceeds 0xff";
+              }
+              return false;
             }
-            return false;
           }
           if ((ch == 0) && leave_nulls_escaped) {
             // Copy the escape sequence for the null character
@@ -464,6 +468,165 @@ void CEscapeAndAppendInternal(absl::string_view src,
       });
 }
 
+// The two strings below provide maps from normal 6-bit characters to their
+// base64-escaped equivalent.
+// For the inverse case, see kUn(WebSafe)Base64 in the external
+// escaping.cc.
+constexpr char kBase64Chars[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+constexpr char kWebSafeBase64Chars[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+// ----------------------------------------------------------------------
+//   Take the input in groups of 4 characters and turn each
+//   character into a code 0 to 63 thus:
+//           A-Z map to 0 to 25
+//           a-z map to 26 to 51
+//           0-9 map to 52 to 61
+//           +(- for WebSafe) maps to 62
+//           /(_ for WebSafe) maps to 63
+//   There will be four numbers, all less than 64 which can be represented
+//   by a 6 digit binary number (aaaaaa, bbbbbb, cccccc, dddddd respectively).
+//   Arrange the 6 digit binary numbers into three bytes as such:
+//   aaaaaabb bbbbcccc ccdddddd
+//   Equals signs (one or two) are used at the end of the encoded block to
+//   indicate that the text was not an integer multiple of three bytes long.
+// ----------------------------------------------------------------------
+size_t Base64EscapeInternal(const unsigned char* src, size_t szsrc, char* dest,
+                            size_t szdest, const char* base64,
+                            bool do_padding) {
+  constexpr char kPad64 = '=';
+
+  constexpr size_t kMaxSize = (std::numeric_limits<size_t>::max() - 1) / 4 * 3;
+  if (ABSL_PREDICT_FALSE(szsrc > kMaxSize || szsrc * 4 > szdest * 3)) return 0;
+
+  char* cur_dest = dest;
+  const unsigned char* cur_src = src;
+
+  char* const limit_dest = dest + szdest;
+  const unsigned char* const limit_src = src + szsrc;
+
+  // (from https://tools.ietf.org/html/rfc3548)
+  // Special processing is performed if fewer than 24 bits are available
+  // at the end of the data being encoded.  A full encoding quantum is
+  // always completed at the end of a quantity.  When fewer than 24 input
+  // bits are available in an input group, zero bits are added (on the
+  // right) to form an integral number of 6-bit groups.
+  //
+  // If do_padding is true, padding at the end of the data is performed. This
+  // output padding uses the '=' character.
+
+  // Three bytes of data encodes to four characters of cyphertext.
+  // So we can pump through three-byte chunks atomically.
+  if (szsrc >= 3) {                    // "limit_src - 3" is UB if szsrc < 3.
+    while (cur_src < limit_src - 3) {  // While we have >= 32 bits.
+      uint32_t in = absl::big_endian::Load32(cur_src) >> 8;
+
+      cur_dest[0] = base64[in >> 18];
+      in &= 0x3FFFF;
+      cur_dest[1] = base64[in >> 12];
+      in &= 0xFFF;
+      cur_dest[2] = base64[in >> 6];
+      in &= 0x3F;
+      cur_dest[3] = base64[in];
+
+      cur_dest += 4;
+      cur_src += 3;
+    }
+  }
+  // To save time, we didn't update szdest or szsrc in the loop.  So do it now.
+  szdest = static_cast<size_t>(limit_dest - cur_dest);
+  szsrc = static_cast<size_t>(limit_src - cur_src);
+
+  /* now deal with the tail (<=3 bytes) */
+  switch (szsrc) {
+    case 0:
+      // Nothing left; nothing more to do.
+      break;
+    case 1: {
+      // One byte left: this encodes to two characters, and (optionally)
+      // two pad characters to round out the four-character cypherblock.
+      if (szdest < 2) return 0;
+      uint32_t in = cur_src[0];
+      cur_dest[0] = base64[in >> 2];
+      in &= 0x3;
+      cur_dest[1] = base64[in << 4];
+      cur_dest += 2;
+      szdest -= 2;
+      if (do_padding) {
+        if (szdest < 2) return 0;
+        cur_dest[0] = kPad64;
+        cur_dest[1] = kPad64;
+        cur_dest += 2;
+        szdest -= 2;
+      }
+      break;
+    }
+    case 2: {
+      // Two bytes left: this encodes to three characters, and (optionally)
+      // one pad character to round out the four-character cypherblock.
+      if (szdest < 3) return 0;
+      uint32_t in = absl::big_endian::Load16(cur_src);
+      cur_dest[0] = base64[in >> 10];
+      in &= 0x3FF;
+      cur_dest[1] = base64[in >> 4];
+      in &= 0x00F;
+      cur_dest[2] = base64[in << 2];
+      cur_dest += 3;
+      szdest -= 3;
+      if (do_padding) {
+        if (szdest < 1) return 0;
+        cur_dest[0] = kPad64;
+        cur_dest += 1;
+        szdest -= 1;
+      }
+      break;
+    }
+    case 3: {
+      // Three bytes left: same as in the big loop above.  We can't do this in
+      // the loop because the loop above always reads 4 bytes, and the fourth
+      // byte is past the end of the input.
+      if (szdest < 4) return 0;
+      uint32_t in =
+          (uint32_t{cur_src[0]} << 16) + absl::big_endian::Load16(cur_src + 1);
+      cur_dest[0] = base64[in >> 18];
+      in &= 0x3FFFF;
+      cur_dest[1] = base64[in >> 12];
+      in &= 0xFFF;
+      cur_dest[2] = base64[in >> 6];
+      in &= 0x3F;
+      cur_dest[3] = base64[in];
+      cur_dest += 4;
+      szdest -= 4;
+      break;
+    }
+    default:
+      // Should not be reached: blocks of 4 bytes are handled
+      // in the while loop before this switch statement.
+      ABSL_RAW_LOG(FATAL, "Logic problem? szsrc = %zu", szsrc);
+      break;
+  }
+  return static_cast<size_t>(cur_dest - dest);
+}
+
+std::string Base64EscapeToStringInternal(const unsigned char* src, size_t szsrc,
+                                         bool do_padding,
+                                         const char* base64_chars) {
+  std::string escaped;
+  const size_t calc_escaped_size =
+      strings_internal::CalculateBase64EscapedLenInternal(szsrc, do_padding);
+  StringResizeAndOverwrite(
+      escaped, calc_escaped_size,
+      [src, szsrc, base64_chars, do_padding](char* buf, size_t buf_size) {
+        const size_t escaped_len = Base64EscapeInternal(
+            src, szsrc, buf, buf_size, base64_chars, do_padding);
+        assert(escaped_len == buf_size);
+        return escaped_len;
+      });
+  return escaped;
+}
+
 // Reverses the mapping in Base64EscapeInternal; see that method's
 // documentation for details of the mapping.
 bool Base64UnescapeInternal(const char* absl_nullable src_param, size_t szsrc,
@@ -951,33 +1114,16 @@ bool WebSafeBase64Unescape(absl::string_view src,
   return Base64UnescapeInternal(src.data(), src.size(), dest, kUnWebSafeBase64);
 }
 
-void Base64Escape(absl::string_view src, std::string* absl_nonnull dest) {
-  strings_internal::Base64EscapeInternal(
-      reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest,
-      true, strings_internal::kBase64Chars);
-}
-
-void WebSafeBase64Escape(absl::string_view src,
-                         std::string* absl_nonnull dest) {
-  strings_internal::Base64EscapeInternal(
-      reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest,
-      false, strings_internal::kWebSafeBase64Chars);
-}
-
 std::string Base64Escape(absl::string_view src) {
-  std::string dest;
-  strings_internal::Base64EscapeInternal(
-      reinterpret_cast<const unsigned char*>(src.data()), src.size(), &dest,
-      true, strings_internal::kBase64Chars);
-  return dest;
+  return Base64EscapeToStringInternal(
+      reinterpret_cast<const unsigned char*>(src.data()), src.size(), true,
+      kBase64Chars);
 }
 
 std::string WebSafeBase64Escape(absl::string_view src) {
-  std::string dest;
-  strings_internal::Base64EscapeInternal(
-      reinterpret_cast<const unsigned char*>(src.data()), src.size(), &dest,
-      false, strings_internal::kWebSafeBase64Chars);
-  return dest;
+  return Base64EscapeToStringInternal(
+      reinterpret_cast<const unsigned char*>(src.data()), src.size(), false,
+      kWebSafeBase64Chars);
 }
 
 bool HexStringToBytes(absl::string_view hex, std::string* absl_nonnull bytes) {

package/vendor/abseil-cpp/absl/strings/escaping.h

@@ -126,16 +126,26 @@ std::string Utf8SafeCHexEscape(absl::string_view src);
 // Encodes a `src` string into a base64-encoded 'dest' string with padding
 // characters. This function conforms with RFC 4648 section 4 (base64) and RFC
 // 2045.
-void Base64Escape(absl::string_view src, std::string* absl_nonnull dest);
 std::string Base64Escape(absl::string_view src);
+[[deprecated(
+    "Use the string-returning version of "
+    "Base64Escape()")]] ABSL_REFACTOR_INLINE inline void
+Base64Escape(absl::string_view src, std::string* absl_nonnull dest) {
+  *dest = Base64Escape(src);
+}
 
 // WebSafeBase64Escape()
 //
 // Encodes a `src` string into a base64 string, like Base64Escape() does, but
 // outputs '-' instead of '+' and '_' instead of '/', and does not pad 'dest'.
 // This function conforms with RFC 4648 section 5 (base64url).
-void WebSafeBase64Escape(absl::string_view src, std::string* absl_nonnull dest);
 std::string WebSafeBase64Escape(absl::string_view src);
+[[deprecated(
+    "Use the string-returning version of "
+    "WebSafeBase64Escape()")]] ABSL_REFACTOR_INLINE inline void
+WebSafeBase64Escape(absl::string_view src, std::string* absl_nonnull dest) {
+  *dest = WebSafeBase64Escape(src);
+}
 
 // Base64Unescape()
 //

package/vendor/abseil-cpp/absl/strings/escaping_benchmark.cc

@@ -49,9 +49,7 @@ void BM_WebSafeBase64Escape_string(benchmark::State& state) {
     }
   }
   for (auto _ : state) {
-    std::string escaped;
-    benchmark::DoNotOptimize(raw);
-    absl::WebSafeBase64Escape(raw, &escaped);
+    std::string escaped = absl::WebSafeBase64Escape(raw);
     benchmark::DoNotOptimize(escaped);
   }
 }

package/vendor/abseil-cpp/absl/strings/escaping_test.cc

@@ -170,22 +170,23 @@ TEST(Unescape, BasicFunction) {
     EXPECT_EQ(out, val.unescaped);
   }
   constexpr absl::string_view bad[] = {
-      "\\u1",         // too short
-      "\\U1",         // too short
-      "\\Uffffff",    // exceeds 0x10ffff (largest Unicode)
-      "\\U00110000",  // exceeds 0x10ffff (largest Unicode)
-      "\\uD835",      // surrogate character (D800-DFFF)
-      "\\U0000DD04",  // surrogate character (D800-DFFF)
-      "\\777",        // exceeds 0xff
-      "\\xABCD",      // exceeds 0xff
-      "endswith\\",   // ends with "\"
-      "endswith\\x",  // ends with "\x"
-      "endswith\\X",  // ends with "\X"
-      "\\x.2345678",  // non-hex follows "\x"
-      "\\X.2345678",  // non-hex follows "\X"
-      "\\u.2345678",  // non-hex follows "\U"
-      "\\U.2345678",  // non-hex follows "\U"
-      "\\.unknown",   // unknown escape sequence
+      "\\u1",          // too short
+      "\\U1",          // too short
+      "\\Uffffff",     // exceeds 0x10ffff (largest Unicode)
+      "\\U00110000",   // exceeds 0x10ffff (largest Unicode)
+      "\\uD835",       // surrogate character (D800-DFFF)
+      "\\U0000DD04",   // surrogate character (D800-DFFF)
+      "\\777",         // exceeds 0xff
+      "\\xABCD",       // exceeds 0xff
+      "\\x100000041",  // overflows uint32_t
+      "endswith\\",    // ends with "\"
+      "endswith\\x",   // ends with "\x"
+      "endswith\\X",   // ends with "\X"
+      "\\x.2345678",   // non-hex follows "\x"
+      "\\X.2345678",   // non-hex follows "\X"
+      "\\u.2345678",   // non-hex follows "\U"
+      "\\U.2345678",   // non-hex follows "\U"
+      "\\.unknown",    // unknown escape sequence
   };
   for (const auto e : bad) {
     std::string error;
@@ -682,8 +683,7 @@ TEST(Base64, DISABLED_HugeData) {
   static_assert(kSize % 3 == 0, "kSize must be divisible by 3");
   const std::string huge(kSize, 'x');
 
-  std::string escaped;
-  absl::Base64Escape(huge, &escaped);
+  std::string escaped = absl::Base64Escape(huge);
 
   // Generates the string that should match a base64 encoded "xxx..." string.
   // "xxx" in base64 is "eHh4".

package/vendor/abseil-cpp/absl/strings/has_absl_stringify_test.cc

@@ -14,10 +14,10 @@
 
 #include "absl/strings/has_absl_stringify.h"
 
+#include <optional>
 #include <string>
 
 #include "gtest/gtest.h"
-#include "absl/types/optional.h"
 
 namespace {
 
@@ -34,7 +34,7 @@ TEST(HasAbslStringifyTest, Works) {
   EXPECT_FALSE(absl::HasAbslStringify<TypeWithoutAbslStringify>::value);
   EXPECT_TRUE(absl::HasAbslStringify<TypeWithAbslStringify>::value);
   EXPECT_FALSE(
-      absl::HasAbslStringify<absl::optional<TypeWithAbslStringify>>::value);
+      absl::HasAbslStringify<std::optional<TypeWithAbslStringify>>::value);
 }
 
 }  // namespace

package/vendor/abseil-cpp/absl/strings/has_ostream_operator_test.cc

@@ -14,11 +14,11 @@
 
 #include "absl/strings/has_ostream_operator.h"
 
+#include <optional>
 #include <ostream>
 #include <string>
 
 #include "gtest/gtest.h"
-#include "absl/types/optional.h"
 
 namespace {
 
@@ -33,7 +33,7 @@ struct TypeWithOstreamOp {
 TEST(HasOstreamOperatorTest, Works) {
   EXPECT_TRUE(absl::HasOstreamOperator<int>::value);
   EXPECT_TRUE(absl::HasOstreamOperator<std::string>::value);
-  EXPECT_FALSE(absl::HasOstreamOperator<absl::optional<int>>::value);
+  EXPECT_FALSE(absl::HasOstreamOperator<std::optional<int>>::value);
   EXPECT_FALSE(absl::HasOstreamOperator<TypeWithoutOstreamOp>::value);
   EXPECT_TRUE(absl::HasOstreamOperator<TypeWithOstreamOp>::value);
 }

package/vendor/abseil-cpp/absl/strings/internal/append_and_overwrite.h

@@ -16,9 +16,10 @@
 #define ABSL_STRINGS_INTERNAL_APPEND_AND_OVERWRITE_H_
 
 #include "absl/base/config.h"
-#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/internal/hardening.h"
 #include "absl/base/macros.h"
 #include "absl/base/optimization.h"
+#include "absl/base/throw_delegate.h"
 #include "absl/strings/resize_and_overwrite.h"
 
 namespace absl {
@@ -46,8 +47,7 @@ template <typename T, typename Op>
 void StringAppendAndOverwrite(T& str, typename T::size_type append_n,
                               Op append_op) {
   if (ABSL_PREDICT_FALSE(append_n > str.max_size() - str.size())) {
-    absl::base_internal::ThrowStdLengthError(
-        "absl::strings_internal::StringAppendAndOverwrite");
+    ThrowStdLengthError("absl::strings_internal::StringAppendAndOverwrite");
   }
 
   auto old_size = str.size();
@@ -57,12 +57,10 @@ void StringAppendAndOverwrite(T& str, typename T::size_type append_n,
     // Make sure to always grow by at least a factor of 2x.
     const auto min_growth = str.capacity();
     if (ABSL_PREDICT_FALSE(str.capacity() > str.max_size() - min_growth)) {
-      resize = str.max_size();
+      str.reserve(str.max_size());
     } else if (resize < str.capacity() + min_growth) {
-      resize = str.capacity() + min_growth;
+      str.reserve(str.capacity() + min_growth);
     }
-  } else {
-    resize = str.capacity();
   }
 
   // Avoid calling StringResizeAndOverwrite() here since it does an MSAN
@@ -72,9 +70,11 @@ void StringAppendAndOverwrite(T& str, typename T::size_type append_n,
       str, resize,
       [old_size, append_n, do_append = std::move(append_op)](
           typename T::value_type* data_ptr, typename T::size_type) mutable {
-        auto num_appended =
-            std::move(do_append)(data_ptr + old_size, append_n);
-        ABSL_HARDENING_ASSERT(num_appended >= 0 && num_appended <= append_n);
+        typename T::size_type num_appended = static_cast<typename T::size_type>(
+            std::move(do_append)(data_ptr + old_size, append_n));
+        absl::base_internal::HardeningAssertGE(num_appended,
+                                               typename T::size_type{0});
+        absl::base_internal::HardeningAssertLE(num_appended, append_n);
         return old_size + num_appended;
       });
 

package/vendor/abseil-cpp/absl/strings/internal/cordz_sample_token_test.cc

@@ -187,7 +187,7 @@ TEST(CordzSampleTokenTest, MultiThreaded) {
             }
           } else {
             // 5) Sample
-            token = absl::make_unique<CordzSampleToken>();
+            token = std::make_unique<CordzSampleToken>();
           }
         }
       }

package/vendor/abseil-cpp/absl/strings/internal/damerau_levenshtein_distance.cc

@@ -16,9 +16,15 @@
 
 #include <algorithm>
 #include <array>
+#include <cstddef>
+#include <cstdint>
 #include <numeric>
+#include <utility>
 
+#include "absl/base/config.h"
+#include "absl/strings/match.h"
 #include "absl/strings/string_view.h"
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace strings_internal {

package/vendor/abseil-cpp/absl/strings/internal/damerau_levenshtein_distance.h

@@ -17,6 +17,7 @@
 
 #include <cstdint>
 
+#include "absl/base/config.h"
 #include "absl/strings/string_view.h"
 
 namespace absl {