Canonicalize char[N] and string_view keys in KeyParam and raw_hash_map.

Convert 1D char[N] and absl::string_view keys to absl::string_view before
try_emplace_impl, insert_or_assign_impl, and KeyParam on StringHash/StringEq
tables.

PiperOrigin-RevId: 1024778963
diff --git a/absl/container/internal/raw_hash_map.h b/absl/container/internal/raw_hash_map.h
index b85accf..94e25e0 100644
--- a/absl/container/internal/raw_hash_map.h
+++ b/absl/container/internal/raw_hash_map.h
@@ -155,7 +155,10 @@
       ABSL_ATTRIBUTE_LIFETIME_BOUND {                                          \
     return ABSL_INTERNAL_IF_##KValue##_OR_##VValue(                            \
         (this->template Func<K, V, 0>), Callee)(                               \
-        std::forward<decltype(k)>(k), std::forward<decltype(v)>(v)) Tail;      \
+        ABSL_INTERNAL_IF_##KValue##_OR_##VValue(                               \
+            std::forward<decltype(k)>(k),                                      \
+            this->CanonicalizeKey(std::forward<decltype(k)>(k))),              \
+        std::forward<decltype(v)>(v)) Tail;                                    \
   }                                                                            \
   static_assert(true, "This is to force a semicolon.")
 
@@ -242,7 +245,7 @@
       std::enable_if_t<!std::is_convertible_v<K, const_iterator>, int> = 0>
   std::pair<iterator, bool> try_emplace(key_arg<K>&& k, Args&&... args)
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return try_emplace_impl(std::forward<key_arg<K>>(k),
+    return try_emplace_impl(this->CanonicalizeKey(std::forward<key_arg<K>>(k)),
                             std::forward<Args>(args)...);
   }
 
@@ -263,7 +266,8 @@
       std::enable_if_t<!std::is_convertible_v<K, const_iterator>, int> = 0>
   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)...);
+    return try_emplace_impl(this->CanonicalizeKey(k),
+                            std::forward<Args>(args)...);
   }
   template <
       class K = key_type, class... Args, EnableIf<LifetimeBoundK<K, true>> = 0,
diff --git a/absl/container/internal/raw_hash_set.h b/absl/container/internal/raw_hash_set.h
index 6ee6d3e..5844e5a 100644
--- a/absl/container/internal/raw_hash_set.h
+++ b/absl/container/internal/raw_hash_set.h
@@ -4367,9 +4367,39 @@
   }
 
  protected:
+  static constexpr bool kIsStringAbslHashEq =
+      std::is_same_v<hasher, absl::container_internal::StringHash> &&
+      std::is_same_v<key_equal, absl::container_internal::StringEq>;
+
+  template <class T>
+  struct IsCharArray : std::false_type {};
+  template <size_t N>
+  struct IsCharArray<char[N]> : std::true_type {};
+  template <size_t N>
+  struct IsCharArray<const char[N]> : std::true_type {};
+
+  // Collapse char[N] keys of different lengths to absl::string_view to avoid
+  // per-length instantiations and repeated strlen calls.
+  template <class K, class RemoveCvrefK = absl::remove_cvref_t<K>>
+  using CanonicalKey = std::conditional_t<kIsStringAbslHashEq &&
+                                              IsCharArray<RemoveCvrefK>::value,
+                                          absl::string_view, RemoveCvrefK>;
+
   template <class K>
-  using KeyParam = type_traits_internal::AddConstRefIfExpensiveToCopy<
-      absl::remove_cvref_t<K>>;
+  using KeyParam =
+      type_traits_internal::AddConstRefIfExpensiveToCopy<CanonicalKey<K>>;
+
+  template <class K>
+  static decltype(auto) CanonicalizeKey(K&& k) {
+    if constexpr (std::conjunction_v<
+                      std::bool_constant<kIsStringAbslHashEq>,
+                      std::is_same<CanonicalKey<K>, absl::string_view>,
+                      std::is_constructible<key_type, absl::string_view>>) {
+      return absl::string_view(k);
+    } else {
+      return std::forward<K>(k);
+    }
+  }
 
   // Asserts for correctness that we run on find/find_or_prepare_insert.
   template <class K>
@@ -4395,9 +4425,6 @@
     // validation. This improves debug performance, but also is important for
     // correctness of the *ConversionCount tests, which fail if we call hash/eq
     // on the lookup keys extra times (which triggers additional conversions).
