re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/profiling/internal/sample_recorder.h

@@ -75,7 +75,7 @@ class SampleRecorder {
 
   // Iterates over all the registered `StackInfo`s.  Returning the number of
   // samples that have been dropped.
-  int64_t Iterate(const std::function<void(const T& stack)>& f);
+  size_t Iterate(const std::function<void(const T& stack)>& f);
 
   size_t GetMaxSamples() const;
   void SetMaxSamples(size_t max);
@@ -130,7 +130,7 @@ SampleRecorder<T>::SetDisposeCallback(DisposeCallback f) {
 template <typename T>
 SampleRecorder<T>::SampleRecorder()
     : dropped_samples_(0), size_estimate_(0), all_(nullptr), dispose_(nullptr) {
-  absl::MutexLock l(&graveyard_.init_mu);
+  absl::MutexLock l(graveyard_.init_mu);
   graveyard_.dead = &graveyard_;
 }
 
@@ -159,8 +159,8 @@ void SampleRecorder<T>::PushDead(T* sample) {
     dispose(*sample);
   }
 
-  absl::MutexLock graveyard_lock(&graveyard_.init_mu);
-  absl::MutexLock sample_lock(&sample->init_mu);
+  absl::MutexLock graveyard_lock(graveyard_.init_mu);
+  absl::MutexLock sample_lock(sample->init_mu);
   sample->dead = graveyard_.dead;
   graveyard_.dead = sample;
 }
@@ -168,7 +168,7 @@ void SampleRecorder<T>::PushDead(T* sample) {
 template <typename T>
 template <typename... Targs>
 T* SampleRecorder<T>::PopDead(Targs... args) {
-  absl::MutexLock graveyard_lock(&graveyard_.init_mu);
+  absl::MutexLock graveyard_lock(graveyard_.init_mu);
 
   // The list is circular, so eventually it collapses down to
   //   graveyard_.dead == &graveyard_
@@ -176,7 +176,7 @@ T* SampleRecorder<T>::PopDead(Targs... args) {
   T* sample = graveyard_.dead;
   if (sample == &graveyard_) return nullptr;
 
-  absl::MutexLock sample_lock(&sample->init_mu);
+  absl::MutexLock sample_lock(sample->init_mu);
   graveyard_.dead = sample->dead;
   sample->dead = nullptr;
   sample->PrepareForSampling(std::forward<Targs>(args)...);
@@ -198,7 +198,7 @@ T* SampleRecorder<T>::Register(Targs&&... args) {
     // Resurrection failed.  Hire a new warlock.
     sample = new T();
     {
-      absl::MutexLock sample_lock(&sample->init_mu);
+      absl::MutexLock sample_lock(sample->init_mu);
       // If flag initialization happens to occur (perhaps in another thread)
       // while in this block, it will lock `graveyard_` which is usually always
       // locked before any sample. This will appear as a lock inversion.
@@ -222,11 +222,11 @@ void SampleRecorder<T>::Unregister(T* sample) {
 }
 
 template <typename T>
-int64_t SampleRecorder<T>::Iterate(
+size_t SampleRecorder<T>::Iterate(
     const std::function<void(const T& stack)>& f) {
   T* s = all_.load(std::memory_order_acquire);
   while (s != nullptr) {
-    absl::MutexLock l(&s->init_mu);
+    absl::MutexLock l(s->init_mu);
     if (s->dead == nullptr) {
       f(*s);
     }

package/vendor/abseil-cpp/absl/profiling/internal/sample_recorder_test.cc

@@ -15,14 +15,20 @@
 #include "absl/profiling/internal/sample_recorder.h"
 
 #include <atomic>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
 #include <random>
 #include <vector>
 
 #include "gmock/gmock.h"
+#include "gtest/gtest.h"
 #include "absl/base/thread_annotations.h"
+#include "absl/random/random.h"
 #include "absl/synchronization/internal/thread_pool.h"
 #include "absl/synchronization/mutex.h"
 #include "absl/synchronization/notification.h"
+#include "absl/time/clock.h"
 #include "absl/time/time.h"
 
 namespace absl {
@@ -112,9 +118,7 @@ TEST(SampleRecorderTest, MultiThreaded) {
 
   for (int i = 0; i < 10; ++i) {
     pool.Schedule([&sampler, &stop, i]() {
-      std::random_device rd;
-      std::mt19937 gen(rd());
-
+      absl::InsecureBitGen gen;
       std::vector<Info*> infoz;
       while (!stop.HasBeenNotified()) {
         if (infoz.empty()) {

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

@@ -16,6 +16,9 @@
 
 # ABSL random-number generation libraries.
 
+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",
@@ -42,9 +45,9 @@ cc_library(
     deps = [
         ":distributions",
         ":seed_sequences",
+        "//absl/base:config",
         "//absl/random/internal:nonsecure_base",
         "//absl/random/internal:pcg_engine",
-        "//absl/random/internal:pool_urbg",
         "//absl/random/internal:randen_engine",
     ],
 )
@@ -111,7 +114,7 @@ cc_library(
         ":seed_gen_exception",
         "//absl/base:config",
         "//absl/base:nullability",
-        "//absl/random/internal:pool_urbg",
+        "//absl/random/internal:entropy_pool",
         "//absl/random/internal:salted_seed_seq",
         "//absl/random/internal:seed_material",
         "//absl/strings:string_view",
@@ -447,6 +450,7 @@ cc_test(
     deps = [
         ":bit_gen_ref",
         ":random",
+        "//absl/base:config",
         "//absl/base:fast_type_id",
         "//absl/random/internal:sequence_urbg",
         "@googletest//:gtest",
@@ -538,9 +542,7 @@ cc_binary(
     deps = [
         ":distributions",
         ":random",
-        ":seed_sequences",
         "//absl/base:core_headers",
-        "//absl/meta:type_traits",
         "//absl/random/internal:fast_uniform_bits",
         "//absl/random/internal:randen_engine",
         "@google_benchmark//:benchmark_main",

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

@@ -24,10 +24,10 @@ absl_cc_library(
   LINKOPTS
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
+    absl::config
     absl::random_distributions
     absl::random_internal_nonsecure_base
     absl::random_internal_pcg_engine
-    absl::random_internal_pool_urbg
     absl::random_internal_randen_engine
     absl::random_seed_sequences
 )
@@ -59,6 +59,7 @@ absl_cc_test(
   LINKOPTS
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
+    absl::config
     absl::random_bit_gen_ref
     absl::random_random
     absl::random_internal_sequence_urbg
@@ -229,7 +230,7 @@ absl_cc_library(
     absl::config
     absl::inlined_vector
     absl::nullability
-    absl::random_internal_pool_urbg
+    absl::random_internal_entropy_pool
     absl::random_internal_salted_seed_seq
     absl::random_internal_seed_material
     absl::random_seed_gen_exception
@@ -582,7 +583,7 @@ absl_cc_library(
     ${ABSL_DEFAULT_LINKOPTS}
     $<$<BOOL:${MINGW}>:-lbcrypt>
   DEPS
-    absl::core_headers
+    absl::config
     absl::optional
     absl::random_internal_fast_uniform_bits
     absl::raw_logging_internal
@@ -593,11 +594,11 @@ absl_cc_library(
 # Internal-only target, do not depend on directly.
 absl_cc_library(
   NAME
-    random_internal_pool_urbg
+    random_internal_entropy_pool
   SRCS
-    "internal/pool_urbg.cc"
+    "internal/entropy_pool.cc"
   HDRS
-    "internal/pool_urbg.h"
+    "internal/entropy_pool.h"
   COPTS
     ${ABSL_DEFAULT_COPTS}
   LINKOPTS
@@ -606,13 +607,12 @@ absl_cc_library(
     absl::base
     absl::config
     absl::core_headers
-    absl::endian
+    absl::random_internal_platform
     absl::random_internal_randen
     absl::random_internal_seed_material
-    absl::random_internal_traits
     absl::random_seed_gen_exception
-    absl::raw_logging_internal
     absl::span
+    absl::synchronization
 )
 
 # Internal-only target, do not depend on directly.
@@ -738,12 +738,11 @@ absl_cc_library(
   LINKOPTS
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
-    absl::core_headers
+    absl::config
     absl::inlined_vector
-    absl::random_internal_pool_urbg
+    absl::random_internal_entropy_pool
     absl::random_internal_salted_seed_seq
     absl::random_internal_seed_material
-    absl::span
     absl::type_traits
 )
 
@@ -1033,9 +1032,11 @@ absl_cc_test(
   LINKOPTS
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
+    absl::flat_hash_map
+    absl::random_distributions
     absl::random_internal_nonsecure_base
     absl::random_random
-    absl::random_distributions
+    absl::synchronization
     absl::type_traits
     GTest::gtest_main
 )
@@ -1052,6 +1053,7 @@ absl_cc_test(
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
     absl::random_internal_seed_material
+    absl::span
     GTest::gmock
     GTest::gtest_main
 )
@@ -1059,17 +1061,17 @@ absl_cc_test(
 # Internal-only target, do not depend on directly.
 absl_cc_test(
   NAME
-    random_internal_pool_urbg_test
+    random_internal_entropy_pool_test
   SRCS
-    "internal/pool_urbg_test.cc"
+    "internal/entropy_pool_test.cc"
   COPTS
     ${ABSL_TEST_COPTS}
   LINKOPTS
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
-    absl::random_internal_pool_urbg
-    absl::span
-    absl::type_traits
+    absl::flat_hash_map
+    absl::random_internal_entropy_pool
+    absl::synchronization
     GTest::gtest_main
 )
 
@@ -1242,7 +1244,6 @@ absl_cc_test(
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
     absl::random_internal_wide_multiply
-    absl::bits
     absl::int128
     GTest::gmock
     GTest::gtest_main

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

@@ -26,7 +26,6 @@
 #include <vector>
 
 #include "absl/base/macros.h"
-#include "absl/meta/type_traits.h"
 #include "absl/random/bernoulli_distribution.h"
 #include "absl/random/beta_distribution.h"
 #include "absl/random/exponential_distribution.h"
@@ -65,10 +64,10 @@ class PrecompiledSeedSeq {
   PrecompiledSeedSeq() = default;
 
   template <typename Iterator>
-  PrecompiledSeedSeq(Iterator begin, Iterator end) {}
+  PrecompiledSeedSeq(Iterator, Iterator) {}
 
   template <typename T>
-  PrecompiledSeedSeq(std::initializer_list<T> il) {}
+  PrecompiledSeedSeq(std::initializer_list<T>) {}
 
   template <typename OutIterator>
   void generate(OutIterator begin, OutIterator end) {
@@ -89,30 +88,23 @@ class PrecompiledSeedSeq {
   }
 };
 
-// use_default_initialization<T> indicates whether the random engine
-// T must be default initialized, or whether we may initialize it using
-// a seed sequence. This is used because some engines do not accept seed
-// sequence-based initialization.
-template <typename E>
-using use_default_initialization = std::false_type;
+// Triggers default constructor initialization.
+class DefaultConstructorSeedSeq {};
 
 // make_engine<T, SSeq> returns a random_engine which is initialized,
 // either via the default constructor, when use_default_initialization<T>
 // is true, or via the indicated seed sequence, SSeq.
-template <typename Engine, typename SSeq = PrecompiledSeedSeq>
-typename absl::enable_if_t<!use_default_initialization<Engine>::value, Engine>
-make_engine() {
-  // Initialize the random engine using the seed sequence SSeq, which
-  // is constructed from the precompiled seed data.
-  SSeq seq(std::begin(kSeedData), std::end(kSeedData));
-  return Engine(seq);
-}
-
-template <typename Engine, typename SSeq = PrecompiledSeedSeq>
-typename absl::enable_if_t<use_default_initialization<Engine>::value, Engine>
-make_engine() {
-  // Initialize the random engine using the default constructor.
-  return Engine();
+template <typename Engine, typename SSeq = DefaultConstructorSeedSeq>
+Engine make_engine() {
+  constexpr bool use_default_initialization =
+    std::is_same_v<SSeq, DefaultConstructorSeedSeq>;
+  if constexpr (use_default_initialization) {
+    return Engine();
+  } else {
+    // Otherwise, use the provided seed sequence.
+    SSeq seq(std::begin(kSeedData), std::end(kSeedData));
+    return Engine(seq);
+  }
 }
 
 template <typename Engine, typename SSeq>
@@ -248,6 +240,7 @@ void BM_Thread(benchmark::State& state) {
 
 // Normal benchmark suite
 #define BM_BASIC(Engine)                                                       \
+  BENCHMARK_TEMPLATE(BM_Construct, Engine, DefaultConstructorSeedSeq);         \
   BENCHMARK_TEMPLATE(BM_Construct, Engine, PrecompiledSeedSeq);                \
   BENCHMARK_TEMPLATE(BM_Construct, Engine, std::seed_seq);                     \
   BENCHMARK_TEMPLATE(BM_Direct, Engine);                                       \

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

@@ -31,7 +31,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
-#include "absl/base/internal/fast_type_id.h"
+#include "absl/base/fast_type_id.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/internal/distribution_caller.h"
 #include "absl/random/internal/fast_uniform_bits.h"
@@ -88,7 +88,7 @@ class MockHelpers;
 //
 class BitGenRef {
   // SFINAE to detect whether the URBG type includes a member matching
-  // bool InvokeMock(base_internal::FastTypeIdType, void*, void*).
+  // bool InvokeMock(key_id, args_tuple*, result*).
   //
   // These live inside BitGenRef so that they have friend access
   // to MockingBitGen. (see similar methods in DistributionCaller).
@@ -100,7 +100,7 @@ class BitGenRef {
 
   template <class T>
   using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock(
-      std::declval<base_internal::FastTypeIdType>(), std::declval<void*>(),
+      std::declval<FastTypeIdType>(), std::declval<void*>(),
       std::declval<void*>()));
 
   template <typename T>
@@ -145,8 +145,7 @@ class BitGenRef {
 
  private:
   using impl_fn = result_type (*)(uintptr_t);
-  using mock_call_fn = bool (*)(uintptr_t, base_internal::FastTypeIdType, void*,
-                                void*);
+  using mock_call_fn = bool (*)(uintptr_t, FastTypeIdType, void*, void*);
 
   template <typename URBG>
   static result_type ImplFn(uintptr_t ptr) {
@@ -158,19 +157,19 @@ class BitGenRef {
 
   // Get a type-erased InvokeMock pointer.
   template <typename URBG>
-  static bool MockCall(uintptr_t gen_ptr, base_internal::FastTypeIdType type,
-                       void* result, void* arg_tuple) {
-    return reinterpret_cast<URBG*>(gen_ptr)->InvokeMock(type, result,
+  static bool MockCall(uintptr_t gen_ptr, FastTypeIdType key_id, void* result,
+                       void* arg_tuple) {
+    return reinterpret_cast<URBG*>(gen_ptr)->InvokeMock(key_id, result,
                                                         arg_tuple);
   }
-  static bool NotAMock(uintptr_t, base_internal::FastTypeIdType, void*, void*) {
+  static bool NotAMock(uintptr_t, FastTypeIdType, void*, void*) {
     return false;
   }
 
-  inline bool InvokeMock(base_internal::FastTypeIdType type, void* args_tuple,
+  inline bool InvokeMock(FastTypeIdType key_id, void* args_tuple,
                          void* result) {
     if (mock_call_ == NotAMock) return false;  // avoids an indirect call.
-    return mock_call_(t_erased_gen_ptr_, type, args_tuple, result);
+    return mock_call_(t_erased_gen_ptr_, key_id, args_tuple, result);
   }
 
   uintptr_t t_erased_gen_ptr_;

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

@@ -15,9 +15,14 @@
 //
 #include "absl/random/bit_gen_ref.h"
 
+#include <cstdint>
+#include <random>
+#include <vector>
+
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "absl/base/internal/fast_type_id.h"
+#include "absl/base/config.h"
+#include "absl/base/fast_type_id.h"
 #include "absl/random/internal/sequence_urbg.h"
 #include "absl/random/random.h"
 
@@ -34,7 +39,7 @@ class ConstBitGen {
   result_type operator()() { return 1; }
 
   // InvokeMock method
-  bool InvokeMock(base_internal::FastTypeIdType index, void*, void* result) {
+  bool InvokeMock(FastTypeIdType, void*, void* result) {
     *static_cast<int*>(result) = 42;
     return true;
   }

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

@@ -50,7 +50,6 @@
 #include <type_traits>
 
 #include "absl/base/config.h"
-#include "absl/base/internal/inline_variable.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/bernoulli_distribution.h"
 #include "absl/random/beta_distribution.h"
@@ -68,13 +67,12 @@
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
-ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalClosedClosedTag, IntervalClosedClosed,
-                               {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalClosedClosedTag, IntervalClosed, {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalClosedOpenTag, IntervalClosedOpen, {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenOpenTag, IntervalOpenOpen, {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenOpenTag, IntervalOpen, {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenClosedTag, IntervalOpenClosed, {});
+inline constexpr IntervalClosedClosedTag IntervalClosedClosed = {};
+inline constexpr IntervalClosedClosedTag IntervalClosed = {};
+inline constexpr IntervalClosedOpenTag IntervalClosedOpen = {};
+inline constexpr IntervalOpenOpenTag IntervalOpenOpen = {};
+inline constexpr IntervalOpenOpenTag IntervalOpen = {};
+inline constexpr IntervalOpenClosedTag IntervalOpenClosed = {};
 
 // -----------------------------------------------------------------------------
 // absl::Uniform<T>(tag, bitgen, lo, hi)

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

@@ -244,7 +244,7 @@ inline double gaussian_distribution_base::zignor(
         bits);  // U(-1, 1)
     const double x = j * zg_.x[i];
 
-    // Retangular box. Handles >97% of all cases.
+    // Rectangular box. Handles >97% of all cases.
     // For any given box, this handles between 75% and 99% of values.
     // Equivalent to U(01) < (x[i+1] / x[i]), and when i == 0, ~93.5%
     if (std::abs(x) < zg_.x[i + 1]) {

package/vendor/abseil-cpp/absl/random/internal/BUILD.bazel

@@ -15,6 +15,9 @@
 #
 
 load("@bazel_skylib//lib:selects.bzl", "selects")
+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")
 
 # Internal-only implementation classes for Abseil Random
 load(
@@ -164,7 +167,7 @@ cc_library(
     }),
     deps = [
         ":fast_uniform_bits",
-        "//absl/base:core_headers",
+        "//absl/base:config",
         "//absl/base:dynamic_annotations",
         "//absl/base:raw_logging_internal",
         "//absl/strings",
@@ -174,13 +177,9 @@ cc_library(
 )
 
 cc_library(
-    name = "pool_urbg",
-    srcs = [
-        "pool_urbg.cc",
-    ],
-    hdrs = [
-        "pool_urbg.h",
-    ],
+    name = "entropy_pool",
+    srcs = ["entropy_pool.cc"],
+    hdrs = ["entropy_pool.h"],
     copts = ABSL_DEFAULT_COPTS,
     linkopts = select({
         "@rules_cc//cc/compiler:msvc-cl": [],
@@ -189,14 +188,12 @@ cc_library(
         "//conditions:default": ["-pthread"],
     }) + ABSL_DEFAULT_LINKOPTS,
     deps = [
+        ":platform",
         ":randen",
         ":seed_material",
-        ":traits",
         "//absl/base",
         "//absl/base:config",
         "//absl/base:core_headers",
-        "//absl/base:endian",
-        "//absl/base:raw_logging_internal",
         "//absl/random:seed_gen_exception",
         "//absl/types:span",
     ],
@@ -299,13 +296,12 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
-        ":pool_urbg",
+        ":entropy_pool",
         ":salted_seed_seq",
         ":seed_material",
-        "//absl/base:core_headers",
+        "//absl/base:config",
         "//absl/container:inlined_vector",
         "//absl/meta:type_traits",
-        "//absl/types:span",
     ],
 )
 
@@ -623,9 +619,11 @@ cc_test(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
         ":nonsecure_base",
+        "//absl/container:flat_hash_set",
         "//absl/meta:type_traits",
         "//absl/random",
         "//absl/random:distributions",
+        "//absl/synchronization",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],
@@ -639,23 +637,24 @@ cc_test(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
         ":seed_material",
+        "//absl/types:span",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],
 )
 
 cc_test(
-    name = "pool_urbg_test",
+    name = "entropy_pool_test",
     size = "small",
     srcs = [
-        "pool_urbg_test.cc",
+        "entropy_pool_test.cc",
     ],
     copts = ABSL_TEST_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
-        ":pool_urbg",
-        "//absl/meta:type_traits",
-        "//absl/types:span",
+        ":entropy_pool",
+        "//absl/container:flat_hash_set",
+        "//absl/synchronization",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],
@@ -750,7 +749,6 @@ cc_test(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
         ":wide_multiply",
-        "//absl/numeric:bits",
         "//absl/numeric:int128",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
@@ -804,6 +802,7 @@ cc_test(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     tags = [
         "benchmark",
+        "no_test_ios_sim_arm64",
         "no_test_ios_x86_64",
         "no_test_loonix",  # Crashing.
         "no_test_wasm",

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

@@ -22,7 +22,7 @@
 #include <utility>
 
 #include "absl/base/config.h"
-#include "absl/base/internal/fast_type_id.h"
+#include "absl/base/fast_type_id.h"
 #include "absl/meta/type_traits.h"
 #include "absl/utility/utility.h"
 
@@ -38,7 +38,7 @@ struct DistributionCaller {
   static_assert(!std::is_pointer<URBG>::value,
                 "You must pass a reference, not a pointer.");
   // SFINAE to detect whether the URBG type includes a member matching
-  // bool InvokeMock(base_internal::FastTypeIdType, void*, void*).
+  // bool InvokeMock(key_id, args_tuple*, result*).
   //
   // These live inside BitGenRef so that they have friend access
   // to MockingBitGen. (see similar methods in DistributionCaller).
@@ -50,8 +50,8 @@ struct DistributionCaller {
 
   template <class T>
   using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock(
-      std::declval<::absl::base_internal::FastTypeIdType>(),
-      std::declval<void*>(), std::declval<void*>()));
+      std::declval<FastTypeIdType>(), std::declval<void*>(),
+      std::declval<void*>()));
 
   using HasInvokeMock = typename detector<invoke_mock_t, void, URBG>::type;
 
@@ -74,8 +74,7 @@ struct DistributionCaller {
 
     ArgTupleT arg_tuple(std::forward<Args>(args)...);
     ResultT result;
-    if (!urbg->InvokeMock(::absl::base_internal::FastTypeId<KeyT>(), &arg_tuple,
-                          &result)) {
+    if (!urbg->InvokeMock(FastTypeId<KeyT>(), &arg_tuple, &result)) {
       auto dist = absl::make_from_tuple<DistrT>(arg_tuple);
       result = dist(*urbg);
     }