re2 1.24.0 → 1.25.0

package/vendor/abseil-cpp/absl/meta/type_traits.h

@@ -45,6 +45,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
+#include "absl/base/macros.h"
 
 #ifdef __cpp_lib_span
 #include <span>  // NOLINT(build/c++20)
@@ -103,9 +104,10 @@ struct is_detected : is_detected_impl<void, Op, Args...>::type {};
 // metafunction allows you to create a general case that maps to `void` while
 // allowing specializations that map to specific types.
 //
-// This metafunction is not 100% compatible with the C++17 `std::void_t`
-// metafunction. It has slightly different behavior, such as when ordering
-// partial specializations. It is recommended to use `std::void_t` instead.
+// This metafunction is a workaround for some implementations of `std::void_t`
+// that evaluate to `void` prematurely, causing partial specializations to
+// appear duplicated (and thus invalid) to the compiler prior to substitution
+// taking place. Whenever possible, use `std::void_t` instead.
 template <typename... Ts>
 using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
 
@@ -115,38 +117,115 @@ using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
 //
 // See the documentation for the STL <type_traits> header for more information:
 // https://en.cppreference.com/w/cpp/header/type_traits
-using std::add_const_t;
-using std::add_cv_t;
-using std::add_lvalue_reference_t;
-using std::add_pointer_t;
-using std::add_rvalue_reference_t;
-using std::add_volatile_t;
-using std::common_type_t;
-using std::conditional_t;
-using std::conjunction;
-using std::decay_t;
-using std::enable_if_t;
-using std::disjunction;
-using std::is_copy_assignable;
-using std::is_function;
-using std::is_move_assignable;
-using std::is_trivially_copy_assignable;
-using std::is_trivially_copy_constructible;
-using std::is_trivially_default_constructible;
-using std::is_trivially_destructible;
-using std::is_trivially_move_assignable;
-using std::is_trivially_move_constructible;
-using std::make_signed_t;
-using std::make_unsigned_t;
-using std::negation;
-using std::remove_all_extents_t;
-using std::remove_const_t;
-using std::remove_cv_t;
-using std::remove_extent_t;
-using std::remove_pointer_t;
-using std::remove_reference_t;
-using std::remove_volatile_t;
-using std::underlying_type_t;
+
+template <class T>
+using add_const_t ABSL_DEPRECATE_AND_INLINE() = std::add_const_t<T>;
+
+template <class T>
+using add_cv_t ABSL_DEPRECATE_AND_INLINE() = std::add_cv_t<T>;
+
+template <class T>
+using add_lvalue_reference_t ABSL_DEPRECATE_AND_INLINE() =
+    std::add_lvalue_reference_t<T>;
+
+template <class T>
+using add_pointer_t ABSL_DEPRECATE_AND_INLINE() = std::add_pointer_t<T>;
+
+template <class T>
+using add_rvalue_reference_t ABSL_DEPRECATE_AND_INLINE() =
+    std::add_rvalue_reference_t<T>;
+
+template <class T>
+using add_volatile_t ABSL_DEPRECATE_AND_INLINE() = std::add_volatile_t<T>;
+
+template <class... T>
+using common_type_t ABSL_DEPRECATE_AND_INLINE() = std::common_type_t<T...>;
+
+template <bool C, class T, class F>
+using conditional_t ABSL_DEPRECATE_AND_INLINE() = std::conditional_t<C, T, F>;
+
+template <class... T>
+using conjunction ABSL_DEPRECATE_AND_INLINE() = std::conjunction<T...>;
+
+template <class T>
+using decay_t ABSL_DEPRECATE_AND_INLINE() = std::decay_t<T>;
+
+template <bool C, class T = void>
+using enable_if_t [[deprecated("Use std::enable_if_t instead.")]] =
+    std::enable_if_t<C, T>;
+
+template <class... T>
+using disjunction ABSL_DEPRECATE_AND_INLINE() = std::disjunction<T...>;
+
+template <class T>
+using is_copy_assignable ABSL_DEPRECATE_AND_INLINE() =
+    std::is_copy_assignable<T>;
+
+template <class T>
+using is_function ABSL_DEPRECATE_AND_INLINE() = std::is_function<T>;
+
+template <class T>
+using is_move_assignable ABSL_DEPRECATE_AND_INLINE() =
+    std::is_move_assignable<T>;
+
+template <class T>
+using is_trivially_copy_assignable ABSL_DEPRECATE_AND_INLINE() =
+    std::is_trivially_copy_assignable<T>;
+
+template <class T>
+using is_trivially_copy_constructible ABSL_DEPRECATE_AND_INLINE() =
+    std::is_trivially_copy_constructible<T>;
+
+template <class T>
+using is_trivially_default_constructible ABSL_DEPRECATE_AND_INLINE() =
+    std::is_trivially_default_constructible<T>;
+
+template <class T>
+using is_trivially_destructible ABSL_DEPRECATE_AND_INLINE() =
+    std::is_trivially_destructible<T>;
+
+template <class T>
+using is_trivially_move_assignable ABSL_DEPRECATE_AND_INLINE() =
+    std::is_trivially_move_assignable<T>;
+
+template <class T>
+using is_trivially_move_constructible ABSL_DEPRECATE_AND_INLINE() =
+    std::is_trivially_move_constructible<T>;
+
+template <class T>
+using make_signed_t ABSL_DEPRECATE_AND_INLINE() = std::make_signed_t<T>;
+
+template <class T>
+using make_unsigned_t ABSL_DEPRECATE_AND_INLINE() = std::make_unsigned_t<T>;
+
+template <class T>
+using negation ABSL_DEPRECATE_AND_INLINE() = std::negation<T>;
+
+template <class T>
+using remove_all_extents_t ABSL_DEPRECATE_AND_INLINE() =
+    std::remove_all_extents_t<T>;
+
+template <class T>
+using remove_const_t ABSL_DEPRECATE_AND_INLINE() = std::remove_const_t<T>;
+
+template <class T>
+using remove_cv_t ABSL_DEPRECATE_AND_INLINE() = std::remove_cv_t<T>;
+
+template <class T>
+using remove_extent_t ABSL_DEPRECATE_AND_INLINE() = std::remove_extent_t<T>;
+
+template <class T>
+using remove_pointer_t ABSL_DEPRECATE_AND_INLINE() = std::remove_pointer_t<T>;
+
+template <class T>
+using remove_reference_t ABSL_DEPRECATE_AND_INLINE() =
+    std::remove_reference_t<T>;
+
+template <class T>
+using remove_volatile_t ABSL_DEPRECATE_AND_INLINE() = std::remove_volatile_t<T>;
+
+template <class T>
+using underlying_type_t ABSL_DEPRECATE_AND_INLINE() = std::underlying_type_t<T>;
 
 #if defined(__cpp_lib_remove_cvref) && __cpp_lib_remove_cvref >= 201711L
 template <typename T>
