re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/base/internal/iterator_traits.h

@@ -0,0 +1,71 @@
+// 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.
+//
+// -----------------------------------------------------------------------------
+// File: internal/iterator_traits.h
+// -----------------------------------------------------------------------------
+//
+// Helpers for querying traits of iterators, for implementing containers, etc.
+
+#ifndef ABSL_BASE_INTERNAL_ITERATOR_TRAITS_H_
+#define ABSL_BASE_INTERNAL_ITERATOR_TRAITS_H_
+
+#include <iterator>
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+template <typename Iterator, typename = void>
+struct IteratorCategory {};
+
+template <typename Iterator>
+struct IteratorCategory<
+    Iterator,
+    absl::void_t<typename std::iterator_traits<Iterator>::iterator_category>> {
+  using type = typename std::iterator_traits<Iterator>::iterator_category;
+};
+
+template <typename Iterator, typename = void>
+struct IteratorConceptImpl : IteratorCategory<Iterator> {};
+
+template <typename Iterator>
+struct IteratorConceptImpl<
+    Iterator,
+    absl::void_t<typename std::iterator_traits<Iterator>::iterator_concept>> {
+  using type = typename std::iterator_traits<Iterator>::iterator_concept;
+};
+
+// The newer `std::iterator_traits<Iterator>::iterator_concept` if available,
+// else `std::iterator_traits<Iterator>::iterator_category`.
+template <typename Iterator>
+using IteratorConcept = typename IteratorConceptImpl<Iterator>::type;
+
+template <typename IteratorTag, typename Iterator>
+using IsAtLeastIterator =
+    std::is_convertible<IteratorConcept<Iterator>, IteratorTag>;
+
+template <typename Iterator>
+using IsAtLeastForwardIterator =
+    IsAtLeastIterator<std::forward_iterator_tag, Iterator>;
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_ITERATOR_TRAITS_H_

package/vendor/abseil-cpp/absl/base/internal/iterator_traits_test.cc

@@ -0,0 +1,85 @@
+// 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/internal/iterator_traits.h"
+
+#include <forward_list>
+#include <iterator>
+#include <list>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/iterator_traits_test_helper.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+namespace {
+
+TEST(IsAtLeastIteratorTest, IsAtLeastIterator) {
+  EXPECT_TRUE((IsAtLeastIterator<std::input_iterator_tag, int*>()));
+  EXPECT_TRUE((IsAtLeastIterator<std::forward_iterator_tag, int*>()));
+  EXPECT_TRUE((IsAtLeastIterator<std::bidirectional_iterator_tag, int*>()));
+  EXPECT_TRUE((IsAtLeastIterator<std::random_access_iterator_tag, int*>()));
+  EXPECT_TRUE((IsAtLeastIterator<std::input_iterator_tag,
+                                 std::vector<int>::iterator>()));
+  EXPECT_TRUE((IsAtLeastIterator<std::forward_iterator_tag,
+                                 std::vector<int>::iterator>()));
+  EXPECT_TRUE((IsAtLeastIterator<std::bidirectional_iterator_tag,
+                                 std::vector<int>::iterator>()));
+  EXPECT_TRUE((IsAtLeastIterator<std::random_access_iterator_tag,
+                                 std::vector<int>::iterator>()));
+
+  EXPECT_TRUE(
+      (IsAtLeastIterator<std::input_iterator_tag, std::list<int>::iterator>()));
+  EXPECT_TRUE((IsAtLeastIterator<std::forward_iterator_tag,
+                                 std::list<int>::iterator>()));
+  EXPECT_TRUE((IsAtLeastIterator<std::bidirectional_iterator_tag,
+                                 std::list<int>::iterator>()));
+  EXPECT_FALSE((IsAtLeastIterator<std::random_access_iterator_tag,
+                                  std::list<int>::iterator>()));
+
+  EXPECT_TRUE((IsAtLeastIterator<std::input_iterator_tag,
+                                 std::forward_list<int>::iterator>()));
+  EXPECT_TRUE((IsAtLeastIterator<std::forward_iterator_tag,
+                                 std::forward_list<int>::iterator>()));
+  EXPECT_FALSE((IsAtLeastIterator<std::bidirectional_iterator_tag,
+                                  std::forward_list<int>::iterator>()));
+  EXPECT_FALSE((IsAtLeastIterator<std::random_access_iterator_tag,
+                                  std::forward_list<int>::iterator>()));
+
+  EXPECT_TRUE((IsAtLeastIterator<std::input_iterator_tag,
+                                 std::istream_iterator<int>>()));
+  EXPECT_FALSE((IsAtLeastIterator<std::forward_iterator_tag,
+                                  std::istream_iterator<int>>()));
+  EXPECT_FALSE((IsAtLeastIterator<std::bidirectional_iterator_tag,
+                                  std::istream_iterator<int>>()));
+  EXPECT_FALSE((IsAtLeastIterator<std::random_access_iterator_tag,
+                                  std::istream_iterator<int>>()));
+
+  EXPECT_TRUE((IsAtLeastIterator<std::input_iterator_tag,
+                                 Cpp20ForwardZipIterator<int*>>()));
+  EXPECT_TRUE((IsAtLeastIterator<std::forward_iterator_tag,
+                                 Cpp20ForwardZipIterator<int*>>()));
+  EXPECT_FALSE((IsAtLeastIterator<std::bidirectional_iterator_tag,
+                                  Cpp20ForwardZipIterator<int*>>()));
+  EXPECT_FALSE((IsAtLeastIterator<std::random_access_iterator_tag,
+                                  Cpp20ForwardZipIterator<int*>>()));
+}
+
+}  // namespace
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl

