re2 1.24.0 → 1.25.0

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

@@ -390,7 +390,7 @@ struct SkipWhitespace {
 template <typename T>
 using EnableSplitIfString =
     typename std::enable_if<std::is_same<T, std::string>::value ||
-                            std::is_same<T, const std::string>::value,
+                                std::is_same<T, const std::string>::value,
                             int>::type;
 
 //------------------------------------------------------------------------------
@@ -399,11 +399,16 @@ using EnableSplitIfString =
 
 // StrSplit()
 //
-// Splits a given string based on the provided `Delimiter` object, returning the
-// elements within the type specified by the caller. Optionally, you may pass a
-// `Predicate` to `StrSplit()` indicating whether to include or exclude the
-// resulting element within the final result set. (See the overviews for
-// Delimiters and Predicates above.)
+// Splits a string into a sequence of substrings identified by `Delimiter`. The
+// input is processed sequentially from beginning to end, and each resulting
+// substring is filtered by an optional `Predicate` before inclusion in the
+// result set. `StrSplit()` returns a lazy range that preserves the substrings
+// original order and is convertible to the collection type specified by the
+// caller.
+//
+// Optionally, you may pass a `Predicate` to `StrSplit()` indicating whether to
+// include or exclude the resulting element within the final result set. (See
+// the overviews for Delimiters and Predicates above.)
 //
 // Example:
 //

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

@@ -36,6 +36,7 @@
 #include "absl/container/btree_set.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/node_hash_map.h"
+#include "absl/hash/hash.h"
 #include "absl/strings/string_view.h"
 
 namespace {
@@ -422,6 +423,9 @@ TEST(Splitter, ConversionOperator) {
   TestConversionOperator<absl::btree_multiset<absl::string_view>>(splitter);
   TestConversionOperator<absl::btree_multiset<std::string>>(splitter);
   TestConversionOperator<std::unordered_set<std::string>>(splitter);
+  TestConversionOperator<
+      std::unordered_set<absl::string_view, absl::Hash<absl::string_view>>>(
+      splitter);
 
   // Tests conversion to map-like objects.
 
@@ -455,6 +459,15 @@ TEST(Splitter, ConversionOperator) {
       splitter);
   TestMapConversionOperator<std::unordered_map<std::string, std::string>>(
       splitter);
+  TestMapConversionOperator<std::unordered_map<
+      absl::string_view, absl::string_view, absl::Hash<absl::string_view>>>(
+      splitter);
+  TestMapConversionOperator<std::unordered_map<absl::string_view, std::string,
+                                               absl::Hash<absl::string_view>>>(
+      splitter);
+  TestMapConversionOperator<std::unordered_map<std::string, absl::string_view,
+                                               absl::Hash<absl::string_view>>>(
+      splitter);
   TestMapConversionOperator<
       absl::node_hash_map<absl::string_view, absl::string_view>>(splitter);
   TestMapConversionOperator<

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

@@ -123,9 +123,9 @@ class Arg {
   // probably using them as 8-bit integers and would probably prefer an integer
   // representation. However, we can't really know, so we make the caller decide
   // what to do.
-  Arg(char value)  // NOLINT(google-explicit-constructor)
-      : piece_(scratch_, 1) {
+  Arg(char value) {  // NOLINT(google-explicit-constructor)
     scratch_[0] = value;
+    piece_ = absl::string_view(scratch_, 1);
   }
   Arg(short value)  // NOLINT(*)
       : piece_(scratch_,

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

@@ -65,6 +65,7 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
+        "//absl:friends",
     ],
     deps = [
         "//absl/base",
@@ -295,6 +296,7 @@ cc_library(
     copts = ABSL_TEST_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
+        "//absl:friends",
     ],
     deps = [
         ":synchronization",
@@ -343,6 +345,7 @@ cc_library(
     copts = ABSL_TEST_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
+        "//absl:friends",
     ],
     deps = [
         ":synchronization",

package/vendor/abseil-cpp/absl/synchronization/internal/create_thread_identity.cc

@@ -77,6 +77,16 @@ void OneTimeInitThreadIdentity(base_internal::ThreadIdentity* identity) {
   identity->ticker.store(0, std::memory_order_relaxed);
   identity->wait_start.store(0, std::memory_order_relaxed);
   identity->is_idle.store(false, std::memory_order_relaxed);
+  // To avoid a circular dependency we declare only the storage in the header
+  // and use placement new to construct the SpinLock.
+  static_assert(
+      sizeof(base_internal::ThreadIdentity::SchedulerState::
+                 association_lock_word) == sizeof(base_internal::SpinLock),
+      "Wrong size for SpinLock");
+  // Protects the association between this identity and its schedulable.  Should
+  // never be cooperative.
+  new (&identity->scheduler_state.association_lock_word)
+      base_internal::SpinLock(base_internal::SCHEDULE_KERNEL_ONLY);
 }
 
 static void ResetThreadIdentityBetweenReuse(
@@ -96,6 +106,17 @@ static void ResetThreadIdentityBetweenReuse(
   pts->wake = false;
   pts->cond_waiter = false;
   pts->all_locks = nullptr;
+  base_internal::ThreadIdentity::SchedulerState* ss =
+      &identity->scheduler_state;
+  ss->bound_schedulable.store(nullptr, std::memory_order_relaxed);
+  ss->association_lock_word = 0;
+  ss->scheduling_disabled_depth.store(0, std::memory_order_relaxed);
+  ss->potentially_blocking_depth = 0;
+  ss->schedule_next_state = 0;
+  ss->waking_designated_waker = false;
+  identity->static_initialization_depth = 0;
+  identity->wait_state.store(base_internal::ThreadIdentity::WaitState::kActive,
+                             std::memory_order_relaxed);
   identity->blocked_count_ptr = nullptr;
   identity->ticker.store(0, std::memory_order_relaxed);
   identity->wait_start.store(0, std::memory_order_relaxed);

package/vendor/abseil-cpp/absl/synchronization/internal/per_thread_sem.h

@@ -31,6 +31,10 @@
 #include "absl/synchronization/internal/create_thread_identity.h"
 #include "absl/synchronization/internal/kernel_timeout.h"
 
+namespace gloop_do_not_use {
+struct SynchronizationBenchmarkPeer;
+}  // namespace gloop_do_not_use
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
@@ -77,6 +81,7 @@ class PerThreadSem {
   // Permitted callers.
   friend class PerThreadSemTest;
   friend class absl::Mutex;
+  friend struct ::gloop_do_not_use::SynchronizationBenchmarkPeer;
   friend void OneTimeInitThreadIdentity(absl::base_internal::ThreadIdentity*);
 };
 

package/vendor/abseil-cpp/absl/synchronization/mutex.cc

@@ -2139,6 +2139,8 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams* waitp) {
   intptr_t wr_wait = 0;  // set to kMuWrWait if we wake a reader and a
                          // later writer could have acquired the lock
                          // (starvation avoidance)
+  // When non-null, clear its "woken_has_waiters" field before returning.
+  absl::base_internal::ThreadIdentity* clear_waking_des_waker = nullptr;
   ABSL_RAW_CHECK(waitp == nullptr || waitp->thread->waitp == nullptr ||
                      waitp->thread->suppress_fatal_errors,
                  "detected illegal recursion into Mutex code");
@@ -2382,6 +2384,13 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams* waitp) {
         h->readers = 0;
         h->maybe_unlocking = false;  // finished unlocking
         nv |= wr_wait | kMuWait | reinterpret_cast<intptr_t>(h);
+
+        // Signal to any Scheduler that we are waking from Mutex Unlock
+        // and there are more waiters left, signaling possible contention.
+        ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
+        clear_waking_des_waker = GetOrCreateCurrentThreadIdentity();
+        ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
+        clear_waking_des_waker->scheduler_state.waking_designated_waker = true;
       }
 
       // release both spinlock & lock
@@ -2417,6 +2426,10 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams* waitp) {
       ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
     }
   }
+
+  if (clear_waking_des_waker) {
+    clear_waking_des_waker->scheduler_state.waking_designated_waker = false;
+  }
 }
 
 // Used by CondVar implementation to reacquire mutex after waking from

package/vendor/abseil-cpp/absl/synchronization/mutex.h

@@ -61,6 +61,7 @@
 #include <atomic>
 #include <cstdint>
 #include <cstring>
+#include <type_traits>
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
@@ -81,6 +82,18 @@ ABSL_NAMESPACE_BEGIN
 class Condition;
 struct SynchWaitParams;
 
+namespace synchronization_internal {
+
+template <typename T, typename = void>
+struct HasConstMemberCallOperator : std::false_type {};
+
+template <typename T>
+struct HasConstMemberCallOperator<
+    T, std::void_t<decltype(static_cast<bool (T::*)() const>(&T::operator()))>>
+    : std::true_type {};
+
+}  // namespace synchronization_internal
+
 // -----------------------------------------------------------------------------
 // Mutex
 // -----------------------------------------------------------------------------
@@ -866,11 +879,23 @@ class Condition {
   // Implementation note: The second template parameter ensures that this
   // constructor doesn't participate in overload resolution if T doesn't have
   // `bool operator() const`.
-  template <typename T, typename E = decltype(static_cast<bool (T::*)() const>(
-                            &T::operator()))>
+  template <typename T,
+            std::enable_if_t<
+                synchronization_internal::HasConstMemberCallOperator<T>::value,
+                int> = 0>
   explicit Condition(const T* absl_nonnull obj)
       : Condition(obj, static_cast<bool (T::*)() const>(&T::operator())) {}
 
+  // Constructor for functors that do not match the `bool operator()() const`
+  // signature, such as those using C++23 "deducing this" or static operator().
+  template <
+      typename T,
+      typename = std::enable_if_t<
+          !synchronization_internal::HasConstMemberCallOperator<T>::value &&
+          sizeof(static_cast<bool (*)(const T&)>(&T::operator())) != 0>>
+  explicit Condition(const T* absl_nonnull obj)
+      : Condition(&CallByRef<T>, obj) {}
+
   // A Condition that always returns `true`.
   // kTrue is only useful in a narrow set of circumstances, mostly when
   // it's passed conditionally. For example:
@@ -932,6 +957,11 @@ class Condition {
   template <typename T, typename ConditionMethodPtr>
   static bool CastAndCallMethod(const Condition* absl_nonnull c);
 
+  template <typename T>
+  static bool CallByRef(const T* absl_nonnull self) {
+    return (*self)();
+  }
+
   // Helper methods for storing, validating, and reading callback arguments.
   template <typename T>
   inline void StoreCallback(T callback) {

package/vendor/abseil-cpp/absl/synchronization/mutex_test.cc

@@ -56,7 +56,7 @@ static constexpr bool kExtendedTest = false;
 
 std::unique_ptr<absl::synchronization_internal::ThreadPool> CreatePool(
     int threads) {
-  return absl::make_unique<absl::synchronization_internal::ThreadPool>(threads);
+  return std::make_unique<absl::synchronization_internal::ThreadPool>(threads);
 }
 
 std::unique_ptr<absl::synchronization_internal::ThreadPool>
@@ -868,7 +868,7 @@ TEST(Mutex, LockedMutexDestructionBug) ABSL_NO_THREAD_SAFETY_ANALYSIS {
   for (int i = 0; i != 10; i++) {
     // Create, lock and destroy 10 locks.
     const int kNumLocks = 10;
-    auto mu = absl::make_unique<absl::Mutex[]>(kNumLocks);
+    auto mu = std::make_unique<absl::Mutex[]>(kNumLocks);
     for (int j = 0; j != kNumLocks; j++) {
       if ((j % 2) == 0) {
         mu[j].lock();
@@ -993,6 +993,20 @@ TEST(Mutex, FunctionPointerConditionWithConstMethod) {
   EXPECT_TRUE(absl::Condition(&chapman, &Constable::WotsAllThisThen).Eval());
 }
 
+#ifdef __cpp_explicit_this_parameter
+struct TrueViaDeducingThis {
+  template <class This, class... Args>
+  bool operator()(this const This&, Args...) {
+    return true;
+  }
+};
+
+TEST(Mutex, FunctorConditionDeducingThis) {
+  TrueViaDeducingThis f;
+  EXPECT_TRUE(absl::Condition(&f).Eval());
+}
+#endif
+
 struct True {
   template <class... Args>
   bool operator()(Args...) const {
@@ -1292,7 +1306,7 @@ TEST(Mutex, DeadlockDetectorStressTest) ABSL_NO_THREAD_SAFETY_ANALYSIS {
   // If a deadlock detector keeps a full graph of lock acquisition order,
   // it will likely be too slow for this test to pass.
   const int n_locks = 1 << 17;
-  auto array_of_locks = absl::make_unique<absl::Mutex[]>(n_locks);
+  auto array_of_locks = std::make_unique<absl::Mutex[]>(n_locks);
   for (int i = 0; i < n_locks; i++) {
     int end = std::min(n_locks, i + 5);
     // acquire and then release locks i, i+1, ..., i+4

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

@@ -67,6 +67,48 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "clock_interface",
+    srcs = [
+        "clock_interface.cc",
+    ],
+    hdrs = [
+        "clock_interface.h",
+    ],
+    copts = ABSL_DEFAULT_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [
+        ":time",
+        "//absl/base:config",
+        "//absl/base:core_headers",
+        "//absl/base:no_destructor",
+        "//absl/base:nullability",
+        "//absl/base:raw_logging_internal",
+        "//absl/synchronization",
+    ],
+)
+
+cc_library(
+    name = "simulated_clock",
+    testonly = True,
+    srcs = [
+        "simulated_clock.cc",
+    ],
+    hdrs = [
+        "simulated_clock.h",
+    ],
+    copts = ABSL_DEFAULT_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [
+        ":clock_interface",
+        ":time",
+        "//absl/base:config",
+        "//absl/base:core_headers",
+        "//absl/base:nullability",
+        "//absl/synchronization",
+    ],
+)
+
 cc_library(
     name = "test_util",
     testonly = True,
@@ -110,6 +152,44 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "clock_interface_test",
+    srcs = [
+        "clock_interface_test.cc",
+    ],
+    copts = ABSL_TEST_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [
+        ":clock_interface",
+        ":time",
+        "//absl/functional:bind_front",
+        "//absl/synchronization",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "simulated_clock_test",
+    srcs = [
+        "simulated_clock_test.cc",
+    ],
+    copts = ABSL_TEST_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [
+        ":clock_interface",
+        ":simulated_clock",
+        ":time",
+        "//absl/base:core_headers",
+        "//absl/base:raw_logging_internal",
+        "//absl/functional:bind_front",
+        "//absl/random",
+        "//absl/synchronization",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)
+
 cc_test(
     name = "flag_test",
     srcs = [

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

@@ -131,6 +131,79 @@ absl_cc_test(
     GTest::gmock_main
 )
 
+absl_cc_library(
+  NAME
+    clock_interface
+  HDRS
+    "clock_interface.h"
+  SRCS
+    "clock_interface.cc"
+  COPTS
+    ${ABSL_DEFAULT_COPTS}
+  DEPS
+    absl::time
+    absl::config
+    absl::core_headers
+    absl::no_destructor
+    absl::nullability
+    absl::raw_logging_internal
+    absl::synchronization
+)
+
+absl_cc_test(
+  NAME
+    clock_interface_test
+  SRCS
+    "clock_interface_test.cc"
+  COPTS
+    ${ABSL_TEST_COPTS}
+  DEPS
+    absl::clock_interface
+    absl::time
+    absl::config
+    absl::bind_front
+    absl::synchronization
+    GTest::gmock_main
+)
+
+absl_cc_library(
+  NAME
+    simulated_clock
+  HDRS
+    "simulated_clock.h"
+  SRCS
+    "simulated_clock.cc"
+  COPTS
+    ${ABSL_DEFAULT_COPTS}
+  DEPS
+    absl::clock_interface
+    absl::time
+    absl::config
+    absl::core_headers
+    absl::nullability
+    absl::synchronization
+  TESTONLY
+)
+
+absl_cc_test(
+  NAME
+    simulated_clock_test
+  SRCS
+    "simulated_clock_test.cc"
+  COPTS
+    ${ABSL_TEST_COPTS}
+  DEPS
+    absl::clock_interface
+    absl::simulated_clock
+    absl::time
+    absl::config
+    absl::bind_front
+    absl::random_random
+    absl::raw_logging_internal
+    absl::synchronization
+    GTest::gmock_main
+)
+
 absl_cc_test(
   NAME
     flag_test

package/vendor/abseil-cpp/absl/time/clock.h

@@ -34,6 +34,9 @@ ABSL_NAMESPACE_BEGIN
 // Now()
 //
 // Returns the current time, expressed as an `absl::Time` absolute time value.
+//
+// To improve testability, consider injecting an absl::Clock and using
+// absl::Clock::TimeNow() instead.
 absl::Time Now();
 
 // GetCurrentTimeNanos()

package/vendor/abseil-cpp/absl/time/clock_interface.cc

@@ -0,0 +1,71 @@
+// Copyright 2026 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/time/clock_interface.h"
+
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/no_destructor.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace {
+
+class RealTimeClock final : public Clock {
+ private:
+#ifdef _MSC_VER
+  // Disable MSVC warning "destructor never returns, potential memory leak"
+#pragma warning(push)
+#pragma warning(disable : 4722)
+#endif
+  ~RealTimeClock() override {
+    ABSL_RAW_LOG(FATAL, "RealTimeClock should never be destroyed");
+  }
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+ public:
+  absl::Time TimeNow() override { return absl::Now(); }
+
+  void Sleep(absl::Duration d) override { absl::SleepFor(d); }
+
+  void SleepUntil(absl::Time wakeup_time) override {
+    absl::Duration d = wakeup_time - TimeNow();
+    if (d > absl::ZeroDuration()) {
+      Sleep(d);
+    }
+  }
+
+  bool AwaitWithDeadline(absl::Mutex* mu, const absl::Condition& cond,
+                         absl::Time deadline) override {
+    return mu->AwaitWithDeadline(cond, deadline);
+  }
+};
+
+}  // namespace
+
+Clock::~Clock() = default;  // go/key-method
+
+Clock& Clock::GetRealClock() {
+  static absl::NoDestructor<RealTimeClock> rtclock;
+  return *rtclock;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl

package/vendor/abseil-cpp/absl/time/clock_interface.h

@@ -0,0 +1,93 @@
+// Copyright 2026 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.
+//
+// -----------------------------------------------------------------------------
+// File: clock_interface.h
+// -----------------------------------------------------------------------------
+
+#ifndef ABSL_TIME_CLOCK_INTERFACE_H_
+#define ABSL_TIME_CLOCK_INTERFACE_H_
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/base/nullability.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/time/time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// An abstract interface representing a Clock, which is an object that can
+// tell you the current time, sleep, and wait for a condition variable.
+//
+// This interface allows decoupling code that uses time from the code that
+// creates a point in time.  You can use this to your advantage by injecting
+// Clocks into interfaces rather than having implementations call absl::Now()
+// directly.
+//
+// Implementations of this interface must be thread-safe.
+//
+// The Clock::GetRealClock() function returns a reference to the global realtime
+// clock.
+//
+// Example:
+//
+//   bool IsWeekend(Clock& clock) {
+//     absl::Time now = clock.TimeNow();
+//     // ... code to check if 'now' is a weekend.
+//   }
+//
+//   // Production code.
+//   IsWeekend(Clock::GetRealClock());
+//
+//   // Test code:
+//   MyTestClock test_clock(SATURDAY);
+//   IsWeekend(test_clock);
+//
+class Clock {
+ public:
+  // Returns a reference to the global realtime clock.
+  // The returned clock is thread-safe.
+  static Clock& GetRealClock();
+
+  virtual ~Clock();
+
+  // Returns the current time.
+  virtual absl::Time TimeNow() = 0;
+
+  // Sleeps for the specified duration.
+  virtual void Sleep(absl::Duration d) = 0;
+
+  // Sleeps until the specified time.
+  virtual void SleepUntil(absl::Time wakeup_time) = 0;
+
+  // Returns when cond is true or the deadline has passed.  Returns true iff
+  // cond holds when returning.
+  //
+  // Requires *mu to be held at least in shared mode.  It will be held when
+  // evaluating cond, and upon return, but it may be released and reacquired
+  // in the meantime.
+  //
+  // This method is similar to mu->AwaitWithDeadline() except that the
+  // latter only works with real-time deadlines.  This call works properly
+  // with simulated time if invoked on a simulated clock.
+  virtual bool AwaitWithDeadline(absl::Mutex* absl_nonnull mu,
+                                 const absl::Condition& cond,
+                                 absl::Time deadline) = 0;
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_CLOCK_INTERFACE_H_