re2 1.24.0 → 1.25.0

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

@@ -14,7 +14,9 @@
 
 #include "absl/container/internal/compressed_tuple.h"
 
+#include <any>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <type_traits>
@@ -25,8 +27,6 @@
 #include "gtest/gtest.h"
 #include "absl/container/internal/test_instance_tracker.h"
 #include "absl/memory/memory.h"
-#include "absl/types/any.h"
-#include "absl/types/optional.h"
 #include "absl/utility/utility.h"
 
 // These are declared at global scope purely so that error messages
@@ -337,11 +337,11 @@ TEST(CompressedTupleTest, NoElements) {
 
 TEST(CompressedTupleTest, MoveOnlyElements) {
   CompressedTuple<std::unique_ptr<std::string>> str_tup(
-      absl::make_unique<std::string>("str"));
+      std::make_unique<std::string>("str"));
 
   CompressedTuple<CompressedTuple<std::unique_ptr<std::string>>,
                   std::unique_ptr<int>>
-  x(std::move(str_tup), absl::make_unique<int>(5));
+      x(std::move(str_tup), std::make_unique<int>(5));
 
   EXPECT_EQ(*x.get<0>().get<0>(), "str");
   EXPECT_EQ(*x.get<1>(), 5);
@@ -355,7 +355,7 @@ TEST(CompressedTupleTest, MoveOnlyElements) {
 
 TEST(CompressedTupleTest, MoveConstructionMoveOnlyElements) {
   CompressedTuple<std::unique_ptr<std::string>> base(
-      absl::make_unique<std::string>("str"));
+      std::make_unique<std::string>("str"));
   EXPECT_EQ(*base.get<0>(), "str");
 
   CompressedTuple<std::unique_ptr<std::string>> copy(std::move(base));
@@ -363,13 +363,13 @@ TEST(CompressedTupleTest, MoveConstructionMoveOnlyElements) {
 }
 
 TEST(CompressedTupleTest, AnyElements) {
-  any a(std::string("str"));
-  CompressedTuple<any, any&> x(any(5), a);
-  EXPECT_EQ(absl::any_cast<int>(x.get<0>()), 5);
-  EXPECT_EQ(absl::any_cast<std::string>(x.get<1>()), "str");
+  std::any a(std::string("str"));
+  CompressedTuple<std::any, std::any&> x(std::any(5), a);
+  EXPECT_EQ(std::any_cast<int>(x.get<0>()), 5);
+  EXPECT_EQ(std::any_cast<std::string>(x.get<1>()), "str");
 
   a = 0.5f;
-  EXPECT_EQ(absl::any_cast<float>(x.get<1>()), 0.5);
+  EXPECT_EQ(std::any_cast<float>(x.get<1>()), 0.5);
 }
 
 TEST(CompressedTupleTest, Constexpr) {
@@ -418,15 +418,15 @@ TEST(CompressedTupleTest, Constexpr) {
   EXPECT_EQ(trivial1, 0);
   EXPECT_EQ(trivial2, 0);
 
-  constexpr CompressedTuple<Empty<0>, NonTrivialStruct, absl::optional<int>>
+  constexpr CompressedTuple<Empty<0>, NonTrivialStruct, std::optional<int>>
       non_trivial = {};
   constexpr CallType non_trivial0 = non_trivial.get<0>().value();
   constexpr int non_trivial1 = non_trivial.get<1>().value();
-  constexpr absl::optional<int> non_trivial2 = non_trivial.get<2>();
+  constexpr std::optional<int> non_trivial2 = non_trivial.get<2>();
 
   EXPECT_EQ(non_trivial0, CallType::kConstRef);
   EXPECT_EQ(non_trivial1, 5);
-  EXPECT_EQ(non_trivial2, absl::nullopt);
+  EXPECT_EQ(non_trivial2, std::nullopt);
 
   static constexpr char data[] = "DEF";
   constexpr CompressedTuple<const char*> z(data);

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

@@ -63,8 +63,8 @@ void* Allocate(Alloc* alloc, size_t n) {
   static_assert(Alignment > 0, "");
   assert(n && "n must be positive");
   using M = AlignedType<Alignment>;
-  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
-  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
+  using A = typename std::allocator_traits<Alloc>::template rebind_alloc<M>;
+  using AT = typename std::allocator_traits<Alloc>::template rebind_traits<M>;
   // On macOS, "mem_alloc" is a #define with one argument defined in
   // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   // with the "foo(bar)" syntax.
@@ -81,7 +81,7 @@ template <class Allocator, class ValueType>
 constexpr auto IsDestructionTrivial() {
   constexpr bool result =
       std::is_trivially_destructible<ValueType>::value &&
-      std::is_same<typename absl::allocator_traits<
+      std::is_same<typename std::allocator_traits<
                        Allocator>::template rebind_alloc<char>,
                    std::allocator<char>>::value;
   return std::integral_constant<bool, result>();
@@ -94,8 +94,8 @@ void Deallocate(Alloc* alloc, void* p, size_t n) {
   static_assert(Alignment > 0, "");
   assert(n && "n must be positive");
   using M = AlignedType<Alignment>;
-  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
-  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
+  using A = typename std::allocator_traits<Alloc>::template rebind_alloc<M>;
+  using AT = typename std::allocator_traits<Alloc>::template rebind_traits<M>;
   // On macOS, "mem_alloc" is a #define with one argument defined in
   // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   // with the "foo(bar)" syntax.
@@ -110,8 +110,8 @@ namespace memory_internal {
 // specified in the tuple.
 template <class Alloc, class T, class Tuple, size_t... I>
 void ConstructFromTupleImpl(Alloc* alloc, T* ptr, Tuple&& t,
-                            absl::index_sequence<I...>) {
-  absl::allocator_traits<Alloc>::construct(
+                            std::index_sequence<I...>) {
+  std::allocator_traits<Alloc>::construct(
       *alloc, ptr, std::get<I>(std::forward<Tuple>(t))...);
 }
 
@@ -127,13 +127,13 @@ struct WithConstructedImplF {
 
 template <class T, class Tuple, size_t... Is, class F>
 decltype(std::declval<F>()(std::declval<T>())) WithConstructedImpl(
-    Tuple&& t, absl::index_sequence<Is...>, F&& f) {
+    Tuple&& t, std::index_sequence<Is...>, F&& f) {
   return WithConstructedImplF<T, F>{std::forward<F>(f)}(
       std::get<Is>(std::forward<Tuple>(t))...);
 }
 
 template <class T, size_t... Is>
-auto TupleRefImpl(T&& t, absl::index_sequence<Is...>)
+auto TupleRefImpl(T&& t, std::index_sequence<Is...>)
     -> decltype(std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...)) {
   // NOLINTNEXTLINE(bugprone-use-after-move)
   return std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...);
@@ -144,11 +144,11 @@ auto TupleRefImpl(T&& t, absl::index_sequence<Is...>)
 template <class T>
 auto TupleRef(T&& t) -> decltype(TupleRefImpl(
     std::forward<T>(t),
-    absl::make_index_sequence<
+    std::make_index_sequence<
         std::tuple_size<typename std::decay<T>::type>::value>())) {
   return TupleRefImpl(
       std::forward<T>(t),
-      absl::make_index_sequence<
+      std::make_index_sequence<
           std::tuple_size<typename std::decay<T>::type>::value>());
 }
 
@@ -169,7 +169,7 @@ template <class Alloc, class T, class Tuple>
 void ConstructFromTuple(Alloc* alloc, T* ptr, Tuple&& t) {
   memory_internal::ConstructFromTupleImpl(
       alloc, ptr, std::forward<Tuple>(t),
-      absl::make_index_sequence<
+      std::make_index_sequence<
           std::tuple_size<typename std::decay<Tuple>::type>::value>());
 }
 
@@ -180,7 +180,7 @@ decltype(std::declval<F>()(std::declval<T>())) WithConstructed(Tuple&& t,
                                                                F&& f) {
   return memory_internal::WithConstructedImpl<T>(
       std::forward<Tuple>(t),
-      absl::make_index_sequence<
+      std::make_index_sequence<
           std::tuple_size<typename std::decay<Tuple>::type>::value>(),
       std::forward<F>(f));
 }
@@ -350,11 +350,11 @@ union map_slot_type {
   ~map_slot_type() = delete;
   using value_type = std::pair<const K, V>;
   using mutable_value_type =
-      std::pair<absl::remove_const_t<K>, absl::remove_const_t<V>>;
+      std::pair<std::remove_const_t<K>, std::remove_const_t<V>>;
 
   value_type value;
   mutable_value_type mutable_value;
-  absl::remove_const_t<K> key;
+  std::remove_const_t<K> key;
 };
 
 template <class K, class V>
@@ -362,7 +362,7 @@ struct map_slot_policy {
   using slot_type = map_slot_type<K, V>;
   using value_type = std::pair<const K, V>;
   using mutable_value_type =
-      std::pair<absl::remove_const_t<K>, absl::remove_const_t<V>>;
+      std::pair<std::remove_const_t<K>, std::remove_const_t<V>>;
 
  private:
   static void emplace(slot_type* slot) {
@@ -397,11 +397,11 @@ struct map_slot_policy {
   static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
     emplace(slot);
     if (kMutableKeys::value) {
-      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
-                                                   std::forward<Args>(args)...);
+      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
+                                                  std::forward<Args>(args)...);
     } else {
-      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
-                                                   std::forward<Args>(args)...);
+      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
+                                                  std::forward<Args>(args)...);
     }
   }
 
@@ -410,11 +410,11 @@ struct map_slot_policy {
   static void construct(Allocator* alloc, slot_type* slot, slot_type* other) {
     emplace(slot);
     if (kMutableKeys::value) {
-      absl::allocator_traits<Allocator>::construct(
+      std::allocator_traits<Allocator>::construct(
           *alloc, &slot->mutable_value, std::move(other->mutable_value));
     } else {
-      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
-                                                   std::move(other->value));
+      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
+                                                  std::move(other->value));
     }
   }
 
@@ -423,16 +423,16 @@ struct map_slot_policy {
   static void construct(Allocator* alloc, slot_type* slot,
                         const slot_type* other) {
     emplace(slot);
-    absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
-                                                 other->value);
+    std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
+                                                other->value);
   }
 
   template <class Allocator>
   static auto destroy(Allocator* alloc, slot_type* slot) {
     if (kMutableKeys::value) {
-      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
+      std::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
     } else {
-      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
+      std::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
     }
     return IsDestructionTrivial<Allocator, value_type>();
   }
@@ -460,11 +460,11 @@ struct map_slot_policy {
     }
 
     if (kMutableKeys::value) {
-      absl::allocator_traits<Allocator>::construct(
+      std::allocator_traits<Allocator>::construct(
           *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
     } else {
-      absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
-                                                   std::move(old_slot->value));
+      std::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
+                                                  std::move(old_slot->value));
     }
     destroy(alloc, old_slot);
     return is_relocatable;
@@ -550,10 +550,20 @@ 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);
+  const T* slot = *static_cast<T**>(slot_ptr);
   return HashElement<Fn, kIsDefault>{*f, seed}(*slot);
 }
 
+// Type erased function to apply `Fn` to data inside of the `slot_ptr->first`.
+// The data is expected to have type `T`.
+template <class Fn, class T, bool kIsDefault>
+size_t TypeErasedDerefAndApplyToSlotFirstFn(const void* fn, void* slot_ptr,
+                                            size_t seed) {
+  const auto* f = static_cast<const Fn*>(fn);
+  const T* slot = *static_cast<T**>(slot_ptr);
+  return HashElement<Fn, kIsDefault>{*f, seed}(slot->first);
+}
+
 }  // namespace container_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

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

@@ -199,14 +199,14 @@ template <typename T, typename E = void>
 struct HasAbslContainerHash : std::false_type {};
 
 template <typename T>
-struct HasAbslContainerHash<T, absl::void_t<typename T::absl_container_hash>>
+struct HasAbslContainerHash<T, std::void_t<typename T::absl_container_hash>>
     : std::true_type {};
 
 template <typename T, typename E = void>
 struct HasAbslContainerEq : std::false_type {};
 
 template <typename T>
-struct HasAbslContainerEq<T, absl::void_t<typename T::absl_container_eq>>
+struct HasAbslContainerEq<T, std::void_t<typename T::absl_container_eq>>
     : std::true_type {};
 
 template <typename T, typename E = void>

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

@@ -47,7 +47,7 @@ template <class Container, class = void>
 struct IsMap : std::false_type {};
 
 template <class Map>
-struct IsMap<Map, absl::void_t<typename Map::mapped_type>> : std::true_type {};
+struct IsMap<Map, std::void_t<typename Map::mapped_type>> : std::true_type {};
 
 }  // namespace generator_internal
 
@@ -128,13 +128,13 @@ struct Generator<std::tuple<Ts...>> {
 template <class T>
 struct Generator<std::unique_ptr<T>> {
   std::unique_ptr<T> operator()() const {
-    return absl::make_unique<T>(Generator<T>()());
+    return std::make_unique<T>(Generator<T>()());
   }
 };
 
 template <class U>
-struct Generator<U, absl::void_t<decltype(std::declval<U&>().key()),
-                                 decltype(std::declval<U&>().value())>>
+struct Generator<U, std::void_t<decltype(std::declval<U&>().key()),
+                                decltype(std::declval<U&>().value())>>
     : Generator<std::pair<
           typename std::decay<decltype(std::declval<U&>().key())>::type,
           typename std::decay<decltype(std::declval<U&>().value())>::type>> {};

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

@@ -31,14 +31,14 @@ namespace container_internal {
 
 // Defines how slots are initialized/destroyed/moved.
 template <class Policy, class = void>
-struct hash_policy_traits : common_policy_traits<Policy> {
+  struct hash_policy_traits : common_policy_traits<Policy> {
   // The type of the keys stored in the hashtable.
   using key_type = typename Policy::key_type;
 
  private:
   struct ReturnKey {
     template <class Key,
-              absl::enable_if_t<std::is_lvalue_reference<Key>::value, int> = 0>
+              std::enable_if_t<std::is_lvalue_reference<Key>::value, int> = 0>
     static key_type& Impl(Key&& k, int) {
       return *std::launder(
           const_cast<key_type*>(std::addressof(std::forward<Key>(k))));
@@ -63,7 +63,7 @@ struct hash_policy_traits : common_policy_traits<Policy> {
   struct ConstantIteratorsImpl : std::false_type {};
 
   template <class P>
-  struct ConstantIteratorsImpl<P, absl::void_t<typename P::constant_iterators>>
+  struct ConstantIteratorsImpl<P, std::void_t<typename P::constant_iterators>>
       : P::constant_iterators {};
 
  public:

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

@@ -84,7 +84,7 @@ class NonIterableBitMask {
  public:
   explicit NonIterableBitMask(T mask) : mask_(mask) {}
 
-  explicit operator bool() const { return this->mask_ != 0; }
+  explicit operator bool() const { return mask_ != 0; }
 
   // Returns the index of the lowest *abstract* bit set in `self`.
   uint32_t LowestBitSet() const {
@@ -274,8 +274,12 @@ inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) {
 
 struct GroupSse2Impl {
   static constexpr size_t kWidth = 16;  // the number of slots per group
-  using BitMaskType = BitMask<uint16_t, kWidth>;
-  using NonIterableBitMaskType = NonIterableBitMask<uint16_t, kWidth>;
+  // There are only 16 bits, but using uint32_t instead of uint16_t allows for
+  // better codegen. In particular, there is no blsr instruction for a 16 bit
+  // register, but there is for a 32 bit register (used in BitMask::operator++).
+  using MaskInt = uint32_t;
+  using BitMaskType = BitMask<MaskInt, kWidth>;
+  using NonIterableBitMaskType = NonIterableBitMask<MaskInt, kWidth>;
 
   explicit GroupSse2Impl(const ctrl_t* pos) {
     ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
@@ -284,42 +288,35 @@ struct GroupSse2Impl {
   // Returns a bitmask representing the positions of slots that match hash.
   BitMaskType Match(h2_t hash) const {
     auto match = _mm_set1_epi8(static_cast<char>(hash));
-    return BitMaskType(
-        static_cast<uint16_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
+    return BitMaskType(MoveMask(_mm_cmpeq_epi8(match, ctrl)));
   }
 
   // Returns a bitmask representing the positions of empty slots.
   NonIterableBitMaskType MaskEmpty() const {
 #ifdef ABSL_INTERNAL_HAVE_SSSE3
     // This only works because ctrl_t::kEmpty is -128.
-    return NonIterableBitMaskType(
-        static_cast<uint16_t>(_mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl))));
+    return NonIterableBitMaskType(MoveMask(_mm_sign_epi8(ctrl, ctrl)));
 #else
     auto match = _mm_set1_epi8(static_cast<char>(ctrl_t::kEmpty));
-    return NonIterableBitMaskType(
-        static_cast<uint16_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
+    return NonIterableBitMaskType(MoveMask(_mm_cmpeq_epi8(match, ctrl)));
 #endif
   }
 
   // Returns a bitmask representing the positions of full slots.
   // Note: for `is_small()` tables group may contain the "same" slot twice:
   // original and mirrored.
-  BitMaskType MaskFull() const {
-    return BitMaskType(static_cast<uint16_t>(_mm_movemask_epi8(ctrl) ^ 0xffff));
-  }
+  BitMaskType MaskFull() const { return BitMaskType(MoveMask(ctrl) ^ 0xffff); }
 
   // Returns a bitmask representing the positions of non full slots.
   // Note: this includes: kEmpty, kDeleted, kSentinel.
   // It is useful in contexts when kSentinel is not present.
-  auto MaskNonFull() const {
-    return BitMaskType(static_cast<uint16_t>(_mm_movemask_epi8(ctrl)));
-  }
+  auto MaskNonFull() const { return BitMaskType(MoveMask(ctrl)); }
 
   // Returns a bitmask representing the positions of empty or deleted slots.
   NonIterableBitMaskType MaskEmptyOrDeleted() const {
     auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
-    return NonIterableBitMaskType(static_cast<uint16_t>(
-        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl))));
+    return NonIterableBitMaskType(
+        MoveMask(_mm_cmpgt_epi8_fixed(special, ctrl)));
   }
 
   // Returns a bitmask representing the positions of full or sentinel slots.
@@ -327,8 +324,8 @@ struct GroupSse2Impl {
   // original and mirrored.
   NonIterableBitMaskType MaskFullOrSentinel() const {
     auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel) - 1);
-    return NonIterableBitMaskType(static_cast<uint16_t>(
-        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(ctrl, special))));
+    return NonIterableBitMaskType(
+        MoveMask(_mm_cmpgt_epi8_fixed(ctrl, special)));
   }
 
   void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
@@ -344,6 +341,17 @@ struct GroupSse2Impl {
     _mm_storeu_si128(reinterpret_cast<__m128i*>(dst), res);
   }
 
+  static MaskInt MoveMask(__m128i xmm) {
+    auto mask = static_cast<MaskInt>(_mm_movemask_epi8(xmm));
+#ifdef __clang__
+    // TODO(b/472522597): Without the inline asm, clang ends up generating an
+    // unnecessary movzx to zero the upper bits of the output, but those bits
+    // are already zero. See https://godbolt.org/z/G6xW1Ecbx.
+    asm("" : "+r"(mask));  // NOLINT
+#endif
+    return mask;
+  }
+
   __m128i ctrl;
 };
 #endif  // ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2

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

@@ -22,6 +22,7 @@
 #include <cstdint>
 #include <functional>
 #include <limits>
+#include <utility>
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
@@ -81,7 +82,6 @@ void HashtablezInfo::PrepareForSampling(int64_t stride,
   capacity.store(0, std::memory_order_relaxed);
   size.store(0, std::memory_order_relaxed);
   num_erases.store(0, std::memory_order_relaxed);
-  num_insert_hits.store(0, std::memory_order_relaxed);
   num_rehashes.store(0, std::memory_order_relaxed);
   max_probe_length.store(0, std::memory_order_relaxed);
   total_probe_length.store(0, std::memory_order_relaxed);
@@ -148,7 +148,7 @@ HashtablezInfo* SampleSlow(SamplingState& next_sample,
                            size_t value_size, uint16_t soo_capacity) {
   if (ABSL_PREDICT_FALSE(ShouldForceSampling())) {
     next_sample.next_sample = 1;
-    const int64_t old_stride = exchange(next_sample.sample_stride, 1);
+    const int64_t old_stride = std::exchange(next_sample.sample_stride, 1);
     HashtablezInfo* result = GlobalHashtablezSampler().Register(
         old_stride, inline_element_size, key_size, value_size, soo_capacity);
     return result;

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

@@ -82,7 +82,6 @@ struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo> {
   std::atomic<size_t> capacity;
   std::atomic<size_t> size;
   std::atomic<size_t> num_erases;
-  std::atomic<size_t> num_insert_hits;
   std::atomic<size_t> num_rehashes;
   std::atomic<size_t> max_probe_length;
   std::atomic<size_t> total_probe_length;
@@ -111,16 +110,6 @@ struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo> {
 
 void RecordRehashSlow(HashtablezInfo* info, size_t total_probe_length);
 
-// This is inline to avoid calling convention overhead for an otherwise
-// lightweight operation.
-inline void RecordInsertHitSlow(HashtablezInfo* info) {
-  // We avoid fetch_add since no other thread should be mutating the table
-  // simultaneously without synchronization.
-  info->num_insert_hits.store(
-      info->num_insert_hits.load(std::memory_order_relaxed) + 1,
-      std::memory_order_relaxed);
-}
-
 void RecordReservationSlow(HashtablezInfo* info, size_t target_capacity);
 
 void RecordClearedReservationSlow(HashtablezInfo* info);
@@ -194,11 +183,6 @@ class HashtablezInfoHandle {
     RecordEraseSlow(info_);
   }
 
-  inline void RecordInsertHit() {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
-    RecordInsertHitSlow(info_);
-  }
-
   friend inline void swap(HashtablezInfoHandle& lhs,
                           HashtablezInfoHandle& rhs) {
     std::swap(lhs.info_, rhs.info_);
@@ -225,7 +209,6 @@ class HashtablezInfoHandle {
   inline void RecordInsertMiss(size_t /*hash*/,
                                size_t /*distance_from_desired*/) {}
   inline void RecordErase() {}
-  inline void RecordInsertHit() {}
 
   friend inline void swap(HashtablezInfoHandle& /*lhs*/,
                           HashtablezInfoHandle& /*rhs*/) {}

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

@@ -63,9 +63,10 @@ using ::testing::UnorderedElementsAre;
 
 std::vector<size_t> GetSizes(HashtablezSampler* s) {
   std::vector<size_t> res;
-  s->Iterate([&](const HashtablezInfo& info) {
+  EXPECT_EQ(s->Iterate([&](const HashtablezInfo& info) {
     res.push_back(info.size.load(std::memory_order_acquire));
-  });
+  }),
+            0);
   return res;
 }
 
@@ -99,7 +100,6 @@ TEST(HashtablezInfoTest, PrepareForSampling) {
   EXPECT_EQ(info.capacity.load(), 0);
   EXPECT_EQ(info.size.load(), 0);
   EXPECT_EQ(info.num_erases.load(), 0);
-  EXPECT_EQ(info.num_insert_hits.load(), 0);
   EXPECT_EQ(info.num_rehashes.load(), 0);
   EXPECT_EQ(info.max_probe_length.load(), 0);
   EXPECT_EQ(info.total_probe_length.load(), 0);
@@ -116,7 +116,6 @@ TEST(HashtablezInfoTest, PrepareForSampling) {
   info.capacity.store(1, std::memory_order_relaxed);
   info.size.store(1, std::memory_order_relaxed);
   info.num_erases.store(1, std::memory_order_relaxed);
-  info.num_insert_hits.store(1, std::memory_order_relaxed);
   info.max_probe_length.store(1, std::memory_order_relaxed);
   info.total_probe_length.store(1, std::memory_order_relaxed);
   info.hashes_bitwise_or.store(1, std::memory_order_relaxed);
@@ -131,7 +130,6 @@ TEST(HashtablezInfoTest, PrepareForSampling) {
   EXPECT_EQ(info.capacity.load(), 0);
   EXPECT_EQ(info.size.load(), 0);
   EXPECT_EQ(info.num_erases.load(), 0);
-  EXPECT_EQ(info.num_insert_hits.load(), 0);
   EXPECT_EQ(info.num_rehashes.load(), 0);
   EXPECT_EQ(info.max_probe_length.load(), 0);
   EXPECT_EQ(info.total_probe_length.load(), 0);
@@ -218,25 +216,6 @@ TEST(HashtablezInfoTest, RecordErase) {
   EXPECT_EQ(info.soo_capacity, 1);
 }
 
-TEST(HashtablezInfoTest, RecordInsertHit) {
-  const int64_t test_stride = 31;
-  const size_t test_element_size = 29;
-  const size_t test_key_size = 27;
-  const size_t test_value_size = 25;
-
-  HashtablezInfo info;
-  absl::MutexLock l(info.init_mu);
-  info.PrepareForSampling(test_stride, test_element_size,
-                          /*key_size=*/test_key_size,
-                          /*value_size=*/test_value_size,
-                          /*soo_capacity_value=*/1);
-  EXPECT_EQ(info.num_insert_hits.load(), 0);
-  RecordInsertHitSlow(&info);
-  EXPECT_EQ(info.num_insert_hits.load(), 1);
-  RecordInsertHitSlow(&info);
-  EXPECT_EQ(info.num_insert_hits.load(), 2);
-}
-
 TEST(HashtablezInfoTest, RecordRehash) {
   const int64_t test_stride = 33;
   const size_t test_element_size = 31;
@@ -381,19 +360,20 @@ TEST(HashtablezSamplerTest, Handle) {
   info->hashes_bitwise_and.store(0x12345678, std::memory_order_relaxed);
 
   bool found = false;
-  sampler.Iterate([&](const HashtablezInfo& h) {
+  EXPECT_EQ(sampler.Iterate([&](const HashtablezInfo& h) {
     if (&h == info) {
       EXPECT_EQ(h.weight, test_stride);
       EXPECT_EQ(h.hashes_bitwise_and.load(), 0x12345678);
       found = true;
     }
-  });
+  }),
+            0);
   EXPECT_TRUE(found);
 
   h.Unregister();
   h = HashtablezInfoHandle();
   found = false;
-  sampler.Iterate([&](const HashtablezInfo& h) {
+  EXPECT_EQ(sampler.Iterate([&](const HashtablezInfo& h) {
     if (&h == info) {
       // this will only happen if some other thread has resurrected the info
       // the old handle was using.
@@ -401,7 +381,8 @@ TEST(HashtablezSamplerTest, Handle) {
         found = true;
       }
     }
-  });
+  }),
+            0);
   EXPECT_FALSE(found);
 }
 #endif
@@ -487,9 +468,10 @@ TEST(HashtablezSamplerTest, MultiThreaded) {
           }
           case 2: {
             absl::Duration oldest = absl::ZeroDuration();
-            sampler.Iterate([&](const HashtablezInfo& info) {
+            EXPECT_EQ(sampler.Iterate([&](const HashtablezInfo& info) {
               oldest = std::max(oldest, absl::Now() - info.create_time);
-            });
+            }),
+                      0);
             ASSERT_GE(oldest, absl::ZeroDuration());
             break;
           }