package/vendor/abseil-cpp/absl/base/internal/iterator_traits_test_helper.h

@@ -0,0 +1,97 @@
+// 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.
+
+#ifndef ABSL_BASE_INTERNAL_ITERATOR_TRAITS_TEST_HELPER_H_
+#define ABSL_BASE_INTERNAL_ITERATOR_TRAITS_TEST_HELPER_H_
+
+#include <iterator>
+#include <utility>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+// This would be a forward_iterator in C++20, but it's only an input iterator
+// before that, since it has a non-reference `reference`.
+template <typename Iterator>
+class Cpp20ForwardZipIterator {
+  using IteratorReference = typename std::iterator_traits<Iterator>::reference;
+
+ public:
+  Cpp20ForwardZipIterator() = default;
+  explicit Cpp20ForwardZipIterator(Iterator left, Iterator right)
+      : left_(left), right_(right) {}
+
+  Cpp20ForwardZipIterator& operator++() {
+    ++left_;
+    ++right_;
+    return *this;
+  }
+
+  Cpp20ForwardZipIterator operator++(int) {
+    Cpp20ForwardZipIterator tmp(*this);
+    ++*this;
+    return *this;
+  }
+
+  std::pair<IteratorReference, IteratorReference> operator*() const {
+    return {*left_, *right_};
+  }
+
+  // C++17 input iterators require `operator->`, but this isn't  possible to
+  // implement. C++20 dropped the requirement.
+
+  friend bool operator==(const Cpp20ForwardZipIterator& lhs,
+                         const Cpp20ForwardZipIterator& rhs) {
+    return lhs.left_ == rhs.left_ && lhs.right_ == rhs.right_;
+  }
+
+  friend bool operator!=(const Cpp20ForwardZipIterator& lhs,
+                         const Cpp20ForwardZipIterator& rhs) {
+    return !(lhs == rhs);
+  }
+
+ private:
+  Iterator left_{};
+  Iterator right_{};
+};
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+template <typename Iterator>
+struct std::iterator_traits<
+    absl::base_internal::Cpp20ForwardZipIterator<Iterator>> {
+ private:
+  using IteratorReference = typename std::iterator_traits<Iterator>::reference;
+
+ public:
+  using iterator_category = std::input_iterator_tag;
+  using iterator_concept = std::forward_iterator_tag;
+  using value_type = std::pair<IteratorReference, IteratorReference>;
+  using difference_type =
+      typename std::iterator_traits<Iterator>::difference_type;
+  using reference = value_type;
+  using pointer = void;
+};
+
+#if defined(__cpp_lib_concepts)
+static_assert(
+    std::forward_iterator<absl::base_internal::Cpp20ForwardZipIterator<int*>>);
+#endif  // defined(__cpp_lib_concepts)
+
+#endif  // ABSL_BASE_INTERNAL_ITERATOR_TRAITS_TEST_HELPER_H_

