[libc++][modules] Refactor poisoned_hash_helper (#108296)

The poisoned_hash_helper header was relying on an implicit forward
declaration of std::hash located in <type_traits>. When we improve the
modularization of the library, that causes issues, in addition to being
a fundamentally non-portable assumption in the test suite.

It turns out that the reason for relying on a forward declaration is to
be able to test that std::hash is *not* provided if we don't include any
header that provides it. But testing that is actually both non-portable
and not really useful.

Indeed, what harm does it make if additional headers provide std::hash
specializations? That would certainly be conforming -- the Standard
never requires an implementation to avoid providing a declaration when a
given header is included, instead it mandates what *must* be provided
for sure. In that spirit, it would be conforming for e.g. `<cstddef>` to
define the hash specializations if that was our desire. I also don't
read https://wg21.link/P0513R0 as going against that statement. Hence,
this patch just removes that test which doesn't carry its weight.

Fixes #56938

Author: ldionne

libcxx/include/type_traits

@@ -421,7 +421,6 @@ namespace std
 */
 
 #include <__config>
-#include <__fwd/functional.h> // This is https://llvm.org/PR56938
 #include <__type_traits/add_const.h>
 #include <__type_traits/add_cv.h>
 #include <__type_traits/add_lvalue_reference.h>

libcxx/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp

@@ -20,8 +20,8 @@
 #include "min_allocator.h"
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  test_hash_enabled_for_type<std::vector<bool> >();
-  test_hash_enabled_for_type<std::vector<bool, min_allocator<bool>>>();
+  test_hash_enabled<std::vector<bool> >();
+  test_hash_enabled<std::vector<bool, min_allocator<bool>>>();
 
   return true;
 }

libcxx/test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp

@@ -22,8 +22,8 @@
 int main(int, char**) {
   test_library_hash_specializations_available();
   {
-    test_hash_enabled_for_type<std::error_code>();
-    test_hash_enabled_for_type<std::error_condition>();
+    test_hash_enabled<std::error_code>();
+    test_hash_enabled<std::error_condition>();
   }
 
   return 0;

libcxx/test/std/experimental/memory/memory.observer.ptr/hash.pass.cpp

@@ -33,7 +33,7 @@ void test_hash() {
     assert(h == std::hash<T*>()(&obj));
   }
 
-  test_hash_enabled_for_type<std::experimental::observer_ptr<T>>();
+  test_hash_enabled<std::experimental::observer_ptr<T>>();
 }
 
 struct Bar {};

libcxx/test/std/input.output/filesystems/class.path/path.member/path.hash_enabled.pass.cpp

@@ -20,7 +20,7 @@ namespace fs = std::filesystem;
 
 int main(int, char**) {
   test_library_hash_specializations_available();
-  test_hash_enabled_for_type<fs::path>();
+  test_hash_enabled<fs::path>();
 
   return 0;
 }

libcxx/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp

