re2 1.24.0 → 1.25.0

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 {

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

@@ -23,16 +23,6 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
-// 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.
-ABSL_CONST_INIT const char kBase64Chars[] =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-ABSL_CONST_INIT const char kWebSafeBase64Chars[] =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-
 size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding) {
   // Base64 encodes three bytes of input at a time. If the input is not
   // divisible by three, we pad as appropriate.
@@ -73,137 +63,6 @@ size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding) {
   return len;
 }
 
-// ----------------------------------------------------------------------
-//   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) {
-  static const char kPad64 = '=';
-
-  if (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);
-}
-
 }  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

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

@@ -15,43 +15,19 @@
 #ifndef ABSL_STRINGS_INTERNAL_ESCAPING_H_
 #define ABSL_STRINGS_INTERNAL_ESCAPING_H_
 
-#include <cassert>
+#include <cstddef>
 
-#include "absl/strings/resize_and_overwrite.h"
+#include "absl/base/config.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
-ABSL_CONST_INIT extern const char kBase64Chars[];
-ABSL_CONST_INIT extern const char kWebSafeBase64Chars[];
-
 // Calculates the length of a Base64 encoding (RFC 4648) of a string of length
 // `input_len`, with or without padding per `do_padding`. Note that 'web-safe'
 // encoding (section 5 of the RFC) does not change this length.
 size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding);
 
-// Base64-encodes `src` using the alphabet provided in `base64` (which
-// determines whether to do web-safe encoding or not) and writes the result to
-// `dest`. If `do_padding` is true, `dest` is padded with '=' chars until its
-// length is a multiple of 3. Returns the length of `dest`.
-size_t Base64EscapeInternal(const unsigned char* src, size_t szsrc, char* dest,
-                            size_t szdest, const char* base64, bool do_padding);
-template <typename String>
-void Base64EscapeInternal(const unsigned char* src, size_t szsrc, String* dest,
-                          bool do_padding, const char* base64_chars) {
-  const size_t calc_escaped_size =
-      CalculateBase64EscapedLenInternal(szsrc, do_padding);
-  StringResizeAndOverwrite(
-      *dest, 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;
-      });
-}
-
 }  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

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

@@ -112,6 +112,23 @@ inline constexpr bool is_supported_ptr<
     // would be a fork.
     decltype(T().~ArenaSafeUniquePtr())> = true;
 
+// `proto2::Arena::UniquePtr` is at least as safe as `std::unique_ptr`.
+template <class T>
+inline constexpr bool is_supported_ptr<
+    T,
+    // Check for `proto2::Arena::UniquePtr` without having to include its
+    // header here. This does match any type named `UniquePtr`, regardless
+    // of the scope it is defined in, but we try to restrict by probing some
+    // methods.
+    std::void_t<decltype(
+        // Check the class name using the destructor.
+        T().~UniquePtr(),
+        // Check some other members, to try to duck type into the right class.
+        T().get(), T().reset(), T().try_heap_release(),
+        T().GetOwningArena()
+            ->template MakeUnique<int>(nullptr)
+            .~UniquePtr())>> = true;
+
 // Specialization for floats: print floating point types using their
 // max_digits10 precision. This ensures each distinct underlying values
 // can be represented uniquely, even though it's not (strictly speaking)
@@ -220,6 +237,8 @@ std::ostream& GenericPrintImpl(std::ostream& os, const T& v) {
   if constexpr (is_any_string<T> || std::is_same_v<T, absl::string_view>) {
     // Specialization for strings: prints with plausible quoting and escaping.
     return PrintEscapedString(os, v);
+  } else if constexpr (is_supported_ptr<T>) {
+    return (PrintSmartPointerContents)(os, v);
   } else if constexpr (absl::HasAbslStringify<T>::value) {
     // If someone has specified `AbslStringify`, we should prefer that.
     return os << absl::StrCat(v);
@@ -246,8 +265,6 @@ std::ostream& GenericPrintImpl(std::ostream& os, const T& v) {
                                                  w)) {})) {
     // For std::variant, use `std::visit(v)`
     return (PrintVariant)(os, v);
-  } else if constexpr (is_supported_ptr<T>) {
-    return (PrintSmartPointerContents)(os, v);
   } else if constexpr (meta_internal::Requires<const T>(
                            [&](auto&& w) -> decltype(w.ok(), w.status(), *w) {
                            })) {
@@ -263,6 +280,10 @@ std::ostream& GenericPrintImpl(std::ostream& os, const T& v) {
     // Specialization for nullptr.
     return os << "nullptr";
 
+  } else if constexpr (std::is_same_v<T, std::monostate>) {
+    // Specialization for `std::monostate`.
+    return os << "monostate";
+
   } else if constexpr (std::is_floating_point_v<T>) {
     // For floating point print with enough precision for a roundtrip.
     return PrintPreciseFP(os, v);

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

@@ -373,6 +373,10 @@ TEST(GenericPrinterTest, Optional) {
                                    generic_logging_test::Streamable{3})));
 }
 
