libstdc++: Make std::hash<basic_string<>> allocator-agnostic (LWG 3705)

This new library issue was recently moved to Tentatively Ready by an LWG
poll, so I'm making the change on trunk.

As noted in PR libstc++/105907 the std::hash specializations for PMR
strings were not treated as slow hashes by the unordered containers, so
this change preserves that. The new specializations for custom
allocators are also not treated as slow, for the same reason. For the
versioned namespace (i.e. unstable ABI) we don't have to worry about
that, so can enable hash code caching for all basic_string
specializations.

libstdc++-v3/ChangeLog:

	* include/bits/basic_string.h (__hash_str_base): New class
	template.
	(hash<basic_string<C, char_traits<C>, A>>): Define partial
	specialization for each of the standard character types.
	(hash<string>, hash<wstring>, hash<u8string>, hash<u16string>)
	(hash<u32string>): Remove explicit specializations.
	* include/std/string (__hash_string_base): Remove class
	template.
	(hash<pmr::string>, hash<pmr::wstring>, hash<pmr::u8string>)
	(hash<pmr::u16string>, hash<pmr::u32string>): Remove explicit
	specializations.
	* testsuite/21_strings/basic_string/hash/hash.cc: Test with
	custom allocators.
	* testsuite/21_strings/basic_string/hash/hash_char8_t.cc:
	Likewise.

diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h
index 6041d05815bbdda820f10b901ce19186b31ffb16..f76ddf970c64a41c9e48e8dad8706986e63cd72a 100644 (file)
--- a/libstdc++-v3/include/bits/basic_string.h
+++ b/libstdc++-v3/include/bits/basic_string.h
@@ -4226,85 +4226,75 @@ namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  // DR 1182.
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 3705. Hashability shouldn't depend on basic_string's allocator
 
-#ifndef _GLIBCXX_COMPATIBILITY_CXX0X
-  /// std::hash specialization for string.
-  template<>
-    struct hash<string>
-    : public __hash_base<size_t, string>
+  template<typename _CharT, typename _Alloc,
+          typename _StrT = basic_string<_CharT, char_traits<_CharT>, _Alloc>>
+    struct __str_hash_base
+    : public __hash_base<size_t, _StrT>
     {
       size_t
-      operator()(const string& __s) const noexcept
-      { return std::_Hash_impl::hash(__s.data(), __s.length()); }
+      operator()(const _StrT& __s) const noexcept
+      { return _Hash_impl::hash(__s.data(), __s.length() * sizeof(_CharT)); }
     };
 
-  template<>
-    struct __is_fast_hash<hash<string>> : std::false_type
+#ifndef _GLIBCXX_COMPATIBILITY_CXX0X
+  /// std::hash specialization for string.
+  template<typename _Alloc>
+    struct hash<basic_string<char, char_traits<char>, _Alloc>>
+    : public __str_hash_base<char, _Alloc>
     { };
 
   /// std::hash specialization for wstring.
-  template<>
-    struct hash<wstring>
-    : public __hash_base<size_t, wstring>
-    {
-      size_t
-      operator()(const wstring& __s) const noexcept
-      { return std::_Hash_impl::hash(__s.data(),
-                                     __s.length() * sizeof(wchar_t)); }
-    };
+  template<typename _Alloc>
+    struct hash<basic_string<wchar_t, char_traits<wchar_t>, _Alloc>>
+    : public __str_hash_base<wchar_t, _Alloc>
+    { };
 
-  template<>
-    struct __is_fast_hash<hash<wstring>> : std::false_type
+  template<typename _Alloc>
+    struct __is_fast_hash<hash<basic_string<wchar_t, char_traits<wchar_t>,
+                                           _Alloc>>>
+    : std::false_type
     { };
 #endif /* _GLIBCXX_COMPATIBILITY_CXX0X */
 
 #ifdef _GLIBCXX_USE_CHAR8_T
   /// std::hash specialization for u8string.
-  template<>
-    struct hash<u8string>
-    : public __hash_base<size_t, u8string>
-    {
-      size_t
-      operator()(const u8string& __s) const noexcept
-      { return std::_Hash_impl::hash(__s.data(),
-                                     __s.length() * sizeof(char8_t)); }
-    };
-
-  template<>
-    struct __is_fast_hash<hash<u8string>> : std::false_type
+  template<typename _Alloc>
+    struct hash<basic_string<char8_t, char_traits<char8_t>, _Alloc>>
+    : public __str_hash_base<char8_t, _Alloc>
     { };
 #endif
 
   /// std::hash specialization for u16string.
-  template<>
-    struct hash<u16string>
-    : public __hash_base<size_t, u16string>
-    {
-      size_t
-      operator()(const u16string& __s) const noexcept
-      { return std::_Hash_impl::hash(__s.data(),
-                                     __s.length() * sizeof(char16_t)); }
-    };
-
-  template<>
-    struct __is_fast_hash<hash<u16string>> : std::false_type
+  template<typename _Alloc>
+    struct hash<basic_string<char16_t, char_traits<char16_t>, _Alloc>>
+    : public __str_hash_base<char16_t, _Alloc>
     { };
 
   /// std::hash specialization for u32string.
