re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/random/mock_distributions_test.cc

@@ -69,10 +69,11 @@ TEST(MockDistributions, Examples) {
       .WillOnce(Return(0.001));
   EXPECT_EQ(absl::Gaussian<double>(gen, 0.0, 1.0), 0.001);
 
-  EXPECT_NE(absl::LogUniform<int>(gen, 0, 1000000, 2), 2040);
-  EXPECT_CALL(absl::MockLogUniform<int>(), Call(gen, 0, 1000000, 2))
-      .WillOnce(Return(2040));
-  EXPECT_EQ(absl::LogUniform<int>(gen, 0, 1000000, 2), 2040);
+  const int kHigh = (1 << 30) - 1;
+  EXPECT_NE(absl::LogUniform<int>(gen, 0, kHigh, 2), kHigh);
+  EXPECT_CALL(absl::MockLogUniform<int>(), Call(gen, 0, kHigh, 2))
+      .WillOnce(Return(kHigh));
+  EXPECT_EQ(absl::LogUniform<int>(gen, 0, kHigh, 2), kHigh);
 }
 
 TEST(MockDistributions, UniformUInt128BoundariesAreAllowed) {

package/vendor/abseil-cpp/absl/random/mocking_bit_gen.h

@@ -35,7 +35,7 @@
 
 #include "gmock/gmock.h"
 #include "absl/base/config.h"
-#include "absl/base/internal/fast_type_id.h"
+#include "absl/base/fast_type_id.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/internal/mock_helpers.h"
@@ -175,9 +175,9 @@ class MockingBitGen {
   // distribution parameters of the expectation.
   template <typename ResultT, typename ArgTupleT, typename SelfT,
             typename ValidatorT>
-  auto RegisterMock(SelfT&, base_internal::FastTypeIdType type, ValidatorT)
+  auto RegisterMock(SelfT&, FastTypeIdType type, ValidatorT)
       -> decltype(GetMockFnType(std::declval<ResultT>(),
-                                std::declval<ArgTupleT>())) & {
+                                std::declval<ArgTupleT>()))& {
     using MockFnType = decltype(GetMockFnType(std::declval<ResultT>(),
                                               std::declval<ArgTupleT>()));
 
@@ -203,8 +203,8 @@ class MockingBitGen {
 
   // MockingBitGen::InvokeMock
   //
-  // InvokeMock(FastTypeIdType, args, result) is the entrypoint for invoking
-  // mocks registered on MockingBitGen.
+  // bool InvokeMock(key_id, args_tuple*, result*) is the entrypoint
+  // for invoking mocks registered on MockingBitGen.
   //
   // When no mocks are registered on the provided FastTypeIdType, returns false.
   // Otherwise attempts to invoke the mock function ResultT(Args...) that
@@ -212,18 +212,16 @@ class MockingBitGen {
   // Requires tuple_args to point to a ArgTupleT, which is a std::tuple<Args...>
   // used to invoke the mock function.
   // Requires result to point to a ResultT, which is the result of the call.
-  inline bool InvokeMock(base_internal::FastTypeIdType type, void* args_tuple,
+  inline bool InvokeMock(FastTypeIdType key_id, void* args_tuple,
                          void* result) {
     // Trigger a mock, if there exists one that matches `param`.
-    auto it = mocks_.find(type);
+    auto it = mocks_.find(key_id);
     if (it == mocks_.end()) return false;
     it->second->Apply(args_tuple, result);
     return true;
   }
 
-  absl::flat_hash_map<base_internal::FastTypeIdType,
-                      std::unique_ptr<FunctionHolder>>
-      mocks_;
+  absl::flat_hash_map<FastTypeIdType, std::unique_ptr<FunctionHolder>> mocks_;
   absl::BitGen gen_;
 
   template <typename>

package/vendor/abseil-cpp/absl/random/random.h

@@ -31,12 +31,13 @@
 #ifndef ABSL_RANDOM_RANDOM_H_
 #define ABSL_RANDOM_RANDOM_H_
 
+#include <cstdint>
 #include <random>
 
+#include "absl/base/config.h"
 #include "absl/random/distributions.h"  // IWYU pragma: export
-#include "absl/random/internal/nonsecure_base.h"  // IWYU pragma: export
-#include "absl/random/internal/pcg_engine.h"  // IWYU pragma: export
-#include "absl/random/internal/pool_urbg.h"
+#include "absl/random/internal/nonsecure_base.h"
+#include "absl/random/internal/pcg_engine.h"
 #include "absl/random/internal/randen_engine.h"
 #include "absl/random/seed_sequences.h"  // IWYU pragma: export
 
@@ -94,31 +95,46 @@ ABSL_NAMESPACE_BEGIN
 // types on modern x86, ARM, and PPC architectures.
 //
 // This type is thread-compatible, but not thread-safe.
-
-// ---------------------------------------------------------------------------
-// absl::BitGen member functions
-// ---------------------------------------------------------------------------
-
-// absl::BitGen::operator()()
-//
-// Calls the BitGen, returning a generated value.
-
-// absl::BitGen::min()
-//
-// Returns the smallest possible value from this bit generator.
-
-// absl::BitGen::max()
-//
-// Returns the largest possible value from this bit generator.
-
-// absl::BitGen::discard(num)
-//
-// Advances the internal state of this bit generator by `num` times, and
-// discards the intermediate results.
-// ---------------------------------------------------------------------------
-
-using BitGen = random_internal::NonsecureURBGBase<
-    random_internal::randen_engine<uint64_t>>;
+class BitGen : private random_internal::NonsecureURBGBase<
+                   random_internal::randen_engine<uint64_t>> {
+  using Base = random_internal::NonsecureURBGBase<
+      random_internal::randen_engine<uint64_t>>;
+
+ public:
+  using result_type = typename Base::result_type;
+
+  // BitGen()
+  // BitGen(SeedSequence seed_seq)
+  //
+  // Copy disallowed.
+  // Move allowed.
+  using Base::Base;
+  using Base::operator=;
+
+  // BitGen::min()
+  //
+  // Returns the smallest possible value from this bit generator.
+  using Base::min;
+
+  // BitGen::max()
+  //
+  // Returns the largest possible value from this bit generator.
+  using Base::max;
+
+  // BitGen::discard(num)
+  //
+  // Advances the internal state of this bit generator by `num` times, and
+  // discards the intermediate results.
+  using Base::discard;
+
+  // BitGen::operator()()
+  //
+  // Invoke the URBG, returning a generated value.
+  using Base::operator();
+
+  using Base::operator==;
+  using Base::operator!=;
+};
 
 // -----------------------------------------------------------------------------
 // absl::InsecureBitGen
@@ -156,32 +172,51 @@ using BitGen = random_internal::NonsecureURBGBase<
 // `absl::InsecureBitGen` is not cryptographically secure.
 //
 // Prefer `absl::BitGen` over `absl::InsecureBitGen` as the general type is
-// often fast enough for the vast majority of applications.
-
-using InsecureBitGen =
-    random_internal::NonsecureURBGBase<random_internal::pcg64_2018_engine>;
-
-// ---------------------------------------------------------------------------
-// absl::InsecureBitGen member functions
-// ---------------------------------------------------------------------------
-
-// absl::InsecureBitGen::operator()()
-//
-// Calls the InsecureBitGen, returning a generated value.
-
-// absl::InsecureBitGen::min()
+// often fast enough for the vast majority of applications. However, it is
+// reasonable to use `absl::InsecureBitGen` in tests or when using a URBG
+// in small isolated tasks such as in `std::shuffle`.
 //
-// Returns the smallest possible value from this bit generator.
-
-// absl::InsecureBitGen::max()
-//
-// Returns the largest possible value from this bit generator.
-
-// absl::InsecureBitGen::discard(num)
-//
-// Advances the internal state of this bit generator by `num` times, and
-// discards the intermediate results.
-// ---------------------------------------------------------------------------
+// This type is thread-compatible, but not thread-safe.
+class InsecureBitGen : private random_internal::NonsecureURBGBase<
+                           random_internal::pcg64_2018_engine> {
+  using Base =
+      random_internal::NonsecureURBGBase<random_internal::pcg64_2018_engine>;
+
+ public:
+  using result_type = typename Base::result_type;
+
+  // InsecureBitGen()
+  // InsecureBitGen(SeedSequence seed_seq)
+  //
+  // Copy disallowed.
+  // Move allowed.
+  using Base::Base;
+  using Base::operator=;
+
+  // InsecureBitGen::min()
+  //
+  // Returns the smallest possible value from this bit generator.
+  using Base::min;
+
+  // InsecureBitGen::max()
+  //
+  // Returns the largest possible value from this bit generator.
+  using Base::max;
+
+  // InsecureBitGen::discard(num)
+  //
+  // Advances the internal state of this bit generator by `num` times, and
+  // discards the intermediate results.
+  using Base::discard;
+
+  // InsecureBitGen::operator()()
+  //
+  // Invoke the URBG, returning a generated value.
+  using Base::operator();
+
+  using Base::operator==;
+  using Base::operator!=;
+};
 
 ABSL_NAMESPACE_END
 }  // namespace absl

package/vendor/abseil-cpp/absl/random/seed_sequences.cc

@@ -14,14 +14,18 @@
 
 #include "absl/random/seed_sequences.h"
 
-#include "absl/random/internal/pool_urbg.h"
+#include <iterator>
+
+#include "absl/base/config.h"
+#include "absl/random/internal/entropy_pool.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
 SeedSeq MakeSeedSeq() {
   SeedSeq::result_type seed_material[8];
-  random_internal::RandenPool<uint32_t>::Fill(absl::MakeSpan(seed_material));
+  random_internal::GetEntropyFromRandenPool(&seed_material[0],
+                                            sizeof(seed_material[0]) * 8);
   return SeedSeq(std::begin(seed_material), std::end(seed_material));
 }
 

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

@@ -17,6 +17,9 @@
 # It will expand later to have utilities around `Status` like `StatusOr`,
 # `StatusBuilder` and macros.
 
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
 load(
     "//absl:copts/configure_copts.bzl",
     "ABSL_DEFAULT_COPTS",
@@ -86,6 +89,17 @@ cc_test(
     ],
 )
 
+cc_binary(
+    name = "status_benchmark",
+    testonly = True,
+    srcs = ["status_benchmark.cc"],
+    tags = ["benchmark"],
+    deps = [
+        ":status",
+        "@google_benchmark//:benchmark_main",
+    ],
+)
+
 cc_library(
     name = "statusor",
     srcs = [
@@ -132,6 +146,18 @@ cc_test(
     ],
 )
 
+cc_binary(
+    name = "statusor_benchmark",
+    testonly = True,
+    srcs = ["statusor_benchmark.cc"],
+    tags = ["benchmark"],
+    deps = [
+        ":status",
+        ":statusor",
+        "@google_benchmark//:benchmark_main",
+    ],
+)
+
 cc_library(
     name = "status_matchers",
     testonly = 1,

package/vendor/abseil-cpp/absl/status/internal/status_internal.cc

@@ -189,7 +189,7 @@ bool StatusRep::operator==(const StatusRep& other) const {
   return true;
 }
 
-absl::Nonnull<StatusRep*> StatusRep::CloneAndUnref() const {
+StatusRep* absl_nonnull StatusRep::CloneAndUnref() const {
   // Optimization: no need to create a clone if we already have a refcount of 1.
   if (ref_.load(std::memory_order_acquire) == 1) {
     // All StatusRep instances are heap allocated and mutable, therefore this
@@ -235,9 +235,8 @@ absl::StatusCode MapToLocalCode(int value) {
   }
 }
 
-absl::Nonnull<const char*> MakeCheckFailString(
-    absl::Nonnull<const absl::Status*> status,
-    absl::Nonnull<const char*> prefix) {
+const char* absl_nonnull MakeCheckFailString(
+    const absl::Status* absl_nonnull status, const char* absl_nonnull prefix) {
   // There's no need to free this string since the process is crashing.
   return absl::IgnoreLeak(
              new std::string(absl::StrCat(

package/vendor/abseil-cpp/absl/status/internal/status_internal.h

@@ -100,7 +100,7 @@ class StatusRep {
   // Returns an equivalent heap allocated StatusRep with refcount 1.
   //
   // `this` is not safe to be used after calling as it may have been deleted.
-  absl::Nonnull<StatusRep*> CloneAndUnref() const;
+  StatusRep* absl_nonnull CloneAndUnref() const;
 
  private:
   mutable std::atomic<int32_t> ref_;
@@ -120,9 +120,8 @@ absl::StatusCode MapToLocalCode(int value);
 //
 // This is an internal implementation detail for Abseil logging.
 ABSL_ATTRIBUTE_PURE_FUNCTION
-absl::Nonnull<const char*> MakeCheckFailString(
-    absl::Nonnull<const absl::Status*> status,
-    absl::Nonnull<const char*> prefix);
+const char* absl_nonnull MakeCheckFailString(
+    const absl::Status* absl_nonnull status, const char* absl_nonnull prefix);
 
 }  // namespace status_internal
 

package/vendor/abseil-cpp/absl/status/internal/status_matchers.cc

@@ -30,14 +30,14 @@ ABSL_NAMESPACE_BEGIN
 namespace status_internal {
 
 void StatusIsMatcherCommonImpl::DescribeTo(std::ostream* os) const {
-  *os << ", has a status code that ";
+  *os << "has a status code that ";
   code_matcher_.DescribeTo(os);
   *os << ", and has an error message that ";
   message_matcher_.DescribeTo(os);
 }
 
 void StatusIsMatcherCommonImpl::DescribeNegationTo(std::ostream* os) const {
-  *os << ", or has a status code that ";
+  *os << "either has a status code that ";
   code_matcher_.DescribeNegationTo(os);
   *os << ", or has an error message that ";
   message_matcher_.DescribeNegationTo(os);
@@ -49,7 +49,8 @@ bool StatusIsMatcherCommonImpl::MatchAndExplain(
   ::testing::StringMatchResultListener inner_listener;
   if (!code_matcher_.MatchAndExplain(status.code(), &inner_listener)) {
     *result_listener << (inner_listener.str().empty()
-                             ? "whose status code is wrong"
+                             ? status.ok() ? "which is OK"
+                                           : "whose status code is wrong"
                              : "which has a status code " +
                                    inner_listener.str());
     return false;