package/vendor/abseil-cpp/absl/base/internal/low_level_alloc.cc

@@ -19,6 +19,9 @@
 
 #include "absl/base/internal/low_level_alloc.h"
 
+#include <stdint.h>
+
+#include <optional>
 #include <type_traits>
 
 #include "absl/base/call_once.h"
@@ -219,6 +222,32 @@ struct LowLevelAlloc::Arena {
   uint32_t random ABSL_GUARDED_BY(mu);
 };
 
+// ---------------------------------------------------------------
+// An async-signal-safe arena for LowLevelAlloc
+static std::atomic<base_internal::LowLevelAlloc::Arena *> g_sig_safe_arena;
+
+base_internal::LowLevelAlloc::Arena *SigSafeArena() {
+  return g_sig_safe_arena.load(std::memory_order_acquire);
+}
+
+void InitSigSafeArena() {
+  if (SigSafeArena() == nullptr) {
+    uint32_t flags = 0;
+#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+    flags |= base_internal::LowLevelAlloc::kAsyncSignalSafe;
+#endif
+    base_internal::LowLevelAlloc::Arena *new_arena =
+        base_internal::LowLevelAlloc::NewArena(flags);
+    base_internal::LowLevelAlloc::Arena *old_value = nullptr;
+    if (!g_sig_safe_arena.compare_exchange_strong(old_value, new_arena,
+                                                  std::memory_order_release,
+                                                  std::memory_order_relaxed)) {
+      // We lost a race to allocate an arena; deallocate.
+      base_internal::LowLevelAlloc::DeleteArena(new_arena);
+    }
+  }
+}
+
 namespace {
 // Static storage space for the lazily-constructed, default global arena
 // instances.  We require this space because the whole point of LowLevelAlloc
@@ -289,11 +318,11 @@ class ABSL_SCOPED_LOCKABLE ArenaLock {
       mask_valid_ = pthread_sigmask(SIG_BLOCK, &all, &mask_) == 0;
     }
 #endif
-    arena_->mu.Lock();
+    arena_->mu.lock();
   }
   ~ArenaLock() { ABSL_RAW_CHECK(left_, "haven't left Arena region"); }
   void Leave() ABSL_UNLOCK_FUNCTION() {
-    arena_->mu.Unlock();
+    arena_->mu.unlock();
 #ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
     if (mask_valid_) {
       const int err = pthread_sigmask(SIG_SETMASK, &mask_, nullptr);
@@ -330,7 +359,7 @@ size_t GetPageSize() {
   GetSystemInfo(&system_info);
   return std::max(system_info.dwPageSize, system_info.dwAllocationGranularity);
 #elif defined(__wasm__) || defined(__asmjs__) || defined(__hexagon__)
-  return getpagesize();
+  return static_cast<size_t>(getpagesize());
 #else
   return static_cast<size_t>(sysconf(_SC_PAGESIZE));
 #endif
@@ -448,8 +477,8 @@ static inline uintptr_t RoundUp(uintptr_t addr, uintptr_t align) {
 // that the freelist is in the correct order, that it
 // consists of regions marked "unallocated", and that no two regions
 // are adjacent in memory (they should have been coalesced).
-// L >= arena->mu
-static AllocList *Next(int i, AllocList *prev, LowLevelAlloc::Arena *arena) {
+static AllocList *Next(int i, AllocList *prev, LowLevelAlloc::Arena *arena)
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(arena->mu) {
   ABSL_RAW_CHECK(i < prev->levels, "too few levels in Next()");
   AllocList *next = prev->next[i];
   if (next != nullptr) {
@@ -473,6 +502,7 @@ static void Coalesce(AllocList *a) {
   if (n != nullptr && reinterpret_cast<char *>(a) + a->header.size ==
                           reinterpret_cast<char *>(n)) {
     LowLevelAlloc::Arena *arena = a->header.arena;
+    arena->mu.AssertHeld();
     a->header.size += n->header.size;
     n->header.magic = 0;
     n->header.arena = nullptr;
@@ -486,8 +516,8 @@ static void Coalesce(AllocList *a) {
 }
 
 // Adds block at location "v" to the free list
-// L >= arena->mu
-static void AddToFreelist(void *v, LowLevelAlloc::Arena *arena) {
+static void AddToFreelist(void *v, LowLevelAlloc::Arena *arena)
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(arena->mu) {
   AllocList *f = reinterpret_cast<AllocList *>(reinterpret_cast<char *>(v) -
                                                sizeof(f->header));
   ABSL_RAW_CHECK(f->header.magic == Magic(kMagicAllocated, &f->header),
@@ -543,7 +573,7 @@ static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
       }
       // we unlock before mmap() both because mmap() may call a callback hook,
       // and because it may be slow.
-      arena->mu.Unlock();
+      arena->mu.unlock();
       // mmap generous 64K chunks to decrease
       // the chances/impact of fragmentation:
       size_t new_pages_size = RoundUp(req_rnd, arena->pagesize * 16);
@@ -582,7 +612,7 @@ static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
 #endif
 #endif  // __linux__
 #endif  // _WIN32
-      arena->mu.Lock();
+      arena->mu.lock();
       s = reinterpret_cast<AllocList *>(new_pages);
       s->header.size = new_pages_size;
       // Pretend the block is allocated; call AddToFreelist() to free it.

package/vendor/abseil-cpp/absl/base/internal/low_level_alloc.h

@@ -120,6 +120,12 @@ class LowLevelAlloc {
   LowLevelAlloc();      // no instances
 };
 
+// Returns a global async-signal-safe arena for LowLevelAlloc.
+LowLevelAlloc::Arena *SigSafeArena();
+
+// Ensures the global async-signal-safe arena for LowLevelAlloc is initialized.
+void InitSigSafeArena();
+
 }  // namespace base_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

package/vendor/abseil-cpp/absl/base/internal/poison.cc

@@ -57,19 +57,20 @@ size_t GetPageSize() {
 
 void* InitializePoisonedPointerInternal() {
   const size_t block_size = GetPageSize();
+  void* data = nullptr;
 #if defined(ABSL_HAVE_ADDRESS_SANITIZER)
-  void* data = malloc(block_size);
+  data = malloc(block_size);
   ASAN_POISON_MEMORY_REGION(data, block_size);
 #elif defined(ABSL_HAVE_MEMORY_SANITIZER)
-  void* data = malloc(block_size);
+  data = malloc(block_size);
   __msan_poison(data, block_size);
 #elif defined(ABSL_HAVE_MMAP)
-  void* data = DirectMmap(nullptr, block_size, PROT_NONE,
-                          MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  data = DirectMmap(nullptr, block_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS,
+                    -1, 0);
   if (data == MAP_FAILED) return GetBadPointerInternal();
 #elif defined(_WIN32)
-  void* data = VirtualAlloc(nullptr, block_size, MEM_RESERVE | MEM_COMMIT,
-                            PAGE_NOACCESS);
+  data = VirtualAlloc(nullptr, block_size, MEM_RESERVE | MEM_COMMIT,
+                      PAGE_NOACCESS);
   if (data == nullptr) return GetBadPointerInternal();
 #else
   return GetBadPointerInternal();

package/vendor/abseil-cpp/absl/base/internal/spinlock.cc

@@ -16,15 +16,18 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cstdint>
 #include <limits>
 
 #include "absl/base/attributes.h"
+#include "absl/base/call_once.h"
 #include "absl/base/config.h"
 #include "absl/base/internal/atomic_hook.h"
 #include "absl/base/internal/cycleclock.h"
+#include "absl/base/internal/scheduling_mode.h"
 #include "absl/base/internal/spinlock_wait.h"
 #include "absl/base/internal/sysinfo.h" /* For NumCPUs() */
-#include "absl/base/call_once.h"
+#include "absl/base/internal/tsan_mutex_interface.h"
 
 // Description of lock-word:
 //  31..00: [............................3][2][1][0]
@@ -58,7 +61,7 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static base_internal::AtomicHook<void (*)(
+ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static AtomicHook<void (*)(
     const void *lock, int64_t wait_cycles)>
     submit_profile_data;
 
@@ -67,21 +70,6 @@ void RegisterSpinLockProfiler(void (*fn)(const void *contendedlock,
   submit_profile_data.Store(fn);
 }
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-// Static member variable definitions.
-constexpr uint32_t SpinLock::kSpinLockHeld;
-constexpr uint32_t SpinLock::kSpinLockCooperative;
-constexpr uint32_t SpinLock::kSpinLockDisabledScheduling;
-constexpr uint32_t SpinLock::kSpinLockSleeper;
-constexpr uint32_t SpinLock::kWaitTimeMask;
-#endif
-
-// Uncommon constructors.
-SpinLock::SpinLock(base_internal::SchedulingMode mode)
-    : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {
-  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
-}
-
 // Monitor the lock to see if its value changes within some time period
 // (adaptive_spin_count loop iterations). The last value read from the lock
 // is returned from the method.
@@ -90,9 +78,8 @@ uint32_t SpinLock::SpinLoop() {
   // adaptive_spin_count here.
   ABSL_CONST_INIT static absl::once_flag init_adaptive_spin_count;
   ABSL_CONST_INIT static int adaptive_spin_count = 0;
-  base_internal::LowLevelCallOnce(&init_adaptive_spin_count, []() {
-    adaptive_spin_count = base_internal::NumCPUs() > 1 ? 1000 : 1;
-  });
+  LowLevelCallOnce(&init_adaptive_spin_count,
+                   []() { adaptive_spin_count = NumCPUs() > 1 ? 1000 : 1; });
 
   int c = adaptive_spin_count;
   uint32_t lock_value;
@@ -109,11 +96,11 @@ void SpinLock::SlowLock() {
     return;
   }
 
-  base_internal::SchedulingMode scheduling_mode;
+  SchedulingMode scheduling_mode;
   if ((lock_value & kSpinLockCooperative) != 0) {
-    scheduling_mode = base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL;
+    scheduling_mode = SCHEDULE_COOPERATIVE_AND_KERNEL;
   } else {
-    scheduling_mode = base_internal::SCHEDULE_KERNEL_ONLY;
+    scheduling_mode = SCHEDULE_KERNEL_ONLY;
   }
 
   // The lock was not obtained initially, so this thread needs to wait for
@@ -143,7 +130,7 @@ void SpinLock::SlowLock() {
         // new lock state will be the number of cycles this thread waited if
         // this thread obtains the lock.
         lock_value = TryLockInternal(lock_value, wait_cycles);
-        continue;   // Skip the delay at the end of the loop.
+        continue;  // Skip the delay at the end of the loop.
       } else if ((lock_value & kWaitTimeMask) == 0) {
         // The lock is still held, without a waiter being marked, but something
         // else about the lock word changed, causing our CAS to fail. For
@@ -159,8 +146,8 @@ void SpinLock::SlowLock() {
     // synchronization there to avoid false positives.
     ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
     // Wait for an OS specific delay.
-    base_internal::SpinLockDelay(&lockword_, lock_value, ++lock_wait_call_count,
-                                 scheduling_mode);
+    SpinLockDelay(&lockword_, lock_value, ++lock_wait_call_count,
+                  scheduling_mode);
     ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
     // Spin again after returning from the wait routine to give this thread
     // some chance of obtaining the lock.
@@ -171,8 +158,8 @@ void SpinLock::SlowLock() {
 }
 
 void SpinLock::SlowUnlock(uint32_t lock_value) {
-  base_internal::SpinLockWake(&lockword_,
-                              false);  // wake waiter if necessary
+  SpinLockWake(&lockword_,
+               false);  // wake waiter if necessary
 
   // If our acquisition was contended, collect contentionz profile info.  We
   // reserve a unitary wait time to represent that a waiter exists without our