@@ -211,31 +290,16 @@ template <typename F>
 using result_of_t = typename type_traits_internal::result_of<F>::type;
 
 namespace type_traits_internal {
-// In MSVC we can't probe std::hash or stdext::hash because it triggers a
-// static_assert instead of failing substitution. Libc++ prior to 4.0
-// also used a static_assert.
-//
-#if defined(_MSC_VER) || (defined(_LIBCPP_VERSION) && \
-                          _LIBCPP_VERSION < 4000 && _LIBCPP_STD_VER > 11)
-#define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 0
-#else
-#define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 1
-#endif
 
-#if !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-template <typename Key, typename = size_t>
-struct IsHashable : std::true_type {};
-#else   // ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
 template <typename Key, typename = void>
 struct IsHashable : std::false_type {};
 
 template <typename Key>
 struct IsHashable<
     Key,
-    absl::enable_if_t<std::is_convertible<
+    std::enable_if_t<std::is_convertible<
         decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())),
         std::size_t>::value>> : std::true_type {};
-#endif  // !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
 
 struct AssertHashEnabledHelper {
  private:
@@ -258,7 +322,7 @@ struct AssertHashEnabledHelper {
     static_assert(
         std::is_copy_constructible<std::hash<Key>>::value,
         "std::hash<Key> must be copy constructible when it is enabled");
-    static_assert(absl::is_copy_assignable<std::hash<Key>>::value,
+    static_assert(std::is_copy_assignable<std::hash<Key>>::value,
                   "std::hash<Key> must be copy assignable when it is enabled");
     // is_destructible is unchecked as it's implied by each of the
     // is_constructible checks.
@@ -321,7 +385,7 @@ struct IsNothrowSwappable
 //
 // Performs the swap idiom from a namespace where valid candidates may only be
 // found in `std` or via ADL.
-template <class T, absl::enable_if_t<IsSwappable<T>::value, int> = 0>
+template <class T, std::enable_if_t<IsSwappable<T>::value, int> = 0>
 void Swap(T& lhs, T& rhs) noexcept(IsNothrowSwappable<T>::value) {
   swap(lhs, rhs);
 }
@@ -490,7 +554,7 @@ template <typename T>
 struct IsOwnerImpl<
     T,
     std::enable_if_t<std::is_class<typename T::absl_internal_is_view>::value>>
-    : absl::negation<typename T::absl_internal_is_view> {};
+    : std::negation<typename T::absl_internal_is_view> {};
 
 // A trait to determine whether a type is an owner.
 // Do *not* depend on the correctness of this trait for correct code behavior.
@@ -570,7 +634,7 @@ struct IsView<std::span<T>> : std::true_type {};
 // Until then, we consider an assignment from an "owner" (such as std::string)
 // to a "view" (such as std::string_view) to be a lifetime-bound assignment.
 template <typename T, typename U>
-using IsLifetimeBoundAssignment = absl::conjunction<
+using IsLifetimeBoundAssignment = std::conjunction<
     std::integral_constant<bool, !std::is_lvalue_reference<U>::value>,
     IsOwner<absl::remove_cvref_t<U>>, IsView<absl::remove_cvref_t<T>>>;
 

package/vendor/abseil-cpp/absl/meta/type_traits_test.cc

@@ -33,8 +33,8 @@ using ::testing::StaticAssertTypeEq;
 
 template <typename T>
 using IsOwnerAndNotView =
-    absl::conjunction<absl::type_traits_internal::IsOwner<T>,
-                      absl::negation<absl::type_traits_internal::IsView<T>>>;
+    std::conjunction<absl::type_traits_internal::IsOwner<T>,
+                      std::negation<absl::type_traits_internal::IsView<T>>>;
 
 static_assert(
     IsOwnerAndNotView<std::pair<std::vector<int>, std::string>>::value,
@@ -70,13 +70,13 @@ struct StructC {};
 
 struct TypeWithBarFunction {
   template <class T,
-            absl::enable_if_t<std::is_same<T&&, StructA&>::value, int> = 0>
+            std::enable_if_t<std::is_same<T&&, StructA&>::value, int> = 0>
   ReturnType bar(T&&, const StructB&, StructC&&) &&;  // NOLINT
 };
 
 struct TypeWithBarFunctionAndConvertibleReturnType {
   template <class T,
-            absl::enable_if_t<std::is_same<T&&, StructA&>::value, int> = 0>
+            std::enable_if_t<std::is_same<T&&, StructA&>::value, int> = 0>
   ConvertibleToReturnType bar(T&&, const StructB&, StructC&&) &&;  // NOLINT
 };
 
@@ -160,19 +160,19 @@ enum class TypeEnum { A, B, C, D };
 
 struct GetTypeT {
   template <typename T,
-            absl::enable_if_t<std::is_same<T, TypeA>::value, int> = 0>
+            std::enable_if_t<std::is_same<T, TypeA>::value, int> = 0>
   TypeEnum operator()(Wrap<T>) const {
     return TypeEnum::A;
   }
 
   template <typename T,
-            absl::enable_if_t<std::is_same<T, TypeB>::value, int> = 0>
+            std::enable_if_t<std::is_same<T, TypeB>::value, int> = 0>
   TypeEnum operator()(Wrap<T>) const {
     return TypeEnum::B;
   }
 
   template <typename T,
-            absl::enable_if_t<std::is_same<T, TypeC>::value, int> = 0>
+            std::enable_if_t<std::is_same<T, TypeC>::value, int> = 0>
   TypeEnum operator()(Wrap<T>) const {
     return TypeEnum::C;
   }

package/vendor/abseil-cpp/absl/numeric/int128_test.cc

@@ -93,11 +93,11 @@ TEST(Uint128, IntrinsicTypeTraitsTest) {
 #endif  // ABSL_HAVE_INTRINSIC_INT128
 
 TEST(Uint128, TrivialTraitsTest) {
-  static_assert(absl::is_trivially_default_constructible<absl::uint128>::value,
+  static_assert(std::is_trivially_default_constructible<absl::uint128>::value,
                 "");
-  static_assert(absl::is_trivially_copy_constructible<absl::uint128>::value,
+  static_assert(std::is_trivially_copy_constructible<absl::uint128>::value,
                 "");
-  static_assert(absl::is_trivially_copy_assignable<absl::uint128>::value, "");
+  static_assert(std::is_trivially_copy_assignable<absl::uint128>::value, "");
   static_assert(std::is_trivially_destructible<absl::uint128>::value, "");
 }
 
@@ -619,10 +619,10 @@ TEST(Int128, IntrinsicTypeTraitsTest) {
 #endif  // ABSL_HAVE_INTRINSIC_INT128
 
 TEST(Int128, TrivialTraitsTest) {
-  static_assert(absl::is_trivially_default_constructible<absl::int128>::value,
+  static_assert(std::is_trivially_default_constructible<absl::int128>::value,
                 "");
-  static_assert(absl::is_trivially_copy_constructible<absl::int128>::value, "");
-  static_assert(absl::is_trivially_copy_assignable<absl::int128>::value, "");
+  static_assert(std::is_trivially_copy_constructible<absl::int128>::value, "");
+  static_assert(std::is_trivially_copy_assignable<absl::int128>::value, "");
   static_assert(std::is_trivially_destructible<absl::int128>::value, "");
 }
 

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

@@ -40,6 +40,7 @@ cc_library(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
         "//absl:__subpackages__",
+        "//absl:friends",
     ],
     deps = [
         "//absl/base:config",
@@ -77,6 +78,7 @@ cc_library(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
         "//absl:__subpackages__",
+        "//absl:friends",
     ],
     deps = [
         "//absl/base:config",
@@ -106,8 +108,8 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
-        # TODO(b/304670045): remove after periodic_sampler moves to //spanner/common.
         "//absl:__subpackages__",
+        "//absl:friends",
     ],
     deps = [
         ":exponential_biased",

package/vendor/abseil-cpp/absl/profiling/hashtable.cc

@@ -60,7 +60,6 @@ StatusOr<std::string> MarshalHashtableProfile(
   const auto capacity_id = builder.InternString("capacity");
   const auto size_id = builder.InternString("size");
   const auto num_erases_id = builder.InternString("num_erases");
-  const auto num_insert_hits_id = builder.InternString("num_insert_hits");
   const auto num_rehashes_id = builder.InternString("num_rehashes");
   const auto max_probe_length_id = builder.InternString("max_probe_length");
   const auto total_probe_length_id = builder.InternString("total_probe_length");
@@ -89,9 +88,6 @@ StatusOr<std::string> MarshalHashtableProfile(
         add_label(size_id, info.size.load(std::memory_order_relaxed));
         add_label(num_erases_id,
                   info.num_erases.load(std::memory_order_relaxed));
-        // TODO(b/436909492): Revisit whether this value is useful.
-        add_label(num_insert_hits_id,
-                  info.num_insert_hits.load(std::memory_order_relaxed));
         add_label(num_rehashes_id,
                   info.num_rehashes.load(std::memory_order_relaxed));
         add_label(max_probe_length_id,

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

@@ -400,6 +400,38 @@ void ProfileBuilder::AddCurrentMappings() {
 
         const bool is_main_executable = builder.mappings_.empty();
 
+        // Storage for path to executable as dlpi_name isn't populated for the
+        // main executable.  +1 to allow for the null terminator that readlink
+        // does not add.
+        char self_filename[PATH_MAX + 1];
+        const char* filename = info->dlpi_name;
+        if (filename == nullptr || filename[0] == '\0') {
+          // This is either the main executable or the VDSO.  The main
+          // executable is always the first entry processed by callbacks.
+          if (is_main_executable) {
+            // This is the main executable.
+            ssize_t ret = readlink("/proc/self/exe", self_filename,
+                                   sizeof(self_filename) - 1);
+            if (ret >= 0 && static_cast<size_t>(ret) < sizeof(self_filename)) {
+              self_filename[ret] = '\0';
+              filename = self_filename;
+            }
+          } else {
+            // This is the VDSO.
+            filename = GetSoName(info);
+          }
+        }
+
+        char resolved_path[PATH_MAX];
+        absl::string_view resolved_filename;
+        if (realpath(filename, resolved_path)) {
+          resolved_filename = resolved_path;
+        } else {
+          resolved_filename = filename;
+        }
+
+        const std::string build_id = GetBuildId(info);
+
         // Evaluate all the loadable segments.
         for (int i = 0; i < info->dlpi_phnum; ++i) {
           if (info->dlpi_phdr[i].p_type != PT_LOAD) {
@@ -414,39 +446,6 @@ void ProfileBuilder::AddCurrentMappings() {
           const size_t memory_limit = memory_start + pt_load->p_memsz;
           const size_t file_offset = pt_load->p_offset;
 
-          // Storage for path to executable as dlpi_name isn't populated for the
-          // main executable.  +1 to allow for the null terminator that readlink
-          // does not add.
-          char self_filename[PATH_MAX + 1];
-          const char* filename = info->dlpi_name;
-          if (filename == nullptr || filename[0] == '\0') {
-            // This is either the main executable or the VDSO.  The main
-            // executable is always the first entry processed by callbacks.
-            if (is_main_executable) {
-              // This is the main executable.
-              ssize_t ret = readlink("/proc/self/exe", self_filename,
-                                     sizeof(self_filename) - 1);
-              if (ret >= 0 &&
-                  static_cast<size_t>(ret) < sizeof(self_filename)) {
-                self_filename[ret] = '\0';
-                filename = self_filename;
-              }
-            } else {
-              // This is the VDSO.
-              filename = GetSoName(info);
-            }
-          }
-
-          char resolved_path[PATH_MAX];
-          absl::string_view resolved_filename;
-          if (realpath(filename, resolved_path)) {
-            resolved_filename = resolved_path;
-          } else {
-            resolved_filename = filename;
-          }
-
-          const std::string build_id = GetBuildId(info);
-
           // Add to profile.
           builder.AddMapping(memory_start, memory_limit, file_offset,
                              resolved_filename, build_id);

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

@@ -116,8 +116,31 @@ class ProfileBuilder {
   void set_default_sample_type_id(StringId default_sample_type_id);
 
  private:
-  absl::flat_hash_map<std::string, StringId> string_table_{{"", StringId(0)}};
-  absl::flat_hash_map<uintptr_t, LocationId> location_table_;
+  // We turn off hashtable profiling for the ProfileBuilder's own tables.
+  //
+  // This is necessary since we use this class to construct hashtable profiles,
+  // which entails walking the hashtable profiling data and we don't want to
+  // encounter it reentrantly.
+  template <typename T>
+  struct HashtablezBarrier : std::allocator<T> {
+    HashtablezBarrier() = default;
+
+    template <typename U>
+    HashtablezBarrier(const HashtablezBarrier<U>&) {}
+
+    template <class U>
+    struct rebind {
+      using other = HashtablezBarrier<U>;
+    };
+  };
+
+  template <typename K, typename V>
+  using UnprofiledHashMap = absl::flat_hash_map<
+      K, V, DefaultHashContainerHash<K>, DefaultHashContainerEq<K>,
+      HashtablezBarrier<std::pair<const K, V>>>;
+
+  UnprofiledHashMap<std::string, StringId> string_table_{{"", StringId(0)}};
+  UnprofiledHashMap<uintptr_t, LocationId> location_table_;
   // mapping_table_ stores the start address of each mapping in mapping_
   // to its index.
   absl::btree_map<uintptr_t, size_t> mapping_table_;

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

@@ -49,15 +49,17 @@ struct Info : public Sample<Info> {
 
 std::vector<size_t> GetSizes(SampleRecorder<Info>* s) {
   std::vector<size_t> res;
-  s->Iterate([&](const Info& info) {
+  EXPECT_EQ(s->Iterate([&](const Info& info) {
     res.push_back(info.size.load(std::memory_order_acquire));
-  });
+  }),
+            0);
   return res;
 }
 
 std::vector<int64_t> GetWeights(SampleRecorder<Info>* s) {
   std::vector<int64_t> res;
-  s->Iterate([&](const Info& info) { res.push_back(info.weight); });
+  EXPECT_EQ(s->Iterate([&](const Info& info) { res.push_back(info.weight); }),
+            0);
   return res;
 }
 
@@ -141,9 +143,10 @@ TEST(SampleRecorderTest, MultiThreaded) {
           }
           case 2: {
             absl::Duration oldest = absl::ZeroDuration();
-            sampler.Iterate([&](const Info& info) {
+            EXPECT_EQ(sampler.Iterate([&](const Info& info) {
               oldest = std::max(oldest, absl::Now() - info.create_time);
-            });
+            }),
+                      0);
             ASSERT_GE(oldest, absl::ZeroDuration());
             break;
           }

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

@@ -128,13 +128,14 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
+        ":mocking_access",
         ":random",
         "//absl/base:config",
         "//absl/base:core_headers",
         "//absl/base:fast_type_id",
         "//absl/meta:type_traits",
-        "//absl/random/internal:distribution_caller",
         "//absl/random/internal:fast_uniform_bits",
+        "//absl/random/internal:traits",
     ],
 )
 
@@ -160,6 +161,7 @@ cc_library(
     ],
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
+        ":mocking_access",
         ":random",
         "//absl/base:config",
         "//absl/base:fast_type_id",
@@ -171,6 +173,16 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "mocking_access",
+    hdrs = ["mocking_access.h"],
+    deps = [
+        "//absl/base:config",
+        "//absl/base:fast_type_id",
+        "//absl/meta:type_traits",
+    ],
+)
+
 cc_test(
     name = "bernoulli_distribution_test",
     size = "small",

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

@@ -44,9 +44,10 @@ absl_cc_library(
   DEPS
     absl::config
     absl::core_headers
-    absl::random_internal_distribution_caller
     absl::random_internal_fast_uniform_bits
     absl::type_traits
+    absl::random_mocking_access
+    absl::random_internal_traits
 )
 
 absl_cc_test(
@@ -68,6 +69,21 @@ absl_cc_test(
     GTest::gtest_main
 )
 
+absl_cc_library(
+  NAME
+    random_mocking_access
+  HDRS
+    "mocking_access.h"
+  COPTS
+    ${ABSL_DEFAULT_COPTS}
+  LINKOPTS
+    ${ABSL_DEFAULT_LINKOPTS}
+  DEPS
+    absl::config
+    absl::fast_type_id
+    absl::type_traits
+)
+
 # Internal-only target, do not depend on directly.
 absl_cc_library(
   NAME
@@ -82,6 +98,7 @@ absl_cc_library(
     absl::config
     absl::fast_type_id
     absl::optional
+    absl::random_mocking_access
 )
 
 # Internal-only target, do not depend on directly.
@@ -118,6 +135,7 @@ absl_cc_library(
     absl::flat_hash_map
     absl::raw_logging_internal
     absl::random_internal_mock_helpers
+    absl::random_mocking_access
     absl::random_random
     absl::type_traits
     absl::utility
@@ -536,6 +554,9 @@ absl_cc_library(
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
     absl::config
+    absl::type_traits
+    absl::bits
+    absl::int128
 )
 
 # Internal-only target, do not depend on directly.
@@ -553,6 +574,7 @@ absl_cc_library(
     absl::utility
     absl::fast_type_id
     absl::type_traits
+    absl::random_mocking_access
 )
 
 # Internal-only target, do not depend on directly.
@@ -852,7 +874,6 @@ absl_cc_library(
     absl::random_internal_platform
     absl::random_internal_randen_hwaes_impl
     absl::config
-    absl::optional
 )
 
 # Internal-only target, do not depend on directly.

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

@@ -97,7 +97,7 @@ class DefaultConstructorSeedSeq {};
 template <typename Engine, typename SSeq = DefaultConstructorSeedSeq>
 Engine make_engine() {
   constexpr bool use_default_initialization =
-    std::is_same_v<SSeq, DefaultConstructorSeedSeq>;
+      std::is_same_v<SSeq, DefaultConstructorSeedSeq>;
   if constexpr (use_default_initialization) {
     return Engine();
   } else {

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

@@ -282,7 +282,7 @@ beta_distribution<RealType>::AlgorithmJoehnk(
   using random_internal::GeneratePositiveTag;
   using random_internal::GenerateRealFromBits;
   using real_type =
-      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+      std::conditional_t<std::is_same<RealType, float>::value, float, double>;
 
   // Based on Joehnk, M. D. Erzeugung von betaverteilten und gammaverteilten
   // Zufallszahlen. Metrika 8.1 (1964): 5-15.
@@ -340,7 +340,7 @@ beta_distribution<RealType>::AlgorithmCheng(
   using random_internal::GeneratePositiveTag;
   using random_internal::GenerateRealFromBits;
   using real_type =
-      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+      std::conditional_t<std::is_same<RealType, float>::value, float, double>;
 
   // Based on Cheng, Russell CH. Generating beta variates with nonintegral
   // shape parameters. Communications of the ACM 21.4 (1978): 317-322.