re2 1.23.0 → 1.23.2

package/vendor/abseil-cpp/absl/debugging/stacktrace_test.cc

@@ -27,6 +27,7 @@
 #include "gtest/gtest.h"
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
+#include "absl/base/internal/errno_saver.h"
 #include "absl/base/optimization.h"
 #include "absl/types/span.h"
 
@@ -93,15 +94,23 @@ TEST(StackTrace, HugeFrame) {
 // This is a separate function to avoid inlining.
 ABSL_ATTRIBUTE_NOINLINE static void FixupNoFixupEquivalenceNoInline() {
 #if !ABSL_HAVE_ATTRIBUTE_WEAK
-  GTEST_SKIP() << "Need weak symbol support";
-#endif
-#if defined(__riscv)
-  GTEST_SKIP() << "Skipping test on RISC-V due to pre-existing failure";
-#endif
-#if defined(_WIN32)
+  const char* kSkipReason = "Need weak symbol support";
+#elif defined(__riscv)
+  const char* kSkipReason =
+      "Skipping test on RISC-V due to pre-existing failure";
+#elif defined(_WIN32)
   // TODO(b/434184677): Add support for fixups on Windows if needed
-  GTEST_SKIP() << "Skipping test on Windows due to lack of support for fixups";
+  const char* kSkipReason =
+      "Skipping test on Windows due to lack of support for fixups";
+#else
+  const char* kSkipReason = nullptr;
 #endif
+
+  // This conditional is to avoid an unreachable code warning.
+  if (kSkipReason != nullptr) {
+    GTEST_SKIP() << kSkipReason;
+  }
+
   bool can_rely_on_frame_pointers = false;
   if (!can_rely_on_frame_pointers) {
     GTEST_SKIP() << "Frame pointers are required, but not guaranteed in OSS";
@@ -232,13 +241,20 @@ TEST(StackTrace, FixupNoFixupEquivalence) { FixupNoFixupEquivalenceNoInline(); }
 
 TEST(StackTrace, FixupLowStackUsage) {
 #if !ABSL_HAVE_ATTRIBUTE_WEAK
-  GTEST_SKIP() << "Skipping test on MSVC due to weak symbols";
-#endif
-#if defined(_WIN32)
+  const char* kSkipReason = "Skipping test on MSVC due to weak symbols";
+#elif defined(_WIN32)
   // TODO(b/434184677): Add support for fixups on Windows if needed
-  GTEST_SKIP() << "Skipping test on Windows due to lack of support for fixups";
+  const char* kSkipReason =
+      "Skipping test on Windows due to lack of support for fixups";
+#else
+  const char* kSkipReason = nullptr;
 #endif
 
+  // This conditional is to avoid an unreachable code warning.
+  if (kSkipReason != nullptr) {
+    GTEST_SKIP() << kSkipReason;
+  }
+
   const Cleanup restore_state([enable_fixup = g_enable_fixup,
                                fixup_calls = g_fixup_calls,
                                should_fixup_calls = g_should_fixup_calls]() {
@@ -275,13 +291,20 @@ TEST(StackTrace, FixupLowStackUsage) {
 
 TEST(StackTrace, CustomUnwinderPerformsFixup) {
 #if !ABSL_HAVE_ATTRIBUTE_WEAK
-  GTEST_SKIP() << "Need weak symbol support";
-#endif
-#if defined(_WIN32)
+  const char* kSkipReason = "Need weak symbol support";
+#elif defined(_WIN32)
   // TODO(b/434184677): Add support for fixups on Windows if needed
-  GTEST_SKIP() << "Skipping test on Windows due to lack of support for fixups";
+  const char* kSkipReason =
+      "Skipping test on Windows due to lack of support for fixups";
+#else
+  const char* kSkipReason = nullptr;
 #endif
 
+  // This conditional is to avoid an unreachable code warning.
+  if (kSkipReason != nullptr) {
+    GTEST_SKIP() << kSkipReason;
+  }
+
   constexpr int kSkip = 1;  // Skip our own frame, whose return PCs won't match
   constexpr auto kStackCount = 1;
 
@@ -414,6 +437,7 @@ const void* g_return_address = nullptr;
 bool g_sigusr2_raised = false;
 
 void SigUsr2Handler(int, siginfo_t*, void* uc) {
+  absl::base_internal::ErrnoSaver errno_saver;
   // Many platforms don't support this by default.
   bool support_is_expected = false;
   constexpr int kMaxStackDepth = 64;

package/vendor/abseil-cpp/absl/debugging/symbolize_emscripten.inc

@@ -26,33 +26,20 @@
 
 extern "C" {
 const char* emscripten_pc_get_function(const void* pc);
+void* emscripten_stack_snapshot();
 }
 
-// clang-format off
-EM_JS(bool, HaveOffsetConverter, (),
-      { return typeof wasmOffsetConverter !== 'undefined'; });
-// clang-format on
-
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
-void InitializeSymbolizer(const char*) {
-  if (!HaveOffsetConverter()) {
-    ABSL_RAW_LOG(INFO,
-                 "Symbolization unavailable. Rebuild with -sWASM=1 "
-                 "and -sUSE_OFFSET_CONVERTER=1.");
-  }
-}
+void InitializeSymbolizer(const char*) {}
 
 bool Symbolize(const void* pc, char* out, int out_size) {
-  // Check if we have the offset converter necessary for pc_get_function.
-  // Without it, the program will abort().
-  if (!HaveOffsetConverter()) {
-    return false;
-  }
   if (pc == nullptr || out_size <= 0) {
     return false;
   }
+  // Need to capture a snapshot first.
+  emscripten_stack_snapshot();
   const char* func_name = emscripten_pc_get_function(pc);
   if (func_name == nullptr) {
     return false;

package/vendor/abseil-cpp/absl/debugging/symbolize_test.cc

@@ -107,8 +107,6 @@ static ABSL_PER_THREAD_TLS_KEYWORD char
 #endif
 
 #if !defined(__EMSCRIPTEN__)
-static void *GetPCFromFnPtr(void *ptr) { return ptr; }
-
 // Used below to hopefully inhibit some compiler/linker optimizations
 // that may remove kHpageTextPadding, kPadding0, and kPadding1 from
 // the binary.
@@ -119,12 +117,6 @@ static constexpr size_t kHpageSize = 1 << 21;
 const char kHpageTextPadding[kHpageSize * 4] ABSL_ATTRIBUTE_SECTION_VARIABLE(
         .text) = "";
 
-#else
-static void *GetPCFromFnPtr(void *ptr) {
-  return EM_ASM_PTR(
-      { return wasmOffsetConverter.convert(wasmTable.get($0).name, 0); }, ptr);
-}
-
 #endif  // !defined(__EMSCRIPTEN__)
 
 static char try_symbolize_buffer[4096];
@@ -174,12 +166,10 @@ void ABSL_ATTRIBUTE_NOINLINE TestWithReturnAddress() {
 
 TEST(Symbolize, Cached) {
   // Compilers should give us pointers to them.
-  EXPECT_STREQ("nonstatic_func",
-               TrySymbolize(GetPCFromFnPtr((void *)(&nonstatic_func))));
+  EXPECT_STREQ("nonstatic_func", TrySymbolize((void*)(&nonstatic_func)));
   // The name of an internal linkage symbol is not specified; allow either a
   // mangled or an unmangled name here.
-  const char *static_func_symbol =
-      TrySymbolize(GetPCFromFnPtr((void *)(&static_func)));
+  const char* static_func_symbol = TrySymbolize((void*)(&static_func));
   EXPECT_TRUE(strcmp("static_func", static_func_symbol) == 0 ||
               strcmp("static_func()", static_func_symbol) == 0);
 
@@ -189,50 +179,38 @@ TEST(Symbolize, Cached) {
 TEST(Symbolize, Truncation) {
   constexpr char kNonStaticFunc[] = "nonstatic_func";
   EXPECT_STREQ("nonstatic_func",
-               TrySymbolizeWithLimit(GetPCFromFnPtr((void *)(&nonstatic_func)),
+               TrySymbolizeWithLimit((void*)(&nonstatic_func),
                                      strlen(kNonStaticFunc) + 1));
   EXPECT_STREQ("nonstatic_...",
-               TrySymbolizeWithLimit(GetPCFromFnPtr((void *)(&nonstatic_func)),
+               TrySymbolizeWithLimit((void*)(&nonstatic_func),
                                      strlen(kNonStaticFunc) + 0));
   EXPECT_STREQ("nonstatic...",
-               TrySymbolizeWithLimit(GetPCFromFnPtr((void *)(&nonstatic_func)),
+               TrySymbolizeWithLimit((void*)(&nonstatic_func),
                                      strlen(kNonStaticFunc) - 1));
-  EXPECT_STREQ("n...", TrySymbolizeWithLimit(
-                           GetPCFromFnPtr((void *)(&nonstatic_func)), 5));
-  EXPECT_STREQ("...", TrySymbolizeWithLimit(
-                          GetPCFromFnPtr((void *)(&nonstatic_func)), 4));
-  EXPECT_STREQ("..", TrySymbolizeWithLimit(
-                         GetPCFromFnPtr((void *)(&nonstatic_func)), 3));
-  EXPECT_STREQ(
-      ".", TrySymbolizeWithLimit(GetPCFromFnPtr((void *)(&nonstatic_func)), 2));
-  EXPECT_STREQ(
-      "", TrySymbolizeWithLimit(GetPCFromFnPtr((void *)(&nonstatic_func)), 1));
-  EXPECT_EQ(nullptr, TrySymbolizeWithLimit(
-                         GetPCFromFnPtr((void *)(&nonstatic_func)), 0));
+  EXPECT_STREQ("n...", TrySymbolizeWithLimit((void*)(&nonstatic_func), 5));
+  EXPECT_STREQ("...", TrySymbolizeWithLimit((void*)(&nonstatic_func), 4));
+  EXPECT_STREQ("..", TrySymbolizeWithLimit((void*)(&nonstatic_func), 3));
+  EXPECT_STREQ(".", TrySymbolizeWithLimit((void*)(&nonstatic_func), 2));
+  EXPECT_STREQ("", TrySymbolizeWithLimit((void*)(&nonstatic_func), 1));
+  EXPECT_EQ(nullptr, TrySymbolizeWithLimit((void*)(&nonstatic_func), 0));
 }
 
 TEST(Symbolize, SymbolizeWithDemangling) {
   Foo::func(100);
 #ifdef __EMSCRIPTEN__
   // Emscripten's online symbolizer is more precise with arguments.
-  EXPECT_STREQ("Foo::func(int)",
-               TrySymbolize(GetPCFromFnPtr((void *)(&Foo::func))));
+  EXPECT_STREQ("Foo::func(int)", TrySymbolize((void*)(&Foo::func)));
 #else
-  EXPECT_STREQ("Foo::func()",
-               TrySymbolize(GetPCFromFnPtr((void *)(&Foo::func))));
+  EXPECT_STREQ("Foo::func()", TrySymbolize((void*)(&Foo::func)));
 #endif
 }
 
 TEST(Symbolize, SymbolizeSplitTextSections) {
-  EXPECT_STREQ("unlikely_func()",
-               TrySymbolize(GetPCFromFnPtr((void *)(&unlikely_func))));
-  EXPECT_STREQ("hot_func()", TrySymbolize(GetPCFromFnPtr((void *)(&hot_func))));
-  EXPECT_STREQ("startup_func()",
-               TrySymbolize(GetPCFromFnPtr((void *)(&startup_func))));
-  EXPECT_STREQ("exit_func()",
-               TrySymbolize(GetPCFromFnPtr((void *)(&exit_func))));
-  EXPECT_STREQ("regular_func()",
-               TrySymbolize(GetPCFromFnPtr((void *)(&regular_func))));
+  EXPECT_STREQ("unlikely_func()", TrySymbolize((void*)(&unlikely_func)));
+  EXPECT_STREQ("hot_func()", TrySymbolize((void*)(&hot_func)));
+  EXPECT_STREQ("startup_func()", TrySymbolize((void*)(&startup_func)));
+  EXPECT_STREQ("exit_func()", TrySymbolize((void*)(&exit_func)));
+  EXPECT_STREQ("regular_func()", TrySymbolize((void*)(&regular_func)));
 }
 
 // Tests that verify that Symbolize stack footprint is within some limit.
@@ -630,5 +608,12 @@ int main(int argc, char **argv) {
 #endif
 #endif
 
+#if !defined(__EMSCRIPTEN__)
+  // All of these test cases rely on symbolizing function pointers.
+  // On most platforms, function pointers directly map to PC.
+  // In WebAssembly, function pointers are indices into the function table
+  // and there is no longer a mapping from function index back into the
+  // file offset for symbolization.
   return RUN_ALL_TESTS();
+#endif  // !defined(__EMSCRIPTEN__)
 }

package/vendor/abseil-cpp/absl/debugging/symbolize_win32.inc

@@ -15,7 +15,6 @@
 // See "Retrieving Symbol Information by Address":
 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms680578(v=vs.85).aspx
 
-#include <ntstatus.h>
 #include <windows.h>
 #include <winternl.h>
 
@@ -58,10 +57,9 @@ void InitializeSymbolizer(const char*) {
     // NTSTATUS (0xC0000004), which can happen when a module load occurs during
     // the SymInitialize call. In this case, we should try calling SymInitialize
     // again.
+    constexpr DWORD kStatusInfoLengthMismatch = DWORD{0xC0000004};
     syminitialize_error = GetLastError();
-    // Both NTSTATUS and DWORD are 32-bit numbers, which makes the cast safe.
-    if (syminitialize_error !=
-        static_cast<DWORD>(STATUS_INFO_LENGTH_MISMATCH)) {
+    if (syminitialize_error != kStatusInfoLengthMismatch) {
       break;
     }
   }

package/vendor/abseil-cpp/absl/flags/BUILD.bazel

@@ -168,6 +168,7 @@ cc_library(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
         "//absl/flags:__pkg__",
+        "//absl/flags/rust:__pkg__",
     ],
     deps = [
         ":commandlineflag",

package/vendor/abseil-cpp/absl/flags/declare.h

@@ -59,10 +59,19 @@ ABSL_NAMESPACE_END
 
 // Internal implementation of ABSL_DECLARE_FLAG to allow macro expansion of its
 // arguments. Clients must use ABSL_DECLARE_FLAG instead.
+//
+// The non-MSVC implementation declares the flag twice. This is to allow
+// applying attributes to the second declaration. However, this causes a
+// compile error (C4273) in MSVC if a `__declspec` is prepended to the macro.
+#if defined(_MSC_VER)
+#define ABSL_DECLARE_FLAG_INTERNAL(type, name) \
+  extern absl::Flag<type> FLAGS_##name
+#else
 #define ABSL_DECLARE_FLAG_INTERNAL(type, name)               \
   extern absl::Flag<type> FLAGS_##name;                      \
   namespace absl /* block flags in namespaces */ {}          \
   /* second redeclaration is to allow applying attributes */ \
   extern absl::Flag<type> FLAGS_##name
+#endif  // _MSC_VER
 
 #endif  // ABSL_FLAGS_DECLARE_H_

package/vendor/abseil-cpp/absl/flags/flag.h

@@ -241,7 +241,8 @@ ABSL_NAMESPACE_END
     /* default value argument. That keeps temporaries alive */               \
     /* long enough for NonConst to work correctly.          */               \
     static constexpr absl::string_view Value(                                \
-        absl::string_view absl_flag_help = ABSL_FLAG_IMPL_FLAGHELP(txt)) {   \
+        absl::string_view absl_flag_help ABSL_ATTRIBUTE_LIFETIME_BOUND  =     \
+            ABSL_FLAG_IMPL_FLAGHELP(txt)) {                                  \
       return absl_flag_help;                                                 \
     }                                                                        \
     static std::string NonConst() { return std::string(Value()); }           \

package/vendor/abseil-cpp/absl/flags/internal/commandlineflag.h

@@ -58,7 +58,7 @@ class FlagStateInterface {
   virtual ~FlagStateInterface();
 
   // Restores the flag originated this object to the saved state.
-  virtual void Restore() const = 0;
+  virtual void Restore() && = 0;
 };
 
 }  // namespace flags_internal

package/vendor/abseil-cpp/absl/flags/internal/flag.cc

@@ -26,6 +26,7 @@
 #include <memory>
 #include <string>
 #include <typeinfo>
+#include <utility>
 #include <vector>
 
 #include "absl/base/attributes.h"
@@ -139,8 +140,8 @@ class FlagState : public flags_internal::FlagStateInterface {
   friend class FlagImpl;
 
   // Restores the flag to the saved state.
-  void Restore() const override {
-    if (!flag_impl_.RestoreState(*this)) return;
+  void Restore() && override {
+    if (!std::move(flag_impl_).RestoreState(*this)) return;
 
     ABSL_INTERNAL_LOG(INFO,
                       absl::StrCat("Restore saved value of ", flag_impl_.Name(),

package/vendor/abseil-cpp/absl/flags/marshalling.cc

@@ -45,22 +45,7 @@ namespace flags_internal {
 // AbslParseFlag specializations for boolean type.
 
 bool AbslParseFlag(absl::string_view text, bool* dst, std::string*) {
-  const char* kTrue[] = {"1", "t", "true", "y", "yes"};
-  const char* kFalse[] = {"0", "f", "false", "n", "no"};
-  static_assert(sizeof(kTrue) == sizeof(kFalse), "true_false_equal");
-
-  text = absl::StripAsciiWhitespace(text);
-
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(kTrue); ++i) {
-    if (absl::EqualsIgnoreCase(text, kTrue[i])) {
-      *dst = true;
-      return true;
-    } else if (absl::EqualsIgnoreCase(text, kFalse[i])) {
-      *dst = false;
-      return true;
-    }
-  }
-  return false;  // didn't match a legal input
+  return SimpleAtob(absl::StripAsciiWhitespace(text), dst);
 }
 
 // --------------------------------------------------------------------

package/vendor/abseil-cpp/absl/flags/parse.cc

@@ -206,8 +206,10 @@ bool ArgsList::ReadFromFlagfile(const std::string& flag_file_name) {
 
   std::string line;
   bool success = true;
+  int line_number = 0;
 
   while (std::getline(flag_file, line)) {
+    line_number++;
     absl::string_view stripped = absl::StripLeadingAsciiWhitespace(line);
 
     if (stripped.empty() || stripped[0] == '#') {
@@ -229,8 +231,8 @@ bool ArgsList::ReadFromFlagfile(const std::string& flag_file_name) {
     }
 
     flags_internal::ReportUsageError(
-        absl::StrCat("Unexpected line in the flagfile ", flag_file_name, ": ",
-                     line),
+        absl::StrCat("Unexpected line ", line_number, " in the flagfile ",
+                     flag_file_name),
         true);
 
     success = false;

package/vendor/abseil-cpp/absl/flags/parse_test.cc

@@ -827,7 +827,7 @@ TEST_F(ParseDeathTest, TestInvalidFlagfiles) {
                       flagfile_flag),
   };
   EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args5),
-               "Unexpected line in the flagfile .*: \\*bin\\*");
+               "Unexpected line 2 in the flagfile .*");
 }
 
 // --------------------------------------------------------------------

package/vendor/abseil-cpp/absl/flags/reflection.cc

@@ -19,6 +19,7 @@
 
 #include <atomic>
 #include <string>
+#include <utility>
 
 #include "absl/base/config.h"
 #include "absl/base/no_destructor.h"
@@ -320,9 +321,9 @@ class FlagSaverImpl {
   }
 
   // Restores the saved flag states into the flag registry.
-  void RestoreToRegistry() {
+  void RestoreToRegistry() && {
     for (const auto& flag_state : backup_registry_) {
-      flag_state->Restore();
+      std::move(*flag_state).Restore();
     }
   }
 
@@ -340,7 +341,7 @@ FlagSaver::FlagSaver() : impl_(new flags_internal::FlagSaverImpl) {
 FlagSaver::~FlagSaver() {
   if (!impl_) return;
 
-  impl_->RestoreToRegistry();
+  std::move(*impl_).RestoreToRegistry();
   delete impl_;
 }
 

package/vendor/abseil-cpp/absl/functional/BUILD.bazel

@@ -104,8 +104,10 @@ cc_library(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
         ":any_invocable",
+        "//absl/base:config",
         "//absl/base:core_headers",
         "//absl/meta:type_traits",
+        "//absl/utility",
     ],
 )
 
@@ -117,8 +119,10 @@ cc_test(
     deps = [
         ":any_invocable",
         ":function_ref",
+        "//absl/base:config",
         "//absl/container:test_instance_tracker",
         "//absl/memory",
+        "//absl/utility",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],

package/vendor/abseil-cpp/absl/functional/CMakeLists.txt

@@ -87,9 +87,11 @@ absl_cc_library(
   COPTS
     ${ABSL_DEFAULT_COPTS}
   DEPS
+    absl::config
     absl::core_headers
     absl::any_invocable
     absl::meta
+    absl::utility
   PUBLIC
 )
 
@@ -101,9 +103,11 @@ absl_cc_test(
   COPTS
     ${ABSL_TEST_COPTS}
   DEPS
+    absl::config
     absl::function_ref
     absl::memory
     absl::test_instance_tracker
+    absl::utility
     GTest::gmock_main
 )
 

package/vendor/abseil-cpp/absl/functional/any_invocable.h

@@ -39,6 +39,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/base/attributes.h"
 #include "absl/base/config.h"
 #include "absl/base/nullability.h"
 #include "absl/functional/internal/any_invocable.h"
@@ -159,7 +160,7 @@ ABSL_NAMESPACE_BEGIN
 //   AnyInvocable<void()> empty;
 //   empty();  // WARNING: Undefined behavior!
 template <class Sig>
-class ABSL_NULLABILITY_COMPATIBLE AnyInvocable
+class ABSL_NULLABILITY_COMPATIBLE ABSL_ATTRIBUTE_OWNER AnyInvocable
     : private internal_any_invocable::Impl<Sig> {
  private:
   static_assert(
@@ -171,6 +172,7 @@ class ABSL_NULLABILITY_COMPATIBLE AnyInvocable
  public:
   // The return type of Sig
   using result_type = typename Impl::result_type;
+  using absl_internal_is_view = std::false_type;
 
   // Constructors