re2 1.22.2 → 1.23.0

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

@@ -109,10 +109,10 @@ absl_cc_library(
     absl::core_headers
     absl::dynamic_annotations
     absl::malloc_internal
+    absl::nullability
     absl::raw_logging_internal
     absl::stacktrace
     absl::symbolize
-    absl::tracing_internal
     absl::time
     absl::tracing_internal
     Threads::Threads
@@ -192,6 +192,7 @@ absl_cc_test(
     absl::core_headers
     absl::log
     absl::memory
+    absl::random_random
     absl::time
     GTest::gmock_main
 )

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

@@ -26,7 +26,7 @@ static bool IsZero(void *arg) {
 }
 
 bool Barrier::Block() {
-  MutexLock l(&this->lock_);
+  MutexLock l(this->lock_);
 
   this->num_to_block_--;
   if (this->num_to_block_ < 0) {

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

@@ -37,7 +37,7 @@ TEST(Barrier, SanityTest) {
     }
 
     // Increment the counter.
-    absl::MutexLock lock(&mutex);
+    absl::MutexLock lock(mutex);
     ++counter;
   };
 
@@ -57,7 +57,7 @@ TEST(Barrier, SanityTest) {
   // The counter should still be zero since no thread should have
   // been able to pass the barrier yet.
   {
-    absl::MutexLock lock(&mutex);
+    absl::MutexLock lock(mutex);
     EXPECT_EQ(counter, 0);
   }
 
@@ -70,6 +70,6 @@ TEST(Barrier, SanityTest) {
   }
 
   // All threads should now have incremented the counter.
-  absl::MutexLock lock(&mutex);
+  absl::MutexLock lock(mutex);
   EXPECT_EQ(counter, kNumThreads);
 }

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

@@ -42,7 +42,7 @@ bool BlockingCounter::DecrementCount() {
                  "BlockingCounter::DecrementCount() called too many times");
   if (count == 0) {
     base_internal::TraceSignal(this, TraceObjectKind());
-    MutexLock l(&lock_);
+    MutexLock l(lock_);
     done_ = true;
     return true;
   }
@@ -52,7 +52,7 @@ bool BlockingCounter::DecrementCount() {
 void BlockingCounter::Wait() {
   base_internal::TraceWait(this, TraceObjectKind());
   {
-    MutexLock l(&this->lock_);
+    MutexLock l(this->lock_);
 
     // only one thread may call Wait(). To support more than one thread,
     // implement a counter num_to_exit, like in the Barrier class.

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

@@ -35,7 +35,7 @@ namespace synchronization_internal {
 // ThreadIdentity storage is persistent, we maintain a free-list of previously
 // released ThreadIdentity objects.
 ABSL_CONST_INIT static base_internal::SpinLock freelist_lock(
-    absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
+    base_internal::SCHEDULE_KERNEL_ONLY);
 ABSL_CONST_INIT static base_internal::ThreadIdentity* thread_identity_freelist;
 
 // A per-thread destructor for reclaiming associated ThreadIdentity objects.
@@ -60,7 +60,7 @@ static void ReclaimThreadIdentity(void* v) {
   //     association state in this case.
   base_internal::ClearCurrentThreadIdentity();
   {
-    base_internal::SpinLockHolder l(&freelist_lock);
+    base_internal::SpinLockHolder l(freelist_lock);
     identity->next = thread_identity_freelist;
     thread_identity_freelist = identity;
   }
@@ -108,7 +108,7 @@ static base_internal::ThreadIdentity* NewThreadIdentity() {
 
   {
     // Re-use a previously released object if possible.
-    base_internal::SpinLockHolder l(&freelist_lock);
+    base_internal::SpinLockHolder l(freelist_lock);
     if (thread_identity_freelist) {
       identity = thread_identity_freelist;  // Take list-head.
       thread_identity_freelist = thread_identity_freelist->next;

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

@@ -31,10 +31,6 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr char FutexWaiter::kName[];
-#endif
-
 int FutexWaiter::WaitUntil(std::atomic<int32_t>* v, int32_t val,
                            KernelTimeout t) {
 #ifdef CLOCK_MONOTONIC

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

@@ -33,15 +33,15 @@
 #include "absl/base/internal/low_level_alloc.h"
 #ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
 
-#include "absl/synchronization/internal/graphcycles.h"
-
 #include <algorithm>
 #include <array>
 #include <cinttypes>
 #include <limits>
+
 #include "absl/base/internal/hide_ptr.h"
 #include "absl/base/internal/raw_logging.h"
 #include "absl/base/internal/spinlock.h"
+#include "absl/synchronization/internal/graphcycles.h"
 
 // Do not use STL.   This module does not use standard memory allocation.
 
@@ -54,15 +54,14 @@ namespace {
 // Avoid LowLevelAlloc's default arena since it calls malloc hooks in
 // which people are doing things like acquiring Mutexes.
 ABSL_CONST_INIT static absl::base_internal::SpinLock arena_mu(
-    absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
+    base_internal::SCHEDULE_KERNEL_ONLY);
 ABSL_CONST_INIT static base_internal::LowLevelAlloc::Arena* arena;
 
 static void InitArenaIfNecessary() {
-  arena_mu.Lock();
+  base_internal::SpinLockHolder l(arena_mu);
   if (arena == nullptr) {
     arena = base_internal::LowLevelAlloc::NewArena(0);
   }
-  arena_mu.Unlock();
 }
 
 // Number of inlined elements in Vec.  Hash table implementation
@@ -89,7 +88,7 @@ class Vec {
   T* end() { return ptr_ + size_; }
   const T& operator[](uint32_t i) const { return ptr_[i]; }
   T& operator[](uint32_t i) { return ptr_[i]; }
-  const T& back() const { return ptr_[size_-1]; }
+  const T& back() const { return ptr_[size_ - 1]; }
   void pop_back() { size_--; }
 
   void push_back(const T& v) {
@@ -178,7 +177,7 @@ class NodeSet {
     }
     table_[i] = v;
     // Double when 75% full.
-    if (occupied_ >= table_.size() - table_.size()/4) Grow();
+    if (occupied_ >= table_.size() - table_.size() / 4) Grow();
     return true;
   }
 
@@ -193,7 +192,7 @@ class NodeSet {
   // Example:
   //    HASH_FOR_EACH(elem, node->out) { ... }
 #define HASH_FOR_EACH(elem, eset) \
-  for (int32_t elem, _cursor = 0; (eset).Next(&_cursor, &elem); )
+  for (int32_t elem, _cursor = 0; (eset).Next(&_cursor, &elem);)
   bool Next(int32_t* cursor, int32_t* elem) {
     while (static_cast<uint32_t>(*cursor) < table_.size()) {
       int32_t v = table_[static_cast<uint32_t>(*cursor)];
@@ -209,7 +208,7 @@ class NodeSet {
  private:
   enum : int32_t { kEmpty = -1, kDel = -2 };
   Vec<int32_t> table_;
-  uint32_t occupied_;     // Count of non-empty slots (includes deleted slots)
+  uint32_t occupied_;  // Count of non-empty slots (includes deleted slots)
 
   static uint32_t Hash(int32_t a) { return static_cast<uint32_t>(a) * 41; }
 
@@ -270,25 +269,23 @@ inline GraphId MakeId(int32_t index, uint32_t version) {
   return g;
 }
 
-inline int32_t NodeIndex(GraphId id) {
-  return static_cast<int32_t>(id.handle);
-}
+inline int32_t NodeIndex(GraphId id) { return static_cast<int32_t>(id.handle); }
 
 inline uint32_t NodeVersion(GraphId id) {
   return static_cast<uint32_t>(id.handle >> 32);
 }
 
 struct Node {
-  int32_t rank;               // rank number assigned by Pearce-Kelly algorithm
-  uint32_t version;           // Current version number
-  int32_t next_hash;          // Next entry in hash table
-  bool visited;               // Temporary marker used by depth-first-search
-  uintptr_t masked_ptr;       // User-supplied pointer
-  NodeSet in;                 // List of immediate predecessor nodes in graph
-  NodeSet out;                // List of immediate successor nodes in graph
-  int priority;               // Priority of recorded stack trace.
-  int nstack;                 // Depth of recorded stack trace.
-  void* stack[40];            // stack[0,nstack-1] holds stack trace for node.
+  int32_t rank;          // rank number assigned by Pearce-Kelly algorithm
+  uint32_t version;      // Current version number
+  int32_t next_hash;     // Next entry in hash table
+  bool visited;          // Temporary marker used by depth-first-search
+  uintptr_t masked_ptr;  // User-supplied pointer
+  NodeSet in;            // List of immediate predecessor nodes in graph
+  NodeSet out;           // List of immediate successor nodes in graph
+  int priority;          // Priority of recorded stack trace.
+  int nstack;            // Depth of recorded stack trace.
+  void* stack[40];       // stack[0,nstack-1] holds stack trace for node.
 };
 
 // Hash table for pointer to node index lookups.
@@ -318,7 +315,7 @@ class PointerMap {
     // Advance through linked list while keeping track of the
     // predecessor slot that points to the current entry.
     auto masked = base_internal::HidePtr(ptr);
-    for (int32_t* slot = &table_[Hash(ptr)]; *slot != -1; ) {
+    for (int32_t* slot = &table_[Hash(ptr)]; *slot != -1;) {
       int32_t index = *slot;
       Node* n = (*nodes_)[static_cast<uint32_t>(index)];
       if (n->masked_ptr == masked) {
@@ -381,7 +378,9 @@ GraphCycles::GraphCycles() {
 
 GraphCycles::~GraphCycles() {
   for (auto* node : rep_->nodes_) {
-    if (node == nullptr) { continue; }
+    if (node == nullptr) {
+      continue;
+    }
     node->Node::~Node();
     base_internal::LowLevelAlloc::Free(node);
   }
@@ -474,8 +473,7 @@ void GraphCycles::RemoveNode(void* ptr) {
 
 void* GraphCycles::Ptr(GraphId id) {
   Node* n = FindNode(rep_, id);
-  return n == nullptr ? nullptr
-                      : base_internal::UnhidePtr<void>(n->masked_ptr);
+  return n == nullptr ? nullptr : base_internal::UnhidePtr<void>(n->masked_ptr);
 }
 
 bool GraphCycles::HasNode(GraphId node) {
@@ -502,8 +500,8 @@ static bool ForwardDFS(GraphCycles::Rep* r, int32_t n, int32_t upper_bound);
 static void BackwardDFS(GraphCycles::Rep* r, int32_t n, int32_t lower_bound);
 static void Reorder(GraphCycles::Rep* r);
 static void Sort(const Vec<Node*>&, Vec<int32_t>* delta);
-static void MoveToList(
-    GraphCycles::Rep* r, Vec<int32_t>* src, Vec<int32_t>* dst);
+static void MoveToList(GraphCycles::Rep* r, Vec<int32_t>* src,
+                       Vec<int32_t>* dst);
 
 bool GraphCycles::InsertEdge(GraphId idx, GraphId idy) {
   Rep* r = rep_;
@@ -605,9 +603,8 @@ static void Reorder(GraphCycles::Rep* r) {
 
   // Produce sorted list of all ranks that will be reassigned.
   r->merged_.resize(r->deltab_.size() + r->deltaf_.size());
-  std::merge(r->deltab_.begin(), r->deltab_.end(),
-             r->deltaf_.begin(), r->deltaf_.end(),
-             r->merged_.begin());
+  std::merge(r->deltab_.begin(), r->deltab_.end(), r->deltaf_.begin(),
+             r->deltaf_.end(), r->merged_.begin());
 
   // Assign the ranks in order to the collected list.
   for (uint32_t i = 0; i < r->list_.size(); i++) {
@@ -628,8 +625,8 @@ static void Sort(const Vec<Node*>& nodes, Vec<int32_t>* delta) {
   std::sort(delta->begin(), delta->end(), cmp);
 }
 
-static void MoveToList(
-    GraphCycles::Rep* r, Vec<int32_t>* src, Vec<int32_t>* dst) {
+static void MoveToList(GraphCycles::Rep* r, Vec<int32_t>* src,
+                       Vec<int32_t>* dst) {
   for (auto& v : *src) {
     int32_t w = v;
     // Replace v entry with its rank

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

@@ -12,14 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "absl/synchronization/internal/graphcycles.h"
-
 #include <algorithm>
 #include <cstdint>
 #include <vector>
 
-#include "benchmark/benchmark.h"
 #include "absl/base/internal/raw_logging.h"
+#include "absl/synchronization/internal/graphcycles.h"
+#include "benchmark/benchmark.h"
 
 namespace {
 

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

@@ -15,6 +15,7 @@
 #include "absl/synchronization/internal/graphcycles.h"
 
 #include <climits>
+#include <cstdint>
 #include <map>
 #include <random>
 #include <unordered_set>
@@ -461,20 +462,20 @@ TEST_F(GraphCyclesTest, ManyEdges) {
 
 TEST(GraphCycles, IntegerOverflow) {
   GraphCycles graph_cycles;
-  char *buf = (char *)nullptr;
-  GraphId prev_id = graph_cycles.GetId(buf);
+  uintptr_t buf = 0;
+  GraphId prev_id = graph_cycles.GetId(reinterpret_cast<void*>(buf));
   buf += 1;
-  GraphId id = graph_cycles.GetId(buf);
+  GraphId id = graph_cycles.GetId(reinterpret_cast<void*>(buf));
   ASSERT_TRUE(graph_cycles.InsertEdge(prev_id, id));
 
   // INT_MAX / 40 is enough to cause an overflow when multiplied by 41.
   graph_cycles.TestOnlyAddNodes(INT_MAX / 40);
 
   buf += 1;
-  GraphId newid = graph_cycles.GetId(buf);
+  GraphId newid = graph_cycles.GetId(reinterpret_cast<void*>(buf));
   graph_cycles.HasEdge(prev_id, newid);
 
-  graph_cycles.RemoveNode(buf);
+  graph_cycles.RemoveNode(reinterpret_cast<void*>(buf));
 }
 
 }  // namespace synchronization_internal

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

@@ -35,11 +35,6 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr uint64_t KernelTimeout::kNoTimeout;
-constexpr int64_t KernelTimeout::kMaxNanos;
-#endif
-
 int64_t KernelTimeout::SteadyClockNow() {
   if (!SupportsSteadyClock()) {
     return absl::GetCurrentTimeNanos();

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

@@ -58,10 +58,6 @@ class PthreadMutexHolder {
 };
 }  // namespace
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr char PthreadWaiter::kName[];
-#endif
-
 PthreadWaiter::PthreadWaiter() : waiter_count_(0), wakeup_count_(0) {
   const int err = pthread_mutex_init(&mu_, 0);
   if (err != 0) {

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

@@ -33,10 +33,6 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr char SemWaiter::kName[];
-#endif
-
 SemWaiter::SemWaiter() : wakeups_(0) {
   if (sem_init(&sem_, 0, 0) != 0) {
     ABSL_RAW_LOG(FATAL, "sem_init failed with errno %d\n", errno);

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

@@ -30,10 +30,6 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr char StdcppWaiter::kName[];
-#endif
-
 StdcppWaiter::StdcppWaiter() : waiter_count_(0), wakeup_count_(0) {}
 
 bool StdcppWaiter::Wait(KernelTimeout t) {

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

@@ -46,7 +46,7 @@ class ThreadPool {
 
   ~ThreadPool() {
     {
-      absl::MutexLock l(&mu_);
+      absl::MutexLock l(mu_);
       for (size_t i = 0; i < threads_.size(); i++) {
         queue_.push(nullptr);  // Shutdown signal.
       }
@@ -59,7 +59,7 @@ class ThreadPool {
   // Schedule a function to be run on a ThreadPool thread immediately.
   void Schedule(absl::AnyInvocable<void()> func) {
     assert(func != nullptr);
-    absl::MutexLock l(&mu_);
+    absl::MutexLock l(mu_);
     queue_.push(std::move(func));
   }
 
@@ -72,7 +72,7 @@ class ThreadPool {
     while (true) {
       absl::AnyInvocable<void()> func;
       {
-        absl::MutexLock l(&mu_);
+        absl::MutexLock l(mu_);
         mu_.Await(absl::Condition(this, &ThreadPool::WorkAvailable));
         func = std::move(queue_.front());
         queue_.pop();

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

@@ -21,10 +21,6 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr int WaiterBase::kIdlePeriods;
-#endif
-
 void WaiterBase::MaybeBecomeIdle() {
   base_internal::ThreadIdentity *identity =
       base_internal::CurrentThreadIdentityIfPresent();

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

@@ -129,7 +129,10 @@ TYPED_TEST_P(WaiterTest, WaitTimeWoken) {
       start + absl::Seconds(10))));
   absl::Duration waited = absl::Now() - start;
   EXPECT_GE(waited, WithTolerance(absl::Milliseconds(500)));
-  EXPECT_LT(waited, absl::Seconds(2));
+  #ifndef _MSC_VER
+    // Skip on MSVC due to flakiness.
+    EXPECT_LT(waited, absl::Seconds(2));
+  #endif
 }
 
 TYPED_TEST_P(WaiterTest, WaitDurationReached) {
@@ -139,7 +142,10 @@ TYPED_TEST_P(WaiterTest, WaitDurationReached) {
       absl::synchronization_internal::KernelTimeout(absl::Milliseconds(500))));
   absl::Duration waited = absl::Now() - start;
   EXPECT_GE(waited, WithTolerance(absl::Milliseconds(500)));
-  EXPECT_LT(waited, absl::Seconds(1));
+  #ifndef _MSC_VER
+    // Skip on MSVC due to flakiness.
+    EXPECT_LT(waited, absl::Seconds(1));
+  #endif
 }
 
 TYPED_TEST_P(WaiterTest, WaitTimeReached) {
@@ -149,7 +155,10 @@ TYPED_TEST_P(WaiterTest, WaitTimeReached) {
       start + absl::Milliseconds(500))));
   absl::Duration waited = absl::Now() - start;
   EXPECT_GE(waited, WithTolerance(absl::Milliseconds(500)));
-  EXPECT_LT(waited, absl::Seconds(1));
+  #ifndef _MSC_VER
+    // Skip on MSVC due to flakiness.
+    EXPECT_LT(waited, absl::Seconds(1));
+  #endif
 }
 
 REGISTER_TYPED_TEST_SUITE_P(WaiterTest,

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

@@ -28,10 +28,6 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr char Win32Waiter::kName[];
-#endif
-
 class Win32Waiter::WinHelper {
  public:
   static SRWLOCK *GetLock(Win32Waiter *w) {

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

@@ -45,7 +45,7 @@ void ThreadOne(absl::Mutex* mutex, absl::CondVar* condvar,
   CHECK(!*state) << "*state not initialized";
 
   {
-    absl::MutexLock lock(mutex);
+    absl::MutexLock lock(*mutex);
 
     notification->Notify();
     CHECK(notification->HasBeenNotified()) << "invalid Notification";
@@ -64,7 +64,7 @@ void ThreadTwo(absl::Mutex* mutex, absl::CondVar* condvar,
   notification->WaitForNotification();
   CHECK(notification->HasBeenNotified()) << "invalid Notification";
   {
-    absl::MutexLock lock(mutex);
+    absl::MutexLock lock(*mutex);
     *state = true;
     condvar->Signal();
   }
@@ -148,12 +148,12 @@ ABSL_CONST_INIT absl::Mutex early_const_init_mutex(absl::kConstInit);
 // before the constructors of either grab_lock or check_still_locked are run.)
 extern absl::Mutex const_init_sanity_mutex;
 OnConstruction grab_lock([]() ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  const_init_sanity_mutex.Lock();
+  const_init_sanity_mutex.lock();
 });
 ABSL_CONST_INIT absl::Mutex const_init_sanity_mutex(absl::kConstInit);
 OnConstruction check_still_locked([]() ABSL_NO_THREAD_SAFETY_ANALYSIS {
   const_init_sanity_mutex.AssertHeld();
-  const_init_sanity_mutex.Unlock();
+  const_init_sanity_mutex.unlock();
 });
 #endif  // defined(__clang__) || !(defined(_MSC_VER) && _MSC_VER > 1900)