grpc 1.84.1 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/container/internal/hashtablez_sampler.h

@@ -87,7 +87,6 @@ struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo> {
   std::atomic<size_t> total_probe_length;
   std::atomic<size_t> hashes_bitwise_or;
   std::atomic<size_t> hashes_bitwise_and;
-  std::atomic<size_t> hashes_bitwise_xor;
   std::atomic<size_t> max_reserve;
 
   // All of the fields below are set by `PrepareForSampling`, they must not be
@@ -97,7 +96,7 @@ struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo> {
   // the lock.
   static constexpr int kMaxStackDepth = 64;
   absl::Time create_time;
-  int32_t depth;
+  uint32_t depth;
   // The SOO capacity for this table in elements (not bytes). Note that sampled
   // tables are never SOO because we need to store the infoz handle on the heap.
   // Tables that would be SOO if not sampled should have: soo_capacity > 0 &&
@@ -118,8 +117,8 @@ void RecordClearedReservationSlow(HashtablezInfo* info);
 void RecordStorageChangedSlow(HashtablezInfo* info, size_t size,
                               size_t capacity);
 
-void RecordInsertSlow(HashtablezInfo* info, size_t hash,
-                      size_t distance_from_desired);
+void RecordInsertMissSlow(HashtablezInfo* info, size_t hash,
+                          size_t distance_from_desired);
 
 void RecordEraseSlow(HashtablezInfo* info);
 
@@ -174,9 +173,9 @@ class HashtablezInfoHandle {
     RecordClearedReservationSlow(info_);
   }
 
-  inline void RecordInsert(size_t hash, size_t distance_from_desired) {
+  inline void RecordInsertMiss(size_t hash, size_t distance_from_desired) {
     if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
-    RecordInsertSlow(info_, hash, distance_from_desired);
+    RecordInsertMissSlow(info_, hash, distance_from_desired);
   }
 
   inline void RecordErase() {
@@ -207,7 +206,8 @@ class HashtablezInfoHandle {
   inline void RecordRehash(size_t /*total_probe_length*/) {}
   inline void RecordReservation(size_t /*target_capacity*/) {}
   inline void RecordClearedReservation() {}
-  inline void RecordInsert(size_t /*hash*/, size_t /*distance_from_desired*/) {}
+  inline void RecordInsertMiss(size_t /*hash*/,
+                               size_t /*distance_from_desired*/) {}
   inline void RecordErase() {}
 
   friend inline void swap(HashtablezInfoHandle& /*lhs*/,

data/third_party/abseil-cpp/absl/container/internal/inlined_vector.h

@@ -27,7 +27,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
-#include "absl/base/internal/identity.h"
+#include "absl/base/internal/hardening.h"
 #include "absl/base/macros.h"
 #include "absl/container/internal/compressed_tuple.h"
 #include "absl/memory/memory.h"
@@ -80,7 +80,7 @@ using IsSwapOk = absl::type_traits_internal::IsSwappable<ValueType<A>>;
 
 template <typename A,
           bool IsTriviallyDestructible =
-              absl::is_trivially_destructible<ValueType<A>>::value &&
+              std::is_trivially_destructible<ValueType<A>>::value &&
               std::is_same<A, std::allocator<ValueType<A>>>::value>
 struct DestroyAdapter;
 
@@ -127,7 +127,7 @@ struct MallocAdapter {
 };
 
 template <typename A, typename ValueAdapter>
-void ConstructElements(absl::internal::type_identity_t<A>& allocator,
+void ConstructElements(absl::type_identity_t<A>& allocator,
                        Pointer<A> construct_first, ValueAdapter& values,
                        SizeType<A> construct_size) {
   for (SizeType<A> i = 0; i < construct_size; ++i) {
@@ -289,14 +289,14 @@ class Storage {
   struct ElementwiseSwapPolicy {};
   struct ElementwiseConstructPolicy {};
 
-  using MoveAssignmentPolicy = absl::conditional_t<
+  using MoveAssignmentPolicy = std::conditional_t<
       // Fast path: if the value type can be trivially move assigned and
       // destroyed, and we know the allocator doesn't do anything fancy, then
       // it's safe for us to simply adopt the contents of the storage for
       // `other` and remove its own reference to them. It's as if we had
       // individually move-assigned each value and then destroyed the original.
-      absl::conjunction<absl::is_trivially_move_assignable<ValueType<A>>,
-                        absl::is_trivially_destructible<ValueType<A>>,
+      std::conjunction<std::is_trivially_move_assignable<ValueType<A>>,
+                        std::is_trivially_destructible<ValueType<A>>,
                         std::is_same<A, std::allocator<ValueType<A>>>>::value,
       MemcpyPolicy,
       // Otherwise we use move assignment if possible. If not, we simulate
@@ -305,21 +305,21 @@ class Storage {
       // Note that this is in contrast to e.g. std::vector and std::optional,
       // which are themselves not move-assignable when their contained type is
       // not.
-      absl::conditional_t<IsMoveAssignOk<A>::value, ElementwiseAssignPolicy,
+      std::conditional_t<IsMoveAssignOk<A>::value, ElementwiseAssignPolicy,
                           ElementwiseConstructPolicy>>;
 
   // The policy to be used specifically when swapping inlined elements.
-  using SwapInlinedElementsPolicy = absl::conditional_t<
+  using SwapInlinedElementsPolicy = std::conditional_t<
       // Fast path: if the value type can be trivially relocated, and we
       // know the allocator doesn't do anything fancy, then it's safe for us
       // to simply swap the bytes in the inline storage. It's as if we had
       // relocated the first vector's elements into temporary storage,
       // relocated the second's elements into the (now-empty) first's,
       // and then relocated from temporary storage into the second.
-      absl::conjunction<absl::is_trivially_relocatable<ValueType<A>>,
+      std::conjunction<absl::is_trivially_relocatable<ValueType<A>>,
                         std::is_same<A, std::allocator<ValueType<A>>>>::value,
       MemcpyPolicy,
-      absl::conditional_t<IsSwapOk<A>::value, ElementwiseSwapPolicy,
+      std::conditional_t<IsSwapOk<A>::value, ElementwiseSwapPolicy,
                           ElementwiseConstructPolicy>>;
 
   static SizeType<A> NextCapacity(SizeType<A> current_capacity) {
@@ -349,7 +349,7 @@ class Storage {
     // Fast path: if no destructors need to be run and we know the allocator
     // doesn't do anything fancy, then all we need to do is deallocate (and
     // maybe not even that).
-    if (absl::is_trivially_destructible<ValueType<A>>::value &&
+    if (std::is_trivially_destructible<ValueType<A>>::value &&
         std::is_same<A, std::allocator<ValueType<A>>>::value) {
       DeallocateIfAllocated();
       return;
@@ -477,7 +477,7 @@ class Storage {
   }
 
   void SubtractSize(SizeType<A> count) {
-    ABSL_HARDENING_ASSERT(count <= GetSize());
+    absl::base_internal::HardeningAssertLE(count, GetSize());
 
     GetSizeAndIsAllocated() -= count << static_cast<SizeType<A>>(1);
   }
@@ -501,18 +501,17 @@ class Storage {
     //
     {
       using V = ValueType<A>;
-      ABSL_HARDENING_ASSERT(
-          other_storage.GetIsAllocated() ||
-          (std::is_same<A, std::allocator<V>>::value &&
-           (
-               // First case above
-               absl::is_trivially_relocatable<V>::value ||
-               // Second case above
-               (absl::is_trivially_move_assignable<V>::value &&
-                absl::is_trivially_destructible<V>::value) ||
-               // Third case above
-               (absl::is_trivially_copy_constructible<V>::value ||
-                absl::is_trivially_copy_assignable<V>::value))));
+      ABSL_ASSERT(other_storage.GetIsAllocated() ||
+                  (std::is_same<A, std::allocator<V>>::value &&
+                   (
+                       // First case above
+                       absl::is_trivially_relocatable<V>::value ||
+                       // Second case above
+                       (std::is_trivially_move_assignable<V>::value &&
+                        std::is_trivially_destructible<V>::value) ||
+                       // Third case above
+                       (std::is_trivially_copy_constructible<V>::value ||
+                        std::is_trivially_copy_assignable<V>::value))));
     }
 
     GetSizeAndIsAllocated() = other_storage.GetSizeAndIsAllocated();
@@ -576,7 +575,7 @@ void Storage<T, N, A>::DestroyContents() {
 template <typename T, size_t N, typename A>
 void Storage<T, N, A>::InitFrom(const Storage& other) {
   const SizeType<A> n = other.GetSize();
-  ABSL_HARDENING_ASSERT(n > 0);  // Empty sources handled handled in caller.
+  ABSL_ASSERT(n > 0);  // Empty sources handled in caller.
   ConstPointer<A> src;
   Pointer<A> dst;
   if (!other.GetIsAllocated()) {
@@ -597,7 +596,7 @@ void Storage<T, N, A>::InitFrom(const Storage& other) {
   // Fast path: if the value type is trivially copy constructible and we know
   // the allocator doesn't do anything fancy, then we know it is legal for us to
   // simply memcpy the other vector's elements.
-  if (absl::is_trivially_copy_constructible<ValueType<A>>::value &&
+  if (std::is_trivially_copy_constructible<ValueType<A>>::value &&
       std::is_same<A, std::allocator<ValueType<A>>>::value) {
     std::memcpy(reinterpret_cast<char*>(dst),
                 reinterpret_cast<const char*>(src), n * sizeof(ValueType<A>));
@@ -614,8 +613,8 @@ template <typename ValueAdapter>
 auto Storage<T, N, A>::Initialize(ValueAdapter values,
                                   SizeType<A> new_size) -> void {
   // Only callable from constructors!
-  ABSL_HARDENING_ASSERT(!GetIsAllocated());
-  ABSL_HARDENING_ASSERT(GetSize() == 0);
+  ABSL_ASSERT(!GetIsAllocated());
+  ABSL_ASSERT(GetSize() == 0);
 
   Pointer<A> construct_data;
   if (new_size > GetInlinedCapacity()) {
@@ -796,16 +795,9 @@ auto Storage<T, N, A>::Insert(ConstIterator<A> pos, ValueAdapter values,
                                    move_construction_values,
                                    move_construction.size());
 
-    for (Pointer<A>
-             destination = move_assignment.data() + move_assignment.size(),
-             last_destination = move_assignment.data(),
-             source = move_assignment_values + move_assignment.size();
-         ;) {
-      --destination;
-      --source;
-      if (destination < last_destination) break;
-      *destination = std::move(*source);
-    }
+    std::move_backward(move_assignment_values,
+                       move_assignment_values + move_assignment.size(),
+                       move_assignment.data() + move_assignment.size());
 
     AssignElements<A>(insert_assignment.data(), values,
                       insert_assignment.size());
@@ -938,7 +930,7 @@ auto Storage<T, N, A>::Reserve(SizeType<A> requested_capacity) -> void {
 template <typename T, size_t N, typename A>
 auto Storage<T, N, A>::ShrinkToFit() -> void {
   // May only be called on allocated instances!
-  ABSL_HARDENING_ASSERT(GetIsAllocated());
+  ABSL_ASSERT(GetIsAllocated());
 
   StorageView<A> storage_view{GetAllocatedData(), GetSize(),
                               GetAllocatedCapacity()};
@@ -987,7 +979,7 @@ auto Storage<T, N, A>::ShrinkToFit() -> void {
 template <typename T, size_t N, typename A>
 auto Storage<T, N, A>::Swap(Storage* other_storage_ptr) -> void {
   using std::swap;
-  ABSL_HARDENING_ASSERT(this != other_storage_ptr);
+  ABSL_ASSERT(this != other_storage_ptr);
 
   if (GetIsAllocated() && other_storage_ptr->GetIsAllocated()) {
     swap(data_.allocated, other_storage_ptr->data_.allocated);

data/third_party/abseil-cpp/absl/container/internal/layout.h

@@ -261,7 +261,7 @@ struct AlignOf<Aligned<T, N>> {
 
 // Does `Ts...` contain `T`?
 template <class T, class... Ts>
-using Contains = absl::disjunction<std::is_same<T, Ts>...>;
+using Contains = std::disjunction<std::is_same<T, Ts>...>;
 
 template <class From, class To>
 using CopyConst =
@@ -346,13 +346,13 @@ class LayoutImpl;
 // can compute offsets).
 template <class... Elements, size_t... StaticSizeSeq, size_t... RuntimeSizeSeq,
           size_t... SizeSeq, size_t... OffsetSeq>
-class LayoutImpl<
-    std::tuple<Elements...>, absl::index_sequence<StaticSizeSeq...>,
-    absl::index_sequence<RuntimeSizeSeq...>, absl::index_sequence<SizeSeq...>,
-    absl::index_sequence<OffsetSeq...>> {
+class LayoutImpl<std::tuple<Elements...>, std::index_sequence<StaticSizeSeq...>,
+                 std::index_sequence<RuntimeSizeSeq...>,
+                 std::index_sequence<SizeSeq...>,
+                 std::index_sequence<OffsetSeq...>> {
  private:
   static_assert(sizeof...(Elements) > 0, "At least one field is required");
-  static_assert(absl::conjunction<IsLegalElementType<Elements>...>::value,
+  static_assert(std::conjunction<IsLegalElementType<Elements>...>::value,
                 "Invalid element type (see IsLegalElementType)");
   static_assert(sizeof...(StaticSizeSeq) <= sizeof...(Elements),
                 "Too many static sizes specified");
@@ -687,10 +687,9 @@ class LayoutImpl<
 
 template <class StaticSizeSeq, size_t NumRuntimeSizes, class... Ts>
 using LayoutType = LayoutImpl<
-    std::tuple<Ts...>, StaticSizeSeq,
-    absl::make_index_sequence<NumRuntimeSizes>,
-    absl::make_index_sequence<NumRuntimeSizes + StaticSizeSeq::size()>,
-    absl::make_index_sequence<adl_barrier::Min(
+    std::tuple<Ts...>, StaticSizeSeq, std::make_index_sequence<NumRuntimeSizes>,
+    std::make_index_sequence<NumRuntimeSizes + StaticSizeSeq::size()>,
+    std::make_index_sequence<adl_barrier::Min(
         sizeof...(Ts), NumRuntimeSizes + StaticSizeSeq::size() + 1)>>;
 
 template <class StaticSizeSeq, class... Ts>
@@ -793,11 +792,12 @@ class LayoutWithStaticSizes
 // internal_layout::LayoutImpl above. Those types are internal to the library
 // but their methods are public, and they are inherited by `Layout`.
 template <class... Ts>
-class Layout : public internal_layout::LayoutWithStaticSizes<
-                   absl::make_index_sequence<0>, Ts...> {
+class Layout
+    : public internal_layout::LayoutWithStaticSizes<std::make_index_sequence<0>,
+                                                    Ts...> {
  private:
   using Super =
-      internal_layout::LayoutWithStaticSizes<absl::make_index_sequence<0>,
+      internal_layout::LayoutWithStaticSizes<std::make_index_sequence<0>,
                                              Ts...>;
 
  public:

data/third_party/abseil-cpp/absl/container/internal/raw_hash_map.h

@@ -21,7 +21,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
-#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/throw_delegate.h"
 #include "absl/container/internal/common_policy_traits.h"
 #include "absl/container/internal/container_memory.h"
 #include "absl/container/internal/raw_hash_set.h"  // IWYU pragma: export
@@ -31,8 +31,20 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
-template <class Policy, class Hash, class Eq, class Alloc>
-class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
+template <class Policy, class... Params>
+class raw_hash_map;
+
+template <typename Policy, typename Hash, typename Eq, typename Alloc>
+struct InstantiateRawHashMap {
+  using type = typename ApplyWithoutDefaultSuffix<
+      raw_hash_map,
+      TypeList<int, typename Policy::DefaultHash, typename Policy::DefaultEq,
+               typename Policy::DefaultAlloc>,
+      TypeList<Policy, Hash, Eq, Alloc>>::type;
+};
+
+template <class Policy, class... Params>
+class raw_hash_map : public raw_hash_set<Policy, Params...> {
   // P is Policy. It's passed as a template argument to support maps that have
   // incomplete types as values, as in unordered_map<K, IncompleteType>.
   // MappedReference<> may be a non-reference type.
@@ -45,6 +57,10 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
   using MappedConstReference = decltype(P::value(
       std::addressof(std::declval<typename raw_hash_map::const_reference>())));
 
+  using Hash = typename raw_hash_map::raw_hash_set::hasher;
+  using Eq = typename raw_hash_map::raw_hash_set::key_equal;
+  using Alloc = typename raw_hash_map::raw_hash_set::allocator_type;
+
   template <class K>
   using key_arg =
       typename KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>::
@@ -72,8 +88,8 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
                           typename Policy::mapped_type, V>>;
   template <class K, bool KValue, class V, bool VValue, typename... Dummy>
   using LifetimeBoundKV =
-      absl::conjunction<LifetimeBoundK<K, KValue, absl::void_t<Dummy...>>,
-                        LifetimeBoundV<V, VValue>>;
+      std::conjunction<LifetimeBoundK<K, KValue, std::void_t<Dummy...>>,
+                       LifetimeBoundV<V, VValue>>;
 
  public:
   using key_type = typename Policy::key_type;
@@ -109,7 +125,7 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
                                           IfRRef<int KQual>::AddPtr<K>,        \
                                           IfRRef<int VQual>::AddPtr<V>>>()),   \
           ABSL_INTERNAL_SINGLE_ARG(                                            \
-              int &...,                                                        \
+              int&...,                                                         \
               decltype(EnableIf<LifetimeBoundKV<K, KValue, V, VValue>>()) =    \
                   0))>                                                         \
   decltype(auto) Func(                                                         \
@@ -123,31 +139,31 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
   }                                                                            \
   static_assert(true, "This is to force a semicolon.")
 
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, const &,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, const&,
                   false, false, ABSL_INTERNAL_SINGLE_ARG());
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, const &,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, const&,
                   false, true, ABSL_INTERNAL_SINGLE_ARG());
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, const &,
-                  true, false, ABSL_INTERNAL_SINGLE_ARG());
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, const &,
-                  true, true, ABSL_INTERNAL_SINGLE_ARG());
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, const&, true,
+                  false, ABSL_INTERNAL_SINGLE_ARG());
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, const&, true,
+                  true, ABSL_INTERNAL_SINGLE_ARG());
 
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, &&, false,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, &&, false,
                   false, ABSL_INTERNAL_SINGLE_ARG());
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, &&, false,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, &&, false,
                   true, ABSL_INTERNAL_SINGLE_ARG());
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, &&, true,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, &&, true,
                   false, ABSL_INTERNAL_SINGLE_ARG());
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, &&, true,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, &&, true,
                   true, ABSL_INTERNAL_SINGLE_ARG());
 
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const &, false,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const&, false,
                   false, ABSL_INTERNAL_SINGLE_ARG());
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const &, false,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const&, false,
                   true, ABSL_INTERNAL_SINGLE_ARG());
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const &, true,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const&, true,
                   false, ABSL_INTERNAL_SINGLE_ARG());
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const &, true,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const&, true,
                   true, ABSL_INTERNAL_SINGLE_ARG());
 
   ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, &&, false, false,
@@ -159,31 +175,31 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
   ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, &&, true, true,
                   ABSL_INTERNAL_SINGLE_ARG());
 
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, const &,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, const&,
                   false, false, .first, const_iterator ABSL_INTERNAL_COMMA);
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, const &,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, const&,
                   false, true, .first, const_iterator ABSL_INTERNAL_COMMA);
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, const &,
-                  true, false, .first, const_iterator ABSL_INTERNAL_COMMA);
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, const &,
-                  true, true, .first, const_iterator ABSL_INTERNAL_COMMA);
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, const&, true,
+                  false, .first, const_iterator ABSL_INTERNAL_COMMA);
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, const&, true,
+                  true, .first, const_iterator ABSL_INTERNAL_COMMA);
 
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, &&, false,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, &&, false,
                   false, .first, const_iterator ABSL_INTERNAL_COMMA);
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, &&, false,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, &&, false,
                   true, .first, const_iterator ABSL_INTERNAL_COMMA);
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, &&, true,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, &&, true,
                   false, .first, const_iterator ABSL_INTERNAL_COMMA);
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const &, &&, true,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, const&, &&, true,
                   true, .first, const_iterator ABSL_INTERNAL_COMMA);
 
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const &, false,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const&, false,
                   false, .first, const_iterator ABSL_INTERNAL_COMMA);
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const &, false,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const&, false,
                   true, .first, const_iterator ABSL_INTERNAL_COMMA);
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const &, true,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const&, true,
                   false, .first, const_iterator ABSL_INTERNAL_COMMA);
-  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const &, true,
+  ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, const&, true,
                   true, .first, const_iterator ABSL_INTERNAL_COMMA);
 
   ABSL_INTERNAL_X(insert_or_assign, insert_or_assign_impl, &&, &&, false, false,
@@ -199,23 +215,24 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
   // All `try_emplace()` overloads make the same guarantees regarding rvalue
   // arguments as `std::unordered_map::try_emplace()`, namely that these
   // functions will not move from rvalue arguments if insertions do not happen.
-  template <class K = key_type, int = EnableIf<LifetimeBoundK<K, false, K *>>(),
+  template <class K = key_type, int = EnableIf<LifetimeBoundK<K, false, K*>>(),
             class... Args,
             typename std::enable_if<
                 !std::is_convertible<K, const_iterator>::value, int>::type = 0>
-  std::pair<iterator, bool> try_emplace(key_arg<K> &&k, Args &&...args)
+  std::pair<iterator, bool> try_emplace(key_arg<K>&& k, Args&&... args)
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
+    return try_emplace_impl(std::forward<key_arg<K>>(k),
+                            std::forward<Args>(args)...);
   }
 
   template <class K = key_type, class... Args,
-            EnableIf<LifetimeBoundK<K, true, K *>> = 0,
+            EnableIf<LifetimeBoundK<K, true, K*>> = 0,
             typename std::enable_if<
                 !std::is_convertible<K, const_iterator>::value, int>::type = 0>
   std::pair<iterator, bool> try_emplace(
-      key_arg<K> &&k ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this),
-      Args &&...args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return this->template try_emplace<K, 0>(std::forward<K>(k),
+      key_arg<K>&& k ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this),
+      Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return this->template try_emplace<K, 0>(std::forward<key_arg<K>>(k),
                                             std::forward<Args>(args)...);
   }
 
@@ -223,7 +240,7 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
             class... Args,
             typename std::enable_if<
                 !std::is_convertible<K, const_iterator>::value, int>::type = 0>
-  std::pair<iterator, bool> try_emplace(const key_arg<K> &k, Args &&...args)
+  std::pair<iterator, bool> try_emplace(const key_arg<K>& k, Args&&... args)
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return try_emplace_impl(k, std::forward<Args>(args)...);
   }
@@ -232,39 +249,40 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
             typename std::enable_if<
                 !std::is_convertible<K, const_iterator>::value, int>::type = 0>
   std::pair<iterator, bool> try_emplace(
-      const key_arg<K> &k ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this),
-      Args &&...args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
+      const key_arg<K>& k ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this),
+      Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return this->template try_emplace<K, 0>(k, std::forward<Args>(args)...);
   }
 
-  template <class K = key_type, int = EnableIf<LifetimeBoundK<K, false, K *>>(),
+  template <class K = key_type, int = EnableIf<LifetimeBoundK<K, false, K*>>(),
             class... Args>
-  iterator try_emplace(const_iterator, key_arg<K> &&k,
-                       Args &&...args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return try_emplace(std::forward<K>(k), std::forward<Args>(args)...).first;
+  iterator try_emplace(const_iterator, key_arg<K>&& k,
+                       Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return try_emplace(std::forward<key_arg<K>>(k), std::forward<Args>(args)...)
+        .first;
   }
   template <class K = key_type, class... Args,
-            EnableIf<LifetimeBoundK<K, true, K *>> = 0>
+            EnableIf<LifetimeBoundK<K, true, K*>> = 0>
   iterator try_emplace(const_iterator hint,
-                       key_arg<K> &&k ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this),
-                       Args &&...args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return this->template try_emplace<K, 0>(hint, std::forward<K>(k),
+                       key_arg<K>&& k ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this),
+                       Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return this->template try_emplace<K, 0>(hint, std::forward<key_arg<K>>(k),
                                             std::forward<Args>(args)...);
   }
 
   template <class K = key_type, int = EnableIf<LifetimeBoundK<K, false>>(),
             class... Args>
-  iterator try_emplace(const_iterator, const key_arg<K> &k,
-                       Args &&...args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  iterator try_emplace(const_iterator, const key_arg<K>& k,
+                       Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return try_emplace(k, std::forward<Args>(args)...).first;
   }
   template <class K = key_type, class... Args,
             EnableIf<LifetimeBoundK<K, true>> = 0>
   iterator try_emplace(const_iterator hint,
-                       const key_arg<K> &k
+                       const key_arg<K>& k
                            ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this),
-                       Args &&...args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return this->template try_emplace<K, 0>(hint, std::forward<K>(k),
+                       Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return this->template try_emplace<K, 0>(hint, k,
                                             std::forward<Args>(args)...);
   }
 
@@ -272,8 +290,7 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
   MappedReference<P> at(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
     auto it = this->find(key);
     if (it == this->end()) {
-      base_internal::ThrowStdOutOfRange(
-          "absl::container_internal::raw_hash_map<>::at");
+      ThrowStdOutOfRange("absl::container_internal::raw_hash_map<>::at");
     }
     return Policy::value(&*it);
   }
@@ -283,48 +300,54 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     auto it = this->find(key);
     if (it == this->end()) {
-      base_internal::ThrowStdOutOfRange(
-          "absl::container_internal::raw_hash_map<>::at");
+      ThrowStdOutOfRange("absl::container_internal::raw_hash_map<>::at");
     }
     return Policy::value(&*it);
   }
 
   template <class K = key_type, class P = Policy,
-            int = EnableIf<LifetimeBoundK<K, false, K *>>()>
-  MappedReference<P> operator[](key_arg<K> &&key)
+            int = EnableIf<LifetimeBoundK<K, false, K*>>()>
+  MappedReference<P> operator[](key_arg<K>&& key)
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     // It is safe to use unchecked_deref here because try_emplace
     // will always return an iterator pointing to a valid item in the table,
     // since it inserts if nothing is found for the given key.
-    return Policy::value(
-        &this->unchecked_deref(try_emplace(std::forward<K>(key)).first));
+    return Policy::value(&this->unchecked_deref(
+        try_emplace(std::forward<key_arg<K>>(key)).first));
   }
-  template <class K = key_type, class P = Policy, int &...,
-            EnableIf<LifetimeBoundK<K, true, K *>> = 0>
+  template <class K = key_type, class P = Policy, int&...,
+            EnableIf<LifetimeBoundK<K, true, K*>> = 0>
   MappedReference<P> operator[](
-      key_arg<K> &&key ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this))
+      key_arg<K>&& key ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this))
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return this->template operator[]<K, P, 0>(std::forward<K>(key));
+    return this->template operator[]<K, P, 0>(std::forward<key_arg<K>>(key));
   }
 
   template <class K = key_type, class P = Policy,
             int = EnableIf<LifetimeBoundK<K, false>>()>
-  MappedReference<P> operator[](const key_arg<K> &key)
+  MappedReference<P> operator[](const key_arg<K>& key)
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     // It is safe to use unchecked_deref here because try_emplace
     // will always return an iterator pointing to a valid item in the table,
     // since it inserts if nothing is found for the given key.
     return Policy::value(&this->unchecked_deref(try_emplace(key).first));
   }
-  template <class K = key_type, class P = Policy, int &...,
+  template <class K = key_type, class P = Policy, int&...,
             EnableIf<LifetimeBoundK<K, true>> = 0>
   MappedReference<P> operator[](
-      const key_arg<K> &key ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this))
+      const key_arg<K>& key ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this))
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return this->template operator[]<K, P, 0>(key);
   }
 
  private:
+  static_assert(
+      std::is_same_v<
+          typename InstantiateRawHashMap<Policy, Hash, Eq, Alloc>::type,
+          raw_hash_map>,
+      "Redundant template parameters were passed. Use InstantiateRawHashMap<> "
+      "instead");
+
   template <class K, class V>
   std::pair<iterator, bool> insert_or_assign_impl(K&& k, V&& v)
       ABSL_ATTRIBUTE_LIFETIME_BOUND {