Use type-erased slot hash functions for all flat_hash_map and node_hash_map types.

First is always at offset 0 of std::pair<const K, V> and std::pair<K, V>. Assert via offsetof that first is at offset 0 and unconditionally use GetTypeErasedApplyToSlotFn and GetTypeErasedDerefAndApplyToSlotFn.

PiperOrigin-RevId: 1018570126
diff --git a/absl/container/flat_hash_map.h b/absl/container/flat_hash_map.h
index 40d44e2..06e8f9c 100644
--- a/absl/container/flat_hash_map.h
+++ b/absl/container/flat_hash_map.h
@@ -706,9 +706,8 @@
 
   template <class Hash, bool kIsDefault, size_t kSeedShift>
   static constexpr HashSlotFn get_hash_slot_fn() {
-    return memory_internal::IsLayoutCompatible<K, V>::value
-               ? GetTypeErasedApplyToSlotFn<Hash, K, kIsDefault, kSeedShift>()
-               : nullptr;
+    memory_internal::AssertPairFirstAtOffsetZero<K, V>();
+    return GetTypeErasedApplyToSlotFn<Hash, K, kIsDefault, kSeedShift>();
   }
 
   static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
diff --git a/absl/container/flat_hash_map_test.cc b/absl/container/flat_hash_map_test.cc
index 2daa235..3d1698e 100644
--- a/absl/container/flat_hash_map_test.cc
+++ b/absl/container/flat_hash_map_test.cc
@@ -425,6 +425,24 @@
                          std::allocator<char>>(nullptr, nullptr))()));
 }
 
+TEST(FlatHashMap, NonStandardLayoutKeyAndValueUseTypeErasedSlotFns) {
+  using Policy = FlatHashMapPolicy<NonStandardLayout, NonStandardLayout>;
+  EXPECT_NE((Policy::get_hash_slot_fn<absl::Hash<NonStandardLayout>,
+                                      /*kIsDefault=*/true, /*kSeedShift=*/0>()),
+            nullptr);
+
+  flat_hash_map<NonStandardLayout, NonStandardLayout> m;
+  for (int i = 0; i < 30; ++i) {
+    m.try_emplace(NonStandardLayout(std::to_string(i)),
+                  NonStandardLayout(std::to_string(i * 10)));
+  }
+  for (int i = 0; i < 30; ++i) {
+    auto it = m.find(NonStandardLayout(std::to_string(i)));
+    ASSERT_NE(it, m.end());
+    EXPECT_EQ(it->second, NonStandardLayout(std::to_string(i * 10)));
+  }
+}
+
 struct InconsistentHashEqType {
   InconsistentHashEqType(int v1, int v2) : v1(v1), v2(v2) {}
   template <typename H>
diff --git a/absl/container/internal/container_memory.h b/absl/container/internal/container_memory.h
index f3057d1..146372d 100644
--- a/absl/container/internal/container_memory.h
+++ b/absl/container/internal/container_memory.h
@@ -399,6 +399,25 @@
                                 LayoutCompatible<std::pair<const K, V>>();
 };
 
+// Asserts that `first` is at offset 0 of `std::pair<const K, V>` and
+// `std::pair<K, V>`. `offsetof` on a non-standard-layout type is
+// conditionally-supported, but all the compilers we care about support it for
+// direct non-static data members.
+template <class K, class V>
+constexpr void AssertPairFirstAtOffsetZero() {
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winvalid-offsetof"
+#endif
+  using Pair = std::pair<const K, V>;
+  static_assert(offsetof(Pair, first) == 0);
+  using MutablePair = std::pair<std::remove_const_t<K>, std::remove_const_t<V>>;
+  static_assert(offsetof(MutablePair, first) == 0);
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+}
+
 }  // namespace memory_internal
 
 // The internal storage type for key-value containers like flat_hash_map.
@@ -682,8 +701,7 @@
   // NodeHashMapPolicy::get_hash_slot_fn(). In that case, slot_ptr has type
   // `std::pair<const T, mapped_type>**`, which is not safe to dereference as
   // `const T**`. Note that it is safe to dereference `slot` afterwards because
-  // `IsLayoutCompatible` guarantees that `std::pair<const T, mapped_type>` is
-  // standard-layout.
+  // `std::pair<const T, mapped_type>::first` is at offset 0.
   std::memcpy(&slot, slot_ptr, sizeof(slot));
   return HashElement<Fn, kIsAbsl, kSeedShift>{*f, seed}(*slot);
 }
diff --git a/absl/container/node_hash_map.h b/absl/container/node_hash_map.h
index 61f2b52..e687391 100644
--- a/absl/container/node_hash_map.h
+++ b/absl/container/node_hash_map.h
@@ -684,10 +684,8 @@
 
   template <class Hash, bool kIsAbsl, size_t kSeedShift>
   static constexpr HashSlotFn get_hash_slot_fn() {
-    return memory_internal::IsLayoutCompatible<Key, Value>::value
-               ? GetTypeErasedDerefAndApplyToSlotFn<Hash, Key, kIsAbsl,
-                                                    kSeedShift>()
-               : nullptr;
+    memory_internal::AssertPairFirstAtOffsetZero<Key, Value>();
+    return GetTypeErasedDerefAndApplyToSlotFn<Hash, Key, kIsAbsl, kSeedShift>();
   }
 };
 }  // namespace container_internal
diff --git a/absl/container/node_hash_map_test.cc b/absl/container/node_hash_map_test.cc
index 476b12f..9deb04d 100644
--- a/absl/container/node_hash_map_test.cc
+++ b/absl/container/node_hash_map_test.cc
@@ -346,6 +346,13 @@
   t.m[0] = RecursiveType{};
 }
 
+TEST(NodeHashMap, NonStandardLayoutValueUsesTypeErasedSlotFns) {
+  using Policy = NodeHashMapPolicy<int, NonStandardLayout>;
+  EXPECT_NE((Policy::get_hash_slot_fn<absl::Hash<int>, /*kIsAbsl=*/true,
+                                      /*kSeedShift=*/0>()),
+            nullptr);
+}
+
 #if defined(__cpp_lib_containers_ranges) && \
     __cpp_lib_containers_ranges >= 202202L
 TEST(NodeHashMap, FromRange) {