re2 1.23.0 → 1.23.2

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

@@ -88,9 +88,20 @@ cc_library(
     hdrs = ["nullability.h"],
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [":config"],
+)
+
+cc_library(
+    name = "nullability_traits_internal",
+    hdrs = ["internal/nullability_traits.h"],
+    copts = ABSL_DEFAULT_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    visibility = [
+        "//absl:__subpackages__",
+    ],
     deps = [
         ":config",
-        ":core_headers",
+        ":nullability",
     ],
 )
 
@@ -230,7 +241,6 @@ cc_library(
     name = "base_internal",
     hdrs = [
         "internal/hide_ptr.h",
-        "internal/identity.h",
         "internal/scheduling_mode.h",
     ],
     copts = ABSL_DEFAULT_COPTS,
@@ -247,6 +257,7 @@ cc_library(
 cc_library(
     name = "base",
     srcs = [
+        "casts.cc",
         "internal/cycleclock.cc",
         "internal/spinlock.cc",
         "internal/sysinfo.cc",
@@ -286,8 +297,6 @@ cc_library(
         ":config",
         ":core_headers",
         ":cycleclock_internal",
-        ":dynamic_annotations",
-        ":log_severity",
         ":nullability",
         ":raw_logging_internal",
         ":spinlock_wait",
@@ -592,6 +601,22 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "casts_test",
+    size = "small",
+    srcs = [
+        "casts_test.cc",
+    ],
+    copts = ABSL_TEST_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [
+        ":base",
+        ":config",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)
+
 cc_test(
     name = "no_destructor_test",
     srcs = ["no_destructor_test.cc"],
@@ -625,7 +650,6 @@ cc_test(
     name = "nullability_test",
     srcs = ["nullability_test.cc"],
     deps = [
-        ":core_headers",
         ":nullability",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
@@ -642,6 +666,18 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "nullability_traits_test",
+    srcs = ["internal/nullability_traits_test.cc"],
+    deps = [
+        ":config",
+        ":nullability",
+        ":nullability_traits_internal",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)
+
 cc_test(
     name = "raw_logging_test",
     srcs = ["raw_logging_test.cc"],
@@ -927,6 +963,9 @@ cc_library(
     hdrs = ["internal/iterator_traits.h"],
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
+    visibility = [
+        "//absl:__subpackages__",
+    ],
     deps = [
         ":config",
         "//absl/meta:type_traits",

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

@@ -74,7 +74,6 @@ absl_cc_library(
     "nullability.h"
   DEPS
     absl::config
-    absl::core_headers
   COPTS
     ${ABSL_DEFAULT_COPTS}
 )
@@ -87,7 +86,6 @@ absl_cc_test(
   COPTS
     ${ABSL_TEST_COPTS}
   DEPS
-    absl::core_headers
     absl::nullability
     GTest::gtest_main
 )
@@ -104,6 +102,34 @@ absl_cc_test(
     GTest::gtest_main
 )
 
+# Internal-only target, do not depend on directly.
+absl_cc_library(
+  NAME
+    nullability_traits_internal
+  HDRS
+    "internal/nullability_traits.h"
+  COPTS
+    ${ABSL_DEFAULT_COPTS}
+  DEPS
+    absl::config
+    absl::nullability
+  PUBLIC
+)
+
+absl_cc_test(
+  NAME
+    nullability_traits_test
+  SRCS
+    "internal/nullability_traits_test.cc"
+  COPTS
+    ${ABSL_TEST_COPTS}
+  DEPS
+    absl::config
+    absl::nullability
+    absl::nullability_traits_internal
+    GTest::gtest_main
+)
+
 # Internal-only target, do not depend on directly.
 absl_cc_library(
   NAME
@@ -212,7 +238,6 @@ absl_cc_library(
     base_internal
   HDRS
     "internal/hide_ptr.h"
-    "internal/identity.h"
     "internal/scheduling_mode.h"
   COPTS
     ${ABSL_DEFAULT_COPTS}
@@ -238,6 +263,7 @@ absl_cc_library(
     "internal/unscaledcycleclock.h"
     "internal/unscaledcycleclock_config.h"
   SRCS
+    "casts.cc"
     "internal/cycleclock.cc"
     "internal/spinlock.cc"
     "internal/sysinfo.cc"
@@ -392,6 +418,19 @@ absl_cc_test(
     GTest::gtest_main
 )
 
+absl_cc_test(
+  NAME
+    casts_test
+  SRCS
+    "casts_test.cc"
+  COPTS
+    ${ABSL_TEST_COPTS}
+  DEPS
+    absl::base
+    absl::core_headers
+    GTest::gtest_main
+)
+
 absl_cc_test(
   NAME
     errno_saver_test

package/vendor/abseil-cpp/absl/base/attributes.h

@@ -580,7 +580,11 @@
 // Instructs the compiler not to use natural alignment for a tagged data
 // structure, but instead to reduce its alignment to 1.
 //
-// Therefore, DO NOT APPLY THIS ATTRIBUTE TO STRUCTS CONTAINING ATOMICS. Doing
+// Use of this attribute is HIGHLY DISCOURAGED. Taking the address of or
+// binding a reference to any unaligned member is UB, and it is very easy to
+// do so unintentionally when passing such members as function arguments.
+//
+// DO NOT APPLY THIS ATTRIBUTE TO STRUCTS CONTAINING ATOMICS. Doing
 // so can cause atomic variables to be mis-aligned and silently violate
 // atomicity on x86.
 //

package/vendor/abseil-cpp/absl/base/call_once_test.cc

@@ -39,25 +39,25 @@ bool done_blocking ABSL_GUARDED_BY(counters_mu) = false;
 
 // Function to be called from absl::call_once.  Waits for a notification.
 void WaitAndIncrement() {
-  counters_mu.Lock();
+  counters_mu.lock();
   ++call_once_invoke_count;
-  counters_mu.Unlock();
+  counters_mu.unlock();
 
   counters_mu.LockWhen(Condition(&done_blocking));
   ++call_once_finished_count;
-  counters_mu.Unlock();
+  counters_mu.unlock();
 }
 
 void ThreadBody() {
-  counters_mu.Lock();
+  counters_mu.lock();
   ++running_thread_count;
-  counters_mu.Unlock();
+  counters_mu.unlock();
 
   absl::call_once(once, WaitAndIncrement);
 
-  counters_mu.Lock();
+  counters_mu.lock();
   ++call_once_return_count;
-  counters_mu.Unlock();
+  counters_mu.unlock();
 }
 
 // Returns true if all threads are set up for the test.
@@ -89,17 +89,17 @@ TEST(CallOnceTest, ExecutionCount) {
   // Allow WaitAndIncrement to finish executing.  Once it does, the other
   // call_once waiters will be unblocked.
   done_blocking = true;
-  counters_mu.Unlock();
+  counters_mu.unlock();
 
   for (std::thread& thread : threads) {
     thread.join();
   }
 
-  counters_mu.Lock();
+  counters_mu.lock();
   EXPECT_EQ(call_once_invoke_count, 1);
   EXPECT_EQ(call_once_finished_count, 1);
   EXPECT_EQ(call_once_return_count, 10);
-  counters_mu.Unlock();
+  counters_mu.unlock();
 }
 
 }  // namespace

package/vendor/abseil-cpp/absl/base/casts.cc

@@ -0,0 +1,61 @@
+// Copyright 2025 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/casts.h"
+
+#include <cstdlib>
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+
+#ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
+#include <cxxabi.h>
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace base_internal {
+
+namespace {
+
+std::string DemangleCppString(const char* mangled) {
+  std::string out;
+  int status = 0;
+  char* demangled = nullptr;
+#ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
+  demangled = abi::__cxa_demangle(mangled, nullptr, nullptr, &status);
+#endif
+  if (status == 0 && demangled != nullptr) {
+    out.append(demangled);
+    free(demangled);
+  } else {
+    out.append(mangled);
+  }
+  return out;
+}
+
+}  // namespace
+
+void BadDownCastCrash(const char* source_type, const char* target_type) {
+  ABSL_RAW_LOG(FATAL, "down cast from %s to %s failed",
+               DemangleCppString(source_type).c_str(),
+               DemangleCppString(target_type).c_str());
+}
+
+}  // namespace base_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl

package/vendor/abseil-cpp/absl/base/casts.h

@@ -33,8 +33,11 @@
 #include <bit>  // For std::bit_cast.
 #endif  // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
 
-#include "absl/base/internal/identity.h"
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
 #include "absl/base/macros.h"
+#include "absl/base/optimization.h"
+#include "absl/base/options.h"
 #include "absl/meta/type_traits.h"
 
 namespace absl {
@@ -90,9 +93,26 @@ ABSL_NAMESPACE_BEGIN
 //
 // Such implicit cast chaining may be useful within template logic.
 template <typename To>
-constexpr To implicit_cast(typename absl::internal::type_identity_t<To> to) {
+constexpr std::enable_if_t<
+    !type_traits_internal::IsView<std::enable_if_t<
+        !std::is_reference_v<To>, std::remove_cv_t<To>>>::value,
+    To>
+implicit_cast(absl::type_identity_t<To> to) {
   return to;
 }
+template <typename To>
+constexpr std::enable_if_t<
+    type_traits_internal::IsView<std::enable_if_t<!std::is_reference_v<To>,
+                                                  std::remove_cv_t<To>>>::value,
+    To>
+implicit_cast(absl::type_identity_t<To> to ABSL_ATTRIBUTE_LIFETIME_BOUND) {
+  return to;
+}
+template <typename To>
+constexpr std::enable_if_t<std::is_reference_v<To>, To> implicit_cast(
+    absl::type_identity_t<To> to ABSL_ATTRIBUTE_LIFETIME_BOUND) {
+  return std::forward<absl::type_identity_t<To>>(to);
+}
 
 // bit_cast()
 //
@@ -174,6 +194,112 @@ inline Dest bit_cast(const Source& source) {
 
 #endif  // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
 
+namespace base_internal {
+
+[[noreturn]] ABSL_ATTRIBUTE_NOINLINE void BadDownCastCrash(
+    const char* source_type, const char* target_type);
+
+template <typename To, typename From>
+inline void ValidateDownCast(From* f ABSL_ATTRIBUTE_UNUSED) {
+  // Assert only if RTTI is enabled and in debug mode or hardened asserts are
+  // enabled.
+#ifdef ABSL_INTERNAL_HAS_RTTI
+#if !defined(NDEBUG) || (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2)
+  // Suppress erroneous nonnull comparison warning on older GCC.
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnonnull-compare"
+#endif
+  if (ABSL_PREDICT_FALSE(f != nullptr && dynamic_cast<To>(f) == nullptr)) {
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+    absl::base_internal::BadDownCastCrash(
+        typeid(*f).name(), typeid(std::remove_pointer_t<To>).name());
+  }
+#endif
+#endif
+}
+
+}  // namespace base_internal
+
+// An "upcast", i.e. a conversion from a pointer to an object to a pointer to a
+// base subobject, always succeeds if the base is unambiguous and accessible,
+// and so it's fine to use implicit_cast.
+//
+// A "downcast", i.e. a conversion from a pointer to an object to a pointer
+// to a more-derived object that may contain the original object as a base
+// subobject, cannot safely be done using static_cast, because you do not
+// generally know whether the source object is really the base subobject of
+// a containing, more-derived object of the target type. Thus, when you
+// downcast in a polymorphic type hierarchy, you should use the following
+// function template.
+//
+// This function only returns null when the input is null. In debug mode, we
+// use dynamic_cast to double-check whether the downcast is legal (we die if
+// it's not). In normal mode, we do the efficient static_cast instead. Because
+// the process will die in debug mode, it's important to test to make sure the
+// cast is legal before calling this function!
+//
+// dynamic_cast should be avoided except as allowed by the style guide
+// (https://google.github.io/styleguide/cppguide.html#Run-Time_Type_Information__RTTI_).
+
+template <typename To, typename From>  // use like this: down_cast<T*>(foo);
+[[nodiscard]]
+inline To down_cast(From* f) {  // so we only accept pointers
+  static_assert(std::is_pointer<To>::value, "target type not a pointer");
+  // dynamic_cast allows casting to the same type or a more cv-qualified
+  // version of the same type without them being polymorphic.
+  if constexpr (!std::is_same<std::remove_cv_t<std::remove_pointer_t<To>>,
+                              std::remove_cv_t<From>>::value) {
+    static_assert(std::is_polymorphic<From>::value,
+                  "source type must be polymorphic");
+    static_assert(std::is_polymorphic<std::remove_pointer_t<To>>::value,
+                  "target type must be polymorphic");
+  }
+  static_assert(
+      std::is_convertible<std::remove_cv_t<std::remove_pointer_t<To>>*,
+                          std::remove_cv_t<From>*>::value,
+      "target type not derived from source type");
+
+  absl::base_internal::ValidateDownCast<To>(f);
+
+  return static_cast<To>(f);
+}
+
+// Overload of down_cast for references. Use like this:
+// absl::down_cast<T&>(foo). The code is slightly convoluted because we're still
+// using the pointer form of dynamic cast. (The reference form throws an
+// exception if it fails.)
+//
+// There's no need for a special const overload either for the pointer
+// or the reference form. If you call down_cast with a const T&, the
+// compiler will just bind From to const T.
+template <typename To, typename From>
+[[nodiscard]]
+inline To down_cast(From& f) {
+  static_assert(std::is_lvalue_reference<To>::value,
+                "target type not a reference");
+  // dynamic_cast allows casting to the same type or a more cv-qualified
+  // version of the same type without them being polymorphic.
+  if constexpr (!std::is_same<std::remove_cv_t<std::remove_reference_t<To>>,
+                              std::remove_cv_t<From>>::value) {
+    static_assert(std::is_polymorphic<From>::value,
+                  "source type must be polymorphic");
+    static_assert(std::is_polymorphic<std::remove_reference_t<To>>::value,
+                  "target type must be polymorphic");
+  }
+  static_assert(
+      std::is_convertible<std::remove_cv_t<std::remove_reference_t<To>>*,
+                          std::remove_cv_t<From>*>::value,
+      "target type not derived from source type");
+
+  absl::base_internal::ValidateDownCast<std::remove_reference_t<To>*>(
+      std::addressof(f));
+
+  return static_cast<To>(f);
+}
+
 ABSL_NAMESPACE_END
 }  // namespace absl
 

package/vendor/abseil-cpp/absl/base/casts_test.cc

@@ -0,0 +1,151 @@
+// Copyright 2025 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/casts.h"
+
+#include <type_traits>
+#include <utility>
+
+#include "gtest/gtest.h"
+#include "absl/base/options.h"
+
+namespace {
+
+struct BaseForImplicitCast {
+  explicit BaseForImplicitCast(int value) : x(value) {}
+  BaseForImplicitCast(const BaseForImplicitCast& other) = delete;
+  BaseForImplicitCast& operator=(const BaseForImplicitCast& other) = delete;
+  int x;
+};
+struct DerivedForImplicitCast : BaseForImplicitCast {
+  explicit DerivedForImplicitCast(int value) : BaseForImplicitCast(value) {}
+};
+
+static_assert(std::is_same_v<decltype(absl::implicit_cast<BaseForImplicitCast&>(
+                                 std::declval<DerivedForImplicitCast&>())),
+                             BaseForImplicitCast&>);
+static_assert(
+    std::is_same_v<decltype(absl::implicit_cast<const BaseForImplicitCast&>(
+                       std::declval<DerivedForImplicitCast>())),
+                   const BaseForImplicitCast&>);
+
+TEST(ImplicitCastTest, LValueReference) {
+  DerivedForImplicitCast derived(5);
+  EXPECT_EQ(&absl::implicit_cast<BaseForImplicitCast&>(derived), &derived);
+  EXPECT_EQ(&absl::implicit_cast<const BaseForImplicitCast&>(derived),
+            &derived);
+}
+
+TEST(ImplicitCastTest, RValueReference) {
+  DerivedForImplicitCast derived(5);
+  BaseForImplicitCast&& base =
+      absl::implicit_cast<BaseForImplicitCast&&>(std::move(derived));
+  EXPECT_EQ(&base, &derived);
+
+  const DerivedForImplicitCast cderived(6);
+  const BaseForImplicitCast&& cbase =
+      absl::implicit_cast<const BaseForImplicitCast&&>(std::move(cderived));
+  EXPECT_EQ(&cbase, &cderived);
+}
+
+class BaseForDownCast {
+ public:
+  virtual ~BaseForDownCast() = default;
+};
+
+class DerivedForDownCast : public BaseForDownCast {};
+class Derived2ForDownCast : public BaseForDownCast {};
+
+TEST(DownCastTest, Pointer) {
+  DerivedForDownCast derived;
+  BaseForDownCast* const base_ptr = &derived;
+
+  // Tests casting a BaseForDownCast* to a DerivedForDownCast*.
+  EXPECT_EQ(&derived, absl::down_cast<DerivedForDownCast*>(base_ptr));
+
+  // Tests casting a const BaseForDownCast* to a const DerivedForDownCast*.
+  const BaseForDownCast* const_base_ptr = base_ptr;
+  EXPECT_EQ(&derived,
+            absl::down_cast<const DerivedForDownCast*>(const_base_ptr));
+
+  // Tests casting a BaseForDownCast* to a const DerivedForDownCast*.
+  EXPECT_EQ(&derived, absl::down_cast<const DerivedForDownCast*>(base_ptr));
+
+  // Tests casting a BaseForDownCast* to a BaseForDownCast* (an identity cast).
+  EXPECT_EQ(base_ptr, absl::down_cast<BaseForDownCast*>(base_ptr));
+
+  // Tests down casting NULL.
+  EXPECT_EQ(nullptr,
+            (absl::down_cast<DerivedForDownCast*, BaseForDownCast>(nullptr)));
+
+  // Tests a bad downcast. We have to disguise the badness just enough
+  // that the compiler doesn't warn about it at compile time.
+  BaseForDownCast* base2 = new BaseForDownCast();
+#if GTEST_HAS_DEATH_TEST && (!defined(NDEBUG) || (ABSL_OPTION_HARDENED == 1 || \
+                                                  ABSL_OPTION_HARDENED == 2))
+  EXPECT_DEATH(static_cast<void>(absl::down_cast<DerivedForDownCast*>(base2)),
+               ".*down cast from .*BaseForDownCast.* to "
+               ".*DerivedForDownCast.* failed.*");
+#endif
+  delete base2;
+}
+
+TEST(DownCastTest, Reference) {
+  DerivedForDownCast derived;
+  BaseForDownCast& base_ref = derived;
+
+  // Tests casting a BaseForDownCast& to a DerivedForDownCast&.
+  // NOLINTNEXTLINE(runtime/casting)
+  EXPECT_EQ(&derived, &absl::down_cast<DerivedForDownCast&>(base_ref));
+
+  // Tests casting a const BaseForDownCast& to a const DerivedForDownCast&.
+  const BaseForDownCast& const_base_ref = base_ref;
+  // NOLINTNEXTLINE(runtime/casting)
+  EXPECT_EQ(&derived,
+            &absl::down_cast<const DerivedForDownCast&>(const_base_ref));
+
+  // Tests casting a BaseForDownCast& to a const DerivedForDownCast&.
+  // NOLINTNEXTLINE(runtime/casting)
+  EXPECT_EQ(&derived, &absl::down_cast<const DerivedForDownCast&>(base_ref));
+
+  // Tests casting a BaseForDownCast& to a BaseForDownCast& (an identity cast).
+  // NOLINTNEXTLINE(runtime/casting)
+  EXPECT_EQ(&base_ref, &absl::down_cast<BaseForDownCast&>(base_ref));
+
+  // Tests a bad downcast. We have to disguise the badness just enough
+  // that the compiler doesn't warn about it at compile time.
+  BaseForDownCast& base2 = *new BaseForDownCast();
+#if GTEST_HAS_DEATH_TEST && (!defined(NDEBUG) || (ABSL_OPTION_HARDENED == 1 || \
+                                                  ABSL_OPTION_HARDENED == 2))
+  EXPECT_DEATH(static_cast<void>(absl::down_cast<DerivedForDownCast&>(base2)),
+               ".*down cast from .*BaseForDownCast.* to "
+               ".*DerivedForDownCast.* failed.*");
+#endif
+  delete &base2;
+}
+
+TEST(DownCastTest, ErrorMessage) {
+  DerivedForDownCast derived;
+  BaseForDownCast& base = derived;
+  (void)base;
+
+#if GTEST_HAS_DEATH_TEST && (!defined(NDEBUG) || (ABSL_OPTION_HARDENED == 1 || \
+                                                  ABSL_OPTION_HARDENED == 2))
+  EXPECT_DEATH(static_cast<void>(absl::down_cast<Derived2ForDownCast&>(base)),
+               ".*down cast from .*DerivedForDownCast.* to "
+               ".*Derived2ForDownCast.* failed.*");
+#endif
+}
+
+}  // namespace