@@ -53,18 +53,18 @@ struct std::char_traits<MyChar> {
 int main(int, char**) {
   test_library_hash_specializations_available();
   {
-    test_hash_enabled_for_type<std::string>();
+    test_hash_enabled<std::string>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test_hash_enabled_for_type<std::wstring>();
+    test_hash_enabled<std::wstring>();
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
-    test_hash_enabled_for_type<std::u8string>();
+    test_hash_enabled<std::u8string>();
 #endif
-    test_hash_enabled_for_type<std::u16string>();
-    test_hash_enabled_for_type<std::u32string>();
-    test_hash_enabled_for_type<std::basic_string<char, std::char_traits<char>, test_allocator<char>>>();
-    test_hash_disabled_for_type<std::basic_string<MyChar, std::char_traits<MyChar>, std::allocator<MyChar>>>();
-    test_hash_disabled_for_type<std::basic_string<char, constexpr_char_traits<char>, std::allocator<char>>>();
+    test_hash_enabled<std::u16string>();
+    test_hash_enabled<std::u32string>();
+    test_hash_enabled<std::basic_string<char, std::char_traits<char>, test_allocator<char>>>();
+    test_hash_disabled<std::basic_string<MyChar, std::char_traits<MyChar>, std::allocator<MyChar>>>();
+    test_hash_disabled<std::basic_string<char, constexpr_char_traits<char>, std::allocator<char>>>();
   }
 
   return 0;

libcxx/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp

@@ -53,17 +53,17 @@ struct std::char_traits<MyChar> {
 int main(int, char**) {
   test_library_hash_specializations_available();
   {
-    test_hash_enabled_for_type<std::string_view>();
+    test_hash_enabled<std::string_view>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test_hash_enabled_for_type<std::wstring_view>();
+    test_hash_enabled<std::wstring_view>();
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
-    test_hash_enabled_for_type<std::u8string_view>();
+    test_hash_enabled<std::u8string_view>();
 #endif
-    test_hash_enabled_for_type<std::u16string_view>();
-    test_hash_enabled_for_type<std::u32string_view>();
-    test_hash_disabled_for_type<std::basic_string_view<MyChar, std::char_traits<MyChar>>>();
-    test_hash_disabled_for_type<std::basic_string_view<char, constexpr_char_traits<char>>>();
+    test_hash_enabled<std::u16string_view>();
+    test_hash_enabled<std::u32string_view>();
+    test_hash_disabled<std::basic_string_view<MyChar, std::char_traits<MyChar>>>();
+    test_hash_disabled<std::basic_string_view<char, constexpr_char_traits<char>>>();
   }
 
   return 0;

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp

@@ -24,7 +24,7 @@
 int main(int, char**) {
   test_library_hash_specializations_available();
   {
-    test_hash_enabled_for_type<std::thread::id>();
+    test_hash_enabled<std::thread::id>();
   }
 
   return 0;

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp

@@ -40,8 +40,8 @@ int main(int, char**)
   }
 #if TEST_STD_VER >= 11
   {
-    test_hash_enabled_for_type<std::shared_ptr<int>>();
-    test_hash_enabled_for_type<std::shared_ptr<A>>();
+    test_hash_enabled<std::shared_ptr<int>>();
+    test_hash_enabled<std::shared_ptr<A>>();
   }
 #endif
 

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp

@@ -35,16 +35,16 @@ void test_enabled_with_deleter() {
   using RawDel = typename std::decay<Del>::type;
   RawDel d(1);
   UPtr p(nullptr, std::forward<Del>(d));
-  test_hash_enabled_for_type<UPtr>(p);
-  test_hash_enabled_for_type<pointer>();
+  test_hash_enabled<UPtr>(p);
+  test_hash_enabled<pointer>();
 }
 
 template <class ValueT, class Del>
 void test_disabled_with_deleter() {
   using UPtr = std::unique_ptr<ValueT, Del>;
   using pointer = typename UPtr::pointer;
-  test_hash_disabled_for_type<UPtr>();
-  test_hash_disabled_for_type<pointer>();
+  test_hash_disabled<UPtr>();
+  test_hash_disabled<pointer>();
 }
 
 template <class T>

libcxx/test/std/utilities/optional/optional.hash/hash.pass.cpp

@@ -63,16 +63,16 @@ int main(int, char**)
         assert(std::hash<optional<T>>{}(opt) == std::hash<T>{}(*opt));
     }
     {
-      test_hash_enabled_for_type<std::optional<int> >();
-      test_hash_enabled_for_type<std::optional<int*> >();
-      test_hash_enabled_for_type<std::optional<const int> >();
-      test_hash_enabled_for_type<std::optional<int* const> >();
+      test_hash_enabled<std::optional<int> >();
+      test_hash_enabled<std::optional<int*> >();
+      test_hash_enabled<std::optional<const int> >();
+      test_hash_enabled<std::optional<int* const> >();
 
-      test_hash_disabled_for_type<std::optional<A>>();
-      test_hash_disabled_for_type<std::optional<const A>>();
+      test_hash_disabled<std::optional<A>>();
+      test_hash_disabled<std::optional<const A>>();
 
-      test_hash_enabled_for_type<std::optional<B>>();
-      test_hash_enabled_for_type<std::optional<const B>>();
+      test_hash_enabled<std::optional<B>>();
+      test_hash_enabled<std::optional<const B>>();
     }
 
   return 0;

libcxx/test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp

@@ -22,10 +22,10 @@
 int main(int, char**) {
   test_library_hash_specializations_available();
   {
-    test_hash_enabled_for_type<std::bitset<0> >();
-    test_hash_enabled_for_type<std::bitset<1> >();
-    test_hash_enabled_for_type<std::bitset<1024> >();
-    test_hash_enabled_for_type<std::bitset<100000> >();
+    test_hash_enabled<std::bitset<0> >();
+    test_hash_enabled<std::bitset<1> >();
+    test_hash_enabled<std::bitset<1024> >();
+    test_hash_enabled<std::bitset<100000> >();
   }
 
   return 0;

libcxx/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp

@@ -34,7 +34,7 @@ int main(int, char**)
   }
 #if TEST_STD_VER >= 11
   {
-    test_hash_enabled_for_type<std::type_index>(std::type_index(typeid(int)));
+    test_hash_enabled<std::type_index>(std::type_index(typeid(int)));
   }
 #endif
 

libcxx/test/std/utilities/variant/variant.hash/hash.pass.cpp

@@ -103,7 +103,7 @@ void test_hash_monostate() {
     static_assert(std::is_copy_constructible<H>::value, "");
   }
   {
-    test_hash_enabled_for_type<std::monostate>();
+    test_hash_enabled<std::monostate>();
   }
 }
 
@@ -131,16 +131,16 @@ struct std::hash<B> {
 
 void test_hash_variant_enabled() {
   {
-    test_hash_enabled_for_type<std::variant<int> >();
-    test_hash_enabled_for_type<std::variant<int*, long, double, const int> >();
+    test_hash_enabled<std::variant<int> >();
+    test_hash_enabled<std::variant<int*, long, double, const int> >();
   }
   {
-    test_hash_disabled_for_type<std::variant<int, A>>();
-    test_hash_disabled_for_type<std::variant<const A, void*>>();
+    test_hash_disabled<std::variant<int, A>>();
+    test_hash_disabled<std::variant<const A, void*>>();
   }
   {
-    test_hash_enabled_for_type<std::variant<int, B>>();
-    test_hash_enabled_for_type<std::variant<const B, int>>();
+    test_hash_enabled<std::variant<int, B>>();
+    test_hash_enabled<std::variant<const B, int>>();
   }
 }