re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/container/internal/compressed_tuple.h

@@ -64,24 +64,24 @@ struct Elem<CompressedTuple<B...>, I>
 template <typename D, size_t I>
 using ElemT = typename Elem<D, I>::type;
 
-// We can't use EBCO on other CompressedTuples because that would mean that we
-// derive from multiple Storage<> instantiations with the same I parameter,
-// and potentially from multiple identical Storage<> instantiations.  So anytime
-// we use type inheritance rather than encapsulation, we mark
-// CompressedTupleImpl, to make this easy to detect.
-struct uses_inheritance {};
 
 template <typename T>
 constexpr bool ShouldUseBase() {
   return std::is_class<T>::value && std::is_empty<T>::value &&
-         !std::is_final<T>::value &&
-         !std::is_base_of<uses_inheritance, T>::value;
+         !std::is_final<T>::value;
 }
 
+// Tag type used to disambiguate Storage types for different CompresseedTuples.
+// Without it, CompressedTuple<T, CompressedTuple<T>> would inherit from
+// Storage<T, 0> twice.
+template <typename... Ts>
+struct StorageTag;
+
 // The storage class provides two specializations:
 //  - For empty classes, it stores T as a base class.
 //  - For everything else, it stores T as a member.
-template <typename T, size_t I, bool UseBase = ShouldUseBase<T>()>
+// Tag should be set to StorageTag<Ts...>.
+template <typename T, size_t I, typename Tag, bool UseBase = ShouldUseBase<T>()>
 struct Storage {
   T value;
   constexpr Storage() = default;
@@ -94,8 +94,8 @@ struct Storage {
   constexpr T&& get() && { return std::move(*this).value; }
 };
 
-template <typename T, size_t I>
-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<T, I, true> : T {
+template <typename T, size_t I, typename Tag>
+struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<T, I, Tag, true> : T {
   constexpr Storage() = default;
 
   template <typename V>
@@ -111,30 +111,35 @@ template <typename D, typename I, bool ShouldAnyUseBase>
 struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
 
 template <typename... Ts, size_t... I, bool ShouldAnyUseBase>
-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
-    CompressedTuple<Ts...>, absl::index_sequence<I...>, ShouldAnyUseBase>
+struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+    CompressedTupleImpl<CompressedTuple<Ts...>, absl::index_sequence<I...>,
+                        ShouldAnyUseBase>
     // We use the dummy identity function through std::integral_constant to
     // convince MSVC of accepting and expanding I in that context. Without it
     // you would get:
     //   error C3548: 'I': parameter pack cannot be used in this context
-    : uses_inheritance,
-      Storage<Ts, std::integral_constant<size_t, I>::value>... {
+    : Storage<Ts, std::integral_constant<size_t, I>::value,
+              StorageTag<Ts...>>... {
   constexpr CompressedTupleImpl() = default;
   template <typename... Vs>
   explicit constexpr CompressedTupleImpl(absl::in_place_t, Vs&&... args)
-      : Storage<Ts, I>(absl::in_place, std::forward<Vs>(args))... {}
+      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
+                                          std::forward<Vs>(args))... {}
   friend CompressedTuple<Ts...>;
 };
 
 template <typename... Ts, size_t... I>
-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
-    CompressedTuple<Ts...>, absl::index_sequence<I...>, false>
+struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+    CompressedTupleImpl<CompressedTuple<Ts...>, absl::index_sequence<I...>,
+                        false>
     // We use the dummy identity function as above...
-    : Storage<Ts, std::integral_constant<size_t, I>::value, false>... {
+    : Storage<Ts, std::integral_constant<size_t, I>::value, StorageTag<Ts...>,
+              false>... {
   constexpr CompressedTupleImpl() = default;
   template <typename... Vs>
   explicit constexpr CompressedTupleImpl(absl::in_place_t, Vs&&... args)
-      : Storage<Ts, I, false>(absl::in_place, std::forward<Vs>(args))... {}
+      : Storage<Ts, I, StorageTag<Ts...>, false>(absl::in_place,
+                                                 std::forward<Vs>(args))... {}
   friend CompressedTuple<Ts...>;
 };
 
@@ -183,9 +188,7 @@ struct TupleItemsMoveConstructible
 // Helper class to perform the Empty Base Class Optimization.
 // Ts can contain classes and non-classes, empty or not. For the ones that
 // are empty classes, we perform the CompressedTuple. If all types in Ts are
-// empty classes, then CompressedTuple<Ts...> is itself an empty class.  (This
-// does not apply when one or more of those empty classes is itself an empty
-// CompressedTuple.)
+// empty classes, then CompressedTuple<Ts...> is itself an empty class.
 //
 // To access the members, use member .get<N>() function.
 //
@@ -208,7 +211,8 @@ class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
   using ElemT = internal_compressed_tuple::ElemT<CompressedTuple, I>;
 
   template <int I>
-  using StorageT = internal_compressed_tuple::Storage<ElemT<I>, I>;
+  using StorageT = internal_compressed_tuple::Storage<
+      ElemT<I>, I, internal_compressed_tuple::StorageTag<Ts...>>;
 
  public:
   // There seems to be a bug in MSVC dealing in which using '=default' here will

package/vendor/abseil-cpp/absl/container/internal/compressed_tuple_test.cc

@@ -386,20 +386,6 @@ TEST(CompressedTupleTest, Constexpr) {
 
   using Tuple = CompressedTuple<int, double, CompressedTuple<int>, Empty<0>>;
 
-  constexpr int r0 =
-      AsLValue(Tuple(1, 0.75, CompressedTuple<int>(9), {})).get<0>();
-  constexpr double r1 =
-      AsLValue(Tuple(1, 0.75, CompressedTuple<int>(9), {})).get<1>();
-  constexpr int r2 =
-      AsLValue(Tuple(1, 0.75, CompressedTuple<int>(9), {})).get<2>().get<0>();
-  constexpr CallType r3 =
-      AsLValue(Tuple(1, 0.75, CompressedTuple<int>(9), {})).get<3>().value();
-
-  EXPECT_EQ(r0, 1);
-  EXPECT_EQ(r1, 0.75);
-  EXPECT_EQ(r2, 9);
-  EXPECT_EQ(r3, CallType::kMutableRef);
-
   constexpr Tuple x(7, 1.25, CompressedTuple<int>(5), {});
   constexpr int x0 = x.get<0>();
   constexpr double x1 = x.get<1>();
@@ -466,14 +452,15 @@ TEST(CompressedTupleTest, EmptyFinalClass) {
 }
 #endif
 
-// TODO(b/214288561): enable this test.
-TEST(CompressedTupleTest, DISABLED_NestedEbo) {
+TEST(CompressedTupleTest, NestedEbo) {
   struct Empty1 {};
   struct Empty2 {};
   CompressedTuple<Empty1, CompressedTuple<Empty2>, int> x;
   CompressedTuple<Empty1, Empty2, int> y;
-  // Currently fails with sizeof(x) == 8, sizeof(y) == 4.
   EXPECT_EQ(sizeof(x), sizeof(y));
+
+  using NestedEmpty = CompressedTuple<Empty1, CompressedTuple<Empty2>>;
+  EXPECT_TRUE(std::is_empty_v<NestedEmpty>);
 }
 
 }  // namespace

package/vendor/abseil-cpp/absl/container/internal/container_memory.h

@@ -26,6 +26,7 @@
 #include <utility>
 
 #include "absl/base/config.h"
+#include "absl/hash/hash.h"
 #include "absl/memory/memory.h"
 #include "absl/meta/type_traits.h"
 #include "absl/utility/utility.h"
@@ -374,9 +375,6 @@ struct map_slot_policy {
     return slot->value;
   }
 
-  // When C++17 is available, we can use std::launder to provide mutable
-  // access to the key for use in node handle.
-#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
   static K& mutable_key(slot_type* slot) {
     // Still check for kMutableKeys so that we can avoid calling std::launder
     // unless necessary because it can interfere with optimizations.
@@ -384,9 +382,6 @@ struct map_slot_policy {
                                : *std::launder(const_cast<K*>(
                                      std::addressof(slot->value.first)));
   }
-#else  // !(defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606)
-  static const K& mutable_key(slot_type* slot) { return key(slot); }
-#endif
 
   static const K& key(const slot_type* slot) {
     return kMutableKeys::value ? slot->key : slot->value.first;
@@ -439,11 +434,17 @@ struct map_slot_policy {
   template <class Allocator>
   static auto transfer(Allocator* alloc, slot_type* new_slot,
                        slot_type* old_slot) {
-    auto is_relocatable =
-        typename absl::is_trivially_relocatable<value_type>::type();
+    // This should really just be
+    // typename absl::is_trivially_relocatable<value_type>::type()
+    // but std::pair is not trivially copyable in C++23 in some standard
+    // library versions.
+    // See https://github.com/llvm/llvm-project/pull/95444 for instance.
+    auto is_relocatable = typename std::conjunction<
+        absl::is_trivially_relocatable<typename value_type::first_type>,
+        absl::is_trivially_relocatable<typename value_type::second_type>>::
+        type();
 
     emplace(new_slot);
-#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
     if (is_relocatable) {
       // TODO(b/247130232,b/251814870): remove casts after fixing warnings.
       std::memcpy(static_cast<void*>(std::launder(&new_slot->value)),
@@ -451,7 +452,6 @@ struct map_slot_policy {
                   sizeof(value_type));
       return is_relocatable;
     }
-#endif
 
     if (kMutableKeys::value) {
       absl::allocator_traits<Allocator>::construct(
@@ -465,24 +465,87 @@ struct map_slot_policy {
   }
 };
 
+// Suppress erroneous uninitialized memory errors on GCC. For example, GCC
+// thinks that the call to slot_array() in find_or_prepare_insert() is reading
+// uninitialized memory, but slot_array is only called there when the table is
+// non-empty and this memory is initialized when the table is non-empty.
+#if !defined(__clang__) && defined(__GNUC__)
+#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x)                    \
+  _Pragma("GCC diagnostic push")                                   \
+      _Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")  \
+          _Pragma("GCC diagnostic ignored \"-Wuninitialized\"") x; \
+  _Pragma("GCC diagnostic pop")
+#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) \
+  ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(return x)
+#else
+#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
+#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
+#endif
+
+// Variadic arguments hash function that ignore the rest of the arguments.
+// Useful for usage with policy traits.
+template <class Hash, bool kIsDefault>
+struct HashElement {
+  HashElement(const Hash& h, size_t s) : hash(h), seed(s) {}
+
+  template <class K, class... Args>
+  size_t operator()(const K& key, Args&&...) const {
+    if constexpr (kIsDefault) {
+      // TODO(b/384509507): resolve `no header providing
+      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
+      // Maybe we should make "internal/hash.h" be a separate library.
+      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
+    }
+    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
+    return hash(key) ^ seed;
+  }
+  const Hash& hash;
+  size_t seed;
+};
+
+// No arguments function hash function for a specific key.
+template <class Hash, class Key, bool kIsDefault>
+struct HashKey {
+  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
+
+  size_t operator()(size_t seed) const {
+    return HashElement<Hash, kIsDefault>{hash, seed}(key);
+  }
+  const Hash& hash;
+  const Key& key;
+};
+
+// Variadic arguments equality function that ignore the rest of the arguments.
+// Useful for usage with policy traits.
+template <class K1, class KeyEqual>
+struct EqualElement {
+  template <class K2, class... Args>
+  bool operator()(const K2& lhs, Args&&...) const {
+    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
+  }
+  const K1& rhs;
+  const KeyEqual& eq;
+};
+
 // Type erased function for computing hash of the slot.
-using HashSlotFn = size_t (*)(const void* hash_fn, void* slot);
+using HashSlotFn = size_t (*)(const void* hash_fn, void* slot, size_t seed);
 
 // Type erased function to apply `Fn` to data inside of the `slot`.
 // The data is expected to have type `T`.
-template <class Fn, class T>
-size_t TypeErasedApplyToSlotFn(const void* fn, void* slot) {
+template <class Fn, class T, bool kIsDefault>
+size_t TypeErasedApplyToSlotFn(const void* fn, void* slot, size_t seed) {
   const auto* f = static_cast<const Fn*>(fn);
-  return (*f)(*static_cast<const T*>(slot));
+  return HashElement<Fn, kIsDefault>{*f, seed}(*static_cast<const T*>(slot));
 }
 
 // Type erased function to apply `Fn` to data inside of the `*slot_ptr`.
 // The data is expected to have type `T`.
-template <class Fn, class T>
-size_t TypeErasedDerefAndApplyToSlotFn(const void* fn, void* slot_ptr) {
+template <class Fn, class T, bool kIsDefault>
+size_t TypeErasedDerefAndApplyToSlotFn(const void* fn, void* slot_ptr,
+                                       size_t seed) {
   const auto* f = static_cast<const Fn*>(fn);
   const T* slot = *static_cast<const T**>(slot_ptr);
-  return (*f)(*slot);
+  return HashElement<Fn, kIsDefault>{*f, seed}(*slot);
 }
 
 }  // namespace container_internal

package/vendor/abseil-cpp/absl/container/internal/container_memory_test.cc

@@ -300,16 +300,46 @@ TEST(MapSlotPolicy, DestroyReturnsTrue) {
 
 TEST(ApplyTest, TypeErasedApplyToSlotFn) {
   size_t x = 7;
+  size_t seed = 100;
   auto fn = [](size_t v) { return v * 2; };
-  EXPECT_EQ((TypeErasedApplyToSlotFn<decltype(fn), size_t>(&fn, &x)), 14);
+  EXPECT_EQ(
+      (TypeErasedApplyToSlotFn<decltype(fn), size_t, /*kIsDefault=*/false>(
+          &fn, &x, seed)),
+      (HashElement<decltype(fn), /*kIsDefault=*/false>(fn, seed)(x)));
 }
 
 TEST(ApplyTest, TypeErasedDerefAndApplyToSlotFn) {
   size_t x = 7;
+  size_t seed = 100;
   auto fn = [](size_t v) { return v * 2; };
   size_t* x_ptr = &x;
+  EXPECT_EQ((TypeErasedDerefAndApplyToSlotFn<decltype(fn), size_t,
+                                             /*kIsDefault=*/false>(&fn, &x_ptr,
+                                                                   seed)),
+            (HashElement<decltype(fn), /*kIsDefault=*/false>(fn, seed)(x)));
+}
+
+TEST(HashElement, DefaultHash) {
+  size_t x = 7;
+  size_t seed = 100;
+  struct HashWithSeed {
+    size_t operator()(size_t v) const { return v * 2; }
+    size_t hash_with_seed(size_t v, size_t seed) const {
+      return v * 2 + seed * 3;
+    }
+  } hash;
+  EXPECT_EQ((HashElement<HashWithSeed, /*kIsDefault=*/true>(hash, seed)(x)),
+            hash.hash_with_seed(x, seed));
+}
+
+TEST(HashElement, NonDefaultHash) {
+  size_t x = 7;
+  size_t seed = 100;
+  auto fn = [](size_t v) { return v * 2; };
   EXPECT_EQ(
-      (TypeErasedDerefAndApplyToSlotFn<decltype(fn), size_t>(&fn, &x_ptr)), 14);
+      (HashElement<decltype(fn), /*kIsDefault=*/false>(
+          fn, seed)(x)),
+      fn(x) ^ seed);
 }
 
 }  // namespace

package/vendor/abseil-cpp/absl/container/internal/hash_function_defaults.h

@@ -49,6 +49,7 @@
 #include <functional>
 #include <memory>
 #include <string>
+#include <string_view>
 #include <type_traits>
 
 #include "absl/base/config.h"
@@ -58,10 +59,6 @@
 #include "absl/strings/cord.h"
 #include "absl/strings/string_view.h"
 
-#ifdef ABSL_HAVE_STD_STRING_VIEW
-#include <string_view>
-#endif
-
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
@@ -82,6 +79,18 @@ struct StringHash {
   size_t operator()(const absl::Cord& v) const {
     return absl::Hash<absl::Cord>{}(v);
   }
+
+ private:
+  friend struct absl::hash_internal::HashWithSeed;
+
+  size_t hash_with_seed(absl::string_view v, size_t seed) const {
+    return absl::hash_internal::HashWithSeed().hash(
+        absl::Hash<absl::string_view>{}, v, seed);
+  }
+  size_t hash_with_seed(const absl::Cord& v, size_t seed) const {
+    return absl::hash_internal::HashWithSeed().hash(absl::Hash<absl::Cord>{}, v,
+                                                    seed);
+  }
 };
 
 struct StringEq {
@@ -113,8 +122,6 @@ struct HashEq<absl::string_view> : StringHashEq {};
 template <>
 struct HashEq<absl::Cord> : StringHashEq {};
 
-#ifdef ABSL_HAVE_STD_STRING_VIEW
-
 template <typename TChar>
 struct BasicStringHash {
   using is_transparent = void;
@@ -153,8 +160,6 @@ struct HashEq<std::u32string> : BasicStringHashEq<char32_t> {};
 template <>
 struct HashEq<std::u32string_view> : BasicStringHashEq<char32_t> {};
 
-#endif  // ABSL_HAVE_STD_STRING_VIEW
-
 // Supports heterogeneous lookup for pointers and smart pointers.
 template <class T>
 struct HashEq<T*> {

package/vendor/abseil-cpp/absl/container/internal/hash_function_defaults_test.cc

@@ -16,6 +16,7 @@
 
 #include <cstddef>
 #include <functional>
+#include <string_view>
 #include <type_traits>
 #include <utility>
 
@@ -28,10 +29,6 @@
 #include "absl/strings/cord_test_helpers.h"
 #include "absl/strings/string_view.h"
 
-#ifdef ABSL_HAVE_STD_STRING_VIEW
-#include <string_view>
-#endif
-
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
@@ -118,9 +115,6 @@ TYPED_TEST(HashString, Works) {
 }
 
 TEST(BasicStringViewTest, WStringEqWorks) {
-#ifndef ABSL_HAVE_STD_STRING_VIEW
-  GTEST_SKIP();
-#else
   hash_default_eq<std::wstring> eq;
   EXPECT_TRUE(eq(L"a", L"a"));
   EXPECT_TRUE(eq(L"a", std::wstring_view(L"a")));
@@ -128,13 +122,9 @@ TEST(BasicStringViewTest, WStringEqWorks) {
   EXPECT_FALSE(eq(L"a", L"b"));
   EXPECT_FALSE(eq(L"a", std::wstring_view(L"b")));
   EXPECT_FALSE(eq(L"a", std::wstring(L"b")));
-#endif
 }
 
 TEST(BasicStringViewTest, WStringViewEqWorks) {
-#ifndef ABSL_HAVE_STD_STRING_VIEW
-  GTEST_SKIP();
-#else
   hash_default_eq<std::wstring_view> eq;
   EXPECT_TRUE(eq(L"a", L"a"));
   EXPECT_TRUE(eq(L"a", std::wstring_view(L"a")));
@@ -142,13 +132,9 @@ TEST(BasicStringViewTest, WStringViewEqWorks) {
   EXPECT_FALSE(eq(L"a", L"b"));
   EXPECT_FALSE(eq(L"a", std::wstring_view(L"b")));
   EXPECT_FALSE(eq(L"a", std::wstring(L"b")));
-#endif
 }
 
 TEST(BasicStringViewTest, U16StringEqWorks) {
-#ifndef ABSL_HAVE_STD_STRING_VIEW
-  GTEST_SKIP();
-#else
   hash_default_eq<std::u16string> eq;
   EXPECT_TRUE(eq(u"a", u"a"));
   EXPECT_TRUE(eq(u"a", std::u16string_view(u"a")));
@@ -156,13 +142,9 @@ TEST(BasicStringViewTest, U16StringEqWorks) {
   EXPECT_FALSE(eq(u"a", u"b"));
   EXPECT_FALSE(eq(u"a", std::u16string_view(u"b")));
   EXPECT_FALSE(eq(u"a", std::u16string(u"b")));
-#endif
 }
 
 TEST(BasicStringViewTest, U16StringViewEqWorks) {
-#ifndef ABSL_HAVE_STD_STRING_VIEW
-  GTEST_SKIP();
-#else
   hash_default_eq<std::u16string_view> eq;
   EXPECT_TRUE(eq(u"a", u"a"));
   EXPECT_TRUE(eq(u"a", std::u16string_view(u"a")));
@@ -170,13 +152,9 @@ TEST(BasicStringViewTest, U16StringViewEqWorks) {
   EXPECT_FALSE(eq(u"a", u"b"));
   EXPECT_FALSE(eq(u"a", std::u16string_view(u"b")));
   EXPECT_FALSE(eq(u"a", std::u16string(u"b")));
-#endif
 }
 
 TEST(BasicStringViewTest, U32StringEqWorks) {
-#ifndef ABSL_HAVE_STD_STRING_VIEW
-  GTEST_SKIP();
-#else
   hash_default_eq<std::u32string> eq;
   EXPECT_TRUE(eq(U"a", U"a"));
   EXPECT_TRUE(eq(U"a", std::u32string_view(U"a")));
@@ -184,13 +162,9 @@ TEST(BasicStringViewTest, U32StringEqWorks) {
   EXPECT_FALSE(eq(U"a", U"b"));
   EXPECT_FALSE(eq(U"a", std::u32string_view(U"b")));
   EXPECT_FALSE(eq(U"a", std::u32string(U"b")));
-#endif
 }
 
 TEST(BasicStringViewTest, U32StringViewEqWorks) {
-#ifndef ABSL_HAVE_STD_STRING_VIEW
-  GTEST_SKIP();
-#else
   hash_default_eq<std::u32string_view> eq;
   EXPECT_TRUE(eq(U"a", U"a"));
   EXPECT_TRUE(eq(U"a", std::u32string_view(U"a")));
@@ -198,85 +172,60 @@ TEST(BasicStringViewTest, U32StringViewEqWorks) {
   EXPECT_FALSE(eq(U"a", U"b"));
   EXPECT_FALSE(eq(U"a", std::u32string_view(U"b")));
   EXPECT_FALSE(eq(U"a", std::u32string(U"b")));
-#endif
 }
 
 TEST(BasicStringViewTest, WStringHashWorks) {
-#ifndef ABSL_HAVE_STD_STRING_VIEW
-  GTEST_SKIP();
-#else
   hash_default_hash<std::wstring> hash;
   auto h = hash(L"a");
   EXPECT_EQ(h, hash(std::wstring_view(L"a")));
   EXPECT_EQ(h, hash(std::wstring(L"a")));
   EXPECT_NE(h, hash(std::wstring_view(L"b")));
   EXPECT_NE(h, hash(std::wstring(L"b")));
-#endif
 }
 
 TEST(BasicStringViewTest, WStringViewHashWorks) {
-#ifndef ABSL_HAVE_STD_STRING_VIEW
-  GTEST_SKIP();
-#else
   hash_default_hash<std::wstring_view> hash;
   auto h = hash(L"a");
   EXPECT_EQ(h, hash(std::wstring_view(L"a")));
   EXPECT_EQ(h, hash(std::wstring(L"a")));
   EXPECT_NE(h, hash(std::wstring_view(L"b")));
   EXPECT_NE(h, hash(std::wstring(L"b")));
-#endif
 }
 
 TEST(BasicStringViewTest, U16StringHashWorks) {
-#ifndef ABSL_HAVE_STD_STRING_VIEW
-  GTEST_SKIP();
-#else
   hash_default_hash<std::u16string> hash;
   auto h = hash(u"a");
   EXPECT_EQ(h, hash(std::u16string_view(u"a")));
   EXPECT_EQ(h, hash(std::u16string(u"a")));
   EXPECT_NE(h, hash(std::u16string_view(u"b")));
   EXPECT_NE(h, hash(std::u16string(u"b")));
-#endif
 }
 
 TEST(BasicStringViewTest, U16StringViewHashWorks) {
-#ifndef ABSL_HAVE_STD_STRING_VIEW
-  GTEST_SKIP();
-#else
   hash_default_hash<std::u16string_view> hash;
   auto h = hash(u"a");
   EXPECT_EQ(h, hash(std::u16string_view(u"a")));
   EXPECT_EQ(h, hash(std::u16string(u"a")));
   EXPECT_NE(h, hash(std::u16string_view(u"b")));
   EXPECT_NE(h, hash(std::u16string(u"b")));
-#endif
 }
 
 TEST(BasicStringViewTest, U32StringHashWorks) {
-#ifndef ABSL_HAVE_STD_STRING_VIEW
-  GTEST_SKIP();
-#else
   hash_default_hash<std::u32string> hash;
   auto h = hash(U"a");
   EXPECT_EQ(h, hash(std::u32string_view(U"a")));
   EXPECT_EQ(h, hash(std::u32string(U"a")));
   EXPECT_NE(h, hash(std::u32string_view(U"b")));
   EXPECT_NE(h, hash(std::u32string(U"b")));
-#endif
 }
 
 TEST(BasicStringViewTest, U32StringViewHashWorks) {
-#ifndef ABSL_HAVE_STD_STRING_VIEW
-  GTEST_SKIP();
-#else
   hash_default_hash<std::u32string_view> hash;
   auto h = hash(U"a");
   EXPECT_EQ(h, hash(std::u32string_view(U"a")));
   EXPECT_EQ(h, hash(std::u32string(U"a")));
   EXPECT_NE(h, hash(std::u32string_view(U"b")));
   EXPECT_NE(h, hash(std::u32string(U"b")));
-#endif
 }
 
 struct NoDeleter {

package/vendor/abseil-cpp/absl/container/internal/hash_generator_testing.cc

@@ -14,61 +14,39 @@
 
 #include "absl/container/internal/hash_generator_testing.h"
 
+#include <algorithm>
 #include <deque>
+#include <random>
+#include <string>
 
 #include "absl/base/no_destructor.h"
+#include "absl/random/random.h"
+#include "absl/strings/string_view.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 namespace hash_internal {
-namespace {
-
-class RandomDeviceSeedSeq {
- public:
-  using result_type = typename std::random_device::result_type;
-
-  template <class Iterator>
-  void generate(Iterator start, Iterator end) {
-    while (start != end) {
-      *start = gen_();
-      ++start;
-    }
-  }
-
- private:
-  std::random_device gen_;
-};
-
-}  // namespace
-
-std::mt19937_64* GetSharedRng() {
-  static absl::NoDestructor<std::mt19937_64> rng([] {
-    RandomDeviceSeedSeq seed_seq;
-    return std::mt19937_64(seed_seq);
-  }());
-  return rng.get();
-}
 
 std::string Generator<std::string>::operator()() const {
+  absl::InsecureBitGen gen;
   // NOLINTNEXTLINE(runtime/int)
   std::uniform_int_distribution<short> chars(0x20, 0x7E);
   std::string res;
   res.resize(32);
-  std::generate(res.begin(), res.end(),
-                [&]() { return chars(*GetSharedRng()); });
+  std::generate(res.begin(), res.end(), [&]() { return chars(gen); });
   return res;
 }
 
 absl::string_view Generator<absl::string_view>::operator()() const {
   static absl::NoDestructor<std::deque<std::string>> arena;
+  absl::InsecureBitGen gen;
   // NOLINTNEXTLINE(runtime/int)
   std::uniform_int_distribution<short> chars(0x20, 0x7E);
   arena->emplace_back();
   auto& res = arena->back();
   res.resize(32);
-  std::generate(res.begin(), res.end(),
-                [&]() { return chars(*GetSharedRng()); });
+  std::generate(res.begin(), res.end(), [&]() { return chars(gen); });
   return res;
 }