-    constexpr bool kIsStringAbslHashEq =
-        std::is_same_v<hasher, absl::container_internal::StringHash> &&
-        std::is_same_v<key_equal, absl::container_internal::StringEq>;
     constexpr bool kIsScalarAbslHashEq =
         std::is_scalar_v<key_type> &&
         std::is_same_v<hasher, typename HashEq<key_type>::Hash> &&
@@ -4493,8 +4520,7 @@
   // explicitly.)
   template <class K, class RemoveCvrefK = absl::remove_cvref_t<K>,
             bool IsStringHashEqAndConvertibleToStringView =
-                std::is_same_v<hasher, absl::container_internal::StringHash> &&
-                std::is_same_v<key_equal, absl::container_internal::StringEq> &&
+                kIsStringAbslHashEq &&
                 std::is_convertible_v<const RemoveCvrefK&, absl::string_view>,
             class Ptr = std::remove_pointer_t<key_type>*,
             class ConstPtr = const std::remove_pointer_t<key_type>*,
diff --git a/absl/container/internal/raw_hash_set_test.cc b/absl/container/internal/raw_hash_set_test.cc
index 970420e..280a4a4 100644
--- a/absl/container/internal/raw_hash_set_test.cc
+++ b/absl/container/internal/raw_hash_set_test.cc
@@ -79,6 +79,8 @@
 namespace container_internal {
 
 struct RawHashSetTestOnlyAccess {
+  template <typename C, typename K>
+  using KeyParam = typename C::raw_hash_set::template KeyParam<K>;
   template <typename C>
   static auto GetCommon(C&& c) -> decltype(std::forward<C>(c).common()) {
     return std::forward<C>(c).common();
@@ -3205,6 +3207,48 @@
   EXPECT_EQ(*m[1], 42);
 }
 
+TEST(Table, CharArrayKeyParamCanonicalizesToStringView) {
+  using StringMap = absl::flat_hash_map<std::string, int>;
+  EXPECT_TRUE((std::is_same_v<
+               RawHashSetTestOnlyAccess::KeyParam<StringMap, const char (&)[4]>,
+               absl::string_view>));
+  EXPECT_TRUE((std::is_same_v<
+               RawHashSetTestOnlyAccess::KeyParam<StringMap, char (&)[64]>,
+               absl::string_view>));
+
+  StringMap m = {{"abc", 1}};
+  char buf[64] = "abc\0xyz";
+  EXPECT_EQ(m.find("abc")->second, 1);
+  EXPECT_EQ(m.find(buf)->second, 1);
+  EXPECT_FALSE(m.try_emplace(buf, 2).second);
+  EXPECT_FALSE(m.emplace(buf, 2).second);
+  EXPECT_FALSE(m.insert_or_assign(buf, 3).second);
+  EXPECT_EQ(m["abc"], 3);
+
+  // Exercise a string key with a non-default-constructible allocator.
+  using AllocString =
+      std::basic_string<char, std::char_traits<char>, FreezableAlloc<char>>;
+  bool frozen = false;
+  FreezableAlloc<char> alloc(&frozen);
+  absl::flat_hash_map<AllocString, int, absl::container_internal::StringHash,
+                      absl::container_internal::StringEq,
+                      FreezableAlloc<std::pair<const AllocString, int>>>
+      alloc_map{FreezableAlloc<std::pair<const AllocString, int>>(alloc)};
+  alloc_map[AllocString("abc", alloc)] = 1;
+  EXPECT_EQ(alloc_map.at("abc"), 1);
+
+  struct CStrOnlyKey {
+    std::string s;
+    CStrOnlyKey(const char* p) : s(p) {}  // NOLINT
+    CStrOnlyKey(absl::string_view) = delete;
+    operator absl::string_view() const { return s; }  // NOLINT
+  };
+  absl::flat_hash_map<CStrOnlyKey, int, absl::container_internal::StringHash,
+                      absl::container_internal::StringEq>
+      cstr_map;
+  cstr_map["abc"] = 1;
+  EXPECT_EQ(cstr_map.at("abc"), 1);
+}
 TEST(Table, DecomposeRangeInsert) {
   if (SwisstableGenerationsEnabled()) {
     GTEST_SKIP() << "Generations being enabled causes extra rehashes.";