-  template<>
-    struct hash<u32string>
-    : public __hash_base<size_t, u32string>
-    {
-      size_t
-      operator()(const u32string& __s) const noexcept
-      { return std::_Hash_impl::hash(__s.data(),
-                                     __s.length() * sizeof(char32_t)); }
-    };
+  template<typename _Alloc>
+    struct hash<basic_string<char32_t, char_traits<char32_t>, _Alloc>>
+    : public __str_hash_base<char32_t, _Alloc>
+    { };
 
-  template<>
-    struct __is_fast_hash<hash<u32string>> : std::false_type
+#if ! _GLIBCXX_INLINE_VERSION
+  // PR libstdc++/105907 - __is_fast_hash affects unordered container ABI.
+  template<> struct __is_fast_hash<hash<string>> : std::false_type { };
+  template<> struct __is_fast_hash<hash<wstring>> : std::false_type { };
+  template<> struct __is_fast_hash<hash<u16string>> : std::false_type { };
+  template<> struct __is_fast_hash<hash<u32string>> : std::false_type { };
+#ifdef _GLIBCXX_USE_CHAR8_T
+  template<> struct __is_fast_hash<hash<u8string>> : std::false_type { };
+#endif
+#else
+  // For versioned namespace, assume every std::hash<basic_string<>> is slow.
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    struct __is_fast_hash<hash<basic_string<_CharT, _Traits, _Alloc>>>
+    : std::false_type
     { };
+#endif
 
 #if __cplusplus >= 201402L
 

diff --git a/libstdc++-v3/include/std/string b/libstdc++-v3/include/std/string
index 4a0633067bd61e6571e4c46fbaa312b59421de2a..37a4aaba9cddfece15c0a2c2ba0cc197c8ca0c36 100644 (file)
--- a/libstdc++-v3/include/std/string
+++ b/libstdc++-v3/include/std/string
@@ -69,39 +69,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     using u32string = basic_string<char32_t>;
     using wstring   = basic_string<wchar_t>;
   } // namespace pmr
-
-  template<typename _Str>
-    struct __hash_string_base
-    : public __hash_base<size_t, _Str>
-    {
-      size_t
-      operator()(const _Str& __s) const noexcept
-      { return hash<basic_string_view<typename _Str::value_type>>{}(__s); }
-    };
-
-  template<>
-    struct hash<pmr::string>
-    : public __hash_string_base<pmr::string>
-    { };
-#ifdef _GLIBCXX_USE_CHAR8_T
-  template<>
-    struct hash<pmr::u8string>
-    : public __hash_string_base<pmr::u8string>
-    { };
-#endif
-  template<>
-    struct hash<pmr::u16string>
-    : public __hash_string_base<pmr::u16string>
-    { };
-  template<>
-    struct hash<pmr::u32string>
-    : public __hash_string_base<pmr::u32string>
-    { };
-  template<>
-    struct hash<pmr::wstring>
-    : public __hash_string_base<pmr::wstring>
-    { };
-
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std
 #endif // C++17

diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash.cc b/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash.cc
index 4c16f0e6f401903aea4f624e88f1b350b1dd221b..7f3809926e5794fe995adf4dc306ef742aee9531 100644 (file)
--- a/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash.cc
+++ b/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash.cc
@@ -20,6 +20,7 @@
 #include <string>
 #include <memory_resource>
 #include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
 
 // C++17 24.3.5 [basic.string.hash]
 // If S is one of these string types, SV is the corresponding string view type,
@@ -54,9 +55,24 @@ test02()
 #endif
 }
 
+template<typename C>
+using String
+  = std::basic_string<C, std::char_traits<C>, __gnu_test::SimpleAllocator<C>>;
+
+void
+test03()
+{
+  // LWG 3705. Hashability shouldn't depend on basic_string's allocator
+  VERIFY( test(String<char>("a narrow string")) );
+  VERIFY( test(String<char16_t>(u"a utf-16 string")) );
+  VERIFY( test(String<char32_t>(U"a utf-32 string")) );
+  VERIFY( test(String<wchar_t>(L"a wide string")) );
+}
+
 int
 main()
 {
   test01();
   test02();
+  test03();
 }

diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash_char8_t.cc b/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash_char8_t.cc
index 217fe15c7fe1c717aba7bbe14174add21784f900..0ff98ad1caa60524c4bccf806b66bb66733abf78 100644 (file)
--- a/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash_char8_t.cc
+++ b/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash_char8_t.cc
@@ -21,6 +21,7 @@
 #include <string>
 #include <memory_resource>
 #include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
 
 // C++2a N4810 21.3.5 [basic.string.hash]
 // If S is one of these string types, SV is the corresponding string view type,
@@ -55,9 +56,20 @@ test02()
   VERIFY( hash<std::string>()(native) == hash<std::u8string>()(utf8) );
 }
 
+void
+test03()
+{
+  using Alloc = __gnu_test::SimpleAllocator<char8_t>;
+  using Stringu8 = std::basic_string<char8_t, std::char_traits<char8_t>, Alloc>;
+
+  // LWG 3705. Hashability shouldn't depend on basic_string's allocator
+  VERIFY( test(Stringu8(u8"a utf-8 string, with custom allocator")) );
+}
+
 int
 main()
 {
   test01();
   test02();
+  test03();
 }