+TEST(GenericPrinterTest, Monostate) {
+  EXPECT_EQ("monostate", GenericPrintToString(std::monostate{}));
+}
+
 TEST(GenericPrinterTest, Tuple) {
   EXPECT_EQ("<1, two, 3>", GenericPrintToString(std::make_tuple(1, "two", 3)));
 }
@@ -396,8 +400,8 @@ TEST(GenericPrinterTest, Variant) {
 }
 
 TEST(GenericPrinterTest, VariantMonostate) {
-  EXPECT_THAT(GenericPrintToString(std::variant<std::monostate, std::string>()),
-              IsUnprintable());
+  EXPECT_EQ("('(index = 0)' monostate)",
+            GenericPrintToString(std::variant<std::monostate, std::string>()));
 }
 
 TEST(GenericPrinterTest, VariantNonStreamable) {

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

@@ -22,8 +22,9 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/base/optimization.h"
 #include "absl/base/port.h"
-#include "absl/meta/type_traits.h"  //  for void_t
+#include "absl/strings/resize_and_overwrite.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -41,8 +42,8 @@ struct ResizeUninitializedTraits {
 // __resize_default_init is provided by libc++ >= 8.0
 template <typename string_type>
 struct ResizeUninitializedTraits<
-    string_type, absl::void_t<decltype(std::declval<string_type&>()
-                                           .__resize_default_init(237))> > {
+    string_type, std::void_t<decltype(std::declval<string_type&>()
+                                          .__resize_default_init(237))> > {
   using HasMember = std::true_type;
   static void Resize(string_type* s, size_t new_size) {
     s->__resize_default_init(new_size);
@@ -68,33 +69,39 @@ inline void STLStringResizeUninitialized(string_type* s, size_t new_size) {
   ResizeUninitializedTraits<string_type>::Resize(s, new_size);
 }
 
-// In this type trait, we look for an __append_default_init member function, and
-// we use it if available, otherwise, we use append.
-template <typename string_type, typename = void>
-struct AppendUninitializedTraits {
-  static void Append(string_type* s, size_t n) {
-    s->append(n, typename string_type::value_type());
-  }
-};
-
-template <typename string_type>
-struct AppendUninitializedTraits<
-    string_type, absl::void_t<decltype(std::declval<string_type&>()
-                                           .__append_default_init(237))> > {
-  static void Append(string_type* s, size_t n) {
-    s->__append_default_init(n);
-  }
-};
-
 // Like STLStringResizeUninitialized(str, new_size), except guaranteed to use
 // exponential growth so that the amortized complexity of increasing the string
 // size by a small amount is O(1), in contrast to O(str->size()) in the case of
 // precise growth.
+//
+// TODO: b/446221957 - Delete this function.
 template <typename string_type>
+[[deprecated]]
 void STLStringResizeUninitializedAmortized(string_type* s, size_t new_size) {
-  const size_t size = s->size();
-  if (new_size > size) {
-    AppendUninitializedTraits<string_type>::Append(s, new_size - size);
+  if (new_size > s->size()) {
+    if (new_size > s->capacity()) {
+      // Make sure to always grow by at least a factor of 2x. Change min_growth
+      // if you want to experiment with other growth strategies.
+      const auto min_growth = s->capacity();
+      if (ABSL_PREDICT_FALSE(s->capacity() > s->max_size() - min_growth)) {
+        s->reserve(s->max_size());
+      } else if (new_size < s->capacity() + min_growth) {
+        s->reserve(s->capacity() + min_growth);
+      }
+    }
+    // This calls absl::strings_internal::StringResizeAndOverwriteImpl() because
+    // the public API absl::StringResizeAndOverwrite() verifies that the
+    // required range has been initialized. No other code should be calling
+    // absl::strings_internal::StringResizeAndOverwriteImpl(). Instead it should
+    // be implemented correctly with absl::StringResizeAndOverwrite().
+    absl::strings_internal::StringResizeAndOverwriteImpl(
+        *s, new_size, [](typename string_type::value_type*, size_t buf_size) {
+          // TODO: b/446221957 - It is undefined behavior if any character in
+          // the range [0, return_value) is uninitialized, but we rely on this
+          // here to implement the old STLStringResizeUninitializedAmortized()
+          // API.
+          return buf_size;
+        });
   } else {
     s->erase(new_size);
   }

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

@@ -14,106 +14,81 @@
 
 #include "absl/strings/internal/resize_uninitialized.h"
 
+#include <cstddef>
+#include <limits>
+
 #include "gtest/gtest.h"
 
 namespace {
 
 int resize_call_count = 0;
-int append_call_count = 0;
 
 // A mock string class whose only purpose is to track how many times its
-// resize()/append() methods have been called.
+// resize() method has been called.
 struct resizable_string {
   using value_type = char;
+  using size_type = size_t;
   size_t size() const { return 0; }
   size_t capacity() const { return 0; }
-  char& operator[](size_t) {
-    static char c = '\0';
-    return c;
-  }
+  char* data() { return buffer; }
+  char& operator[](size_t) { return buffer[0]; }
   void resize(size_t) { resize_call_count += 1; }
-  void append(size_t, value_type) { append_call_count += 1; }
   void reserve(size_t) {}
   resizable_string& erase(size_t = 0, size_t = 0) { return *this; }
+  size_t max_size() const { return std::numeric_limits<size_t>::max(); }
+  char buffer[1] = {};
 };
 
 int resize_default_init_call_count = 0;
-int append_default_init_call_count = 0;
 
 // A mock string class whose only purpose is to track how many times its
-// resize()/__resize_default_init()/append()/__append_default_init() methods
-// have been called.
+// resize()/__resize_default_init() methods have been called.
 struct default_init_string {
+  using value_type = char;
+  using size_type = size_t;
   size_t size() const { return 0; }
   size_t capacity() const { return 0; }
-  char& operator[](size_t) {
-    static char c = '\0';
-    return c;
-  }
+  char* data() { return buffer; }
+  char& operator[](size_t) { return buffer[0]; }
   void resize(size_t) { resize_call_count += 1; }
   void __resize_default_init(size_t) { resize_default_init_call_count += 1; }
-  void __append_default_init(size_t) { append_default_init_call_count += 1; }
   void reserve(size_t) {}
   default_init_string& erase(size_t = 0, size_t = 0) { return *this; }
+  size_t max_size() const { return std::numeric_limits<size_t>::max(); }
+  char buffer[1];
 };
 
 TEST(ResizeUninit, WithAndWithout) {
   resize_call_count = 0;
-  append_call_count = 0;
   resize_default_init_call_count = 0;
-  append_default_init_call_count = 0;
   {
     resizable_string rs;
 
     EXPECT_EQ(resize_call_count, 0);
-    EXPECT_EQ(append_call_count, 0);
     EXPECT_EQ(resize_default_init_call_count, 0);
-    EXPECT_EQ(append_default_init_call_count, 0);
     EXPECT_FALSE(
         absl::strings_internal::STLStringSupportsNontrashingResize(&rs));
     EXPECT_EQ(resize_call_count, 0);
-    EXPECT_EQ(append_call_count, 0);
     EXPECT_EQ(resize_default_init_call_count, 0);
-    EXPECT_EQ(append_default_init_call_count, 0);
     absl::strings_internal::STLStringResizeUninitialized(&rs, 237);
     EXPECT_EQ(resize_call_count, 1);
-    EXPECT_EQ(append_call_count, 0);
     EXPECT_EQ(resize_default_init_call_count, 0);
-    EXPECT_EQ(append_default_init_call_count, 0);
-    absl::strings_internal::STLStringResizeUninitializedAmortized(&rs, 1000);
-    EXPECT_EQ(resize_call_count, 1);
-    EXPECT_EQ(append_call_count, 1);
-    EXPECT_EQ(resize_default_init_call_count, 0);
-    EXPECT_EQ(append_default_init_call_count, 0);
   }
 
   resize_call_count = 0;
-  append_call_count = 0;
   resize_default_init_call_count = 0;
-  append_default_init_call_count = 0;
   {
     default_init_string rus;
 
     EXPECT_EQ(resize_call_count, 0);
-    EXPECT_EQ(append_call_count, 0);
     EXPECT_EQ(resize_default_init_call_count, 0);
-    EXPECT_EQ(append_default_init_call_count, 0);
     EXPECT_TRUE(
         absl::strings_internal::STLStringSupportsNontrashingResize(&rus));
     EXPECT_EQ(resize_call_count, 0);
-    EXPECT_EQ(append_call_count, 0);
     EXPECT_EQ(resize_default_init_call_count, 0);
-    EXPECT_EQ(append_default_init_call_count, 0);
     absl::strings_internal::STLStringResizeUninitialized(&rus, 237);
     EXPECT_EQ(resize_call_count, 0);
-    EXPECT_EQ(append_call_count, 0);
-    EXPECT_EQ(resize_default_init_call_count, 1);
-    EXPECT_EQ(append_default_init_call_count, 0);
-    absl::strings_internal::STLStringResizeUninitializedAmortized(&rus, 1000);
-    EXPECT_EQ(resize_call_count, 0);
-    EXPECT_EQ(append_call_count, 0);
     EXPECT_EQ(resize_default_init_call_count, 1);
-    EXPECT_EQ(append_default_init_call_count, 1);
   }
 }