Add std::hash<char8_t> specialization if char8_t is enabled

[georgthegreat]

Summary

Use _LIBCPP_NO_HAS_CHAR8_T to test if template should be specialized.

[mclow.lists]

libcxx/include/utility

1367

I think this should be #ifndef _LIBCPP_NO_HAS_CHAR8_T

libcxx/test/libcxx/extensions/hash/specializations.pass.cpp

26

Here too.

[georgthegreat]

There is a chance that _LIBCPP_NO_HAS_CHAR8_T should be removed in the course of https://reviews.llvm.org/D92212

Could you please, take a look and share you thoughts?

[mclow.lists]

Commented there.
For the record, the link is https://reviews.llvm.org/D92212 (without the trailing slash.
Alternately, you can just write D92212 and Phab will figure it out.

[georgthegreat]

Use libc++-specific macro to rest if hashing should be enabled.

Continue using standard defined macro in tests.

[georgthegreat]

libcxx/test/libcxx/extensions/hash/specializations.pass.cpp

26

I think test (due to being a library client) should continue checking the flag defined by the standard __cpp_lib_char8_t.

I have fixed it to check the value of the macro,

[georgthegreat]

I am waiting for D92212 to land, then I will rebase the diff to make it consistent with the changes proposed by @ldionne.

[mclow.lists]

libcxx/test/libcxx/extensions/hash/specializations.pass.cpp

26

Since the test is libc++-specific (it's in the test/libcxx hierarchy, as opposed to test/std), it *could* use _LIBCPP_NO_HAS_CHAR8_T. However, this is fine.

[ldionne]

We can still proceed with this even though we're keeping _LIBCPP_NO_HAS_CHAR8_T.

This LGTM.

[ldionne]

@georgthegreat Can you please rebase and resubmit, that will trigger CI.

[ldionne]

Let's wait for CI to complete, and if it pass, you're good to commit this. Thanks!

[georgthegreat]

The attempt to test std::hash via _gnu_cxx was just wrong.
I can not find any place to put individual hash tests anywhere, so I am removing the test completely.

[georgthegreat]

The final revision is buildable and can be merged.
@ldionne, could you merge it?

libcxx/include/functional

template <class  R, class ... ArgTypes>
   void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
 
 template <class T> struct hash;
 
 template <> struct hash<bool>;
 template <> struct hash<char>;
 template <> struct hash<signed char>;
 template <> struct hash<unsigned char>;
+template <> struct hash<char8_t>; // since C++20
 template <> struct hash<char16_t>;
 template <> struct hash<char32_t>;
 template <> struct hash<wchar_t>;
 template <> struct hash<short>;
 template <> struct hash<unsigned short>;
 template <> struct hash<int>;
 template <> struct hash<unsigned int>;
 template <> struct hash<long>;

libcxx/include/utility

 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<unsigned char>
     : public unary_function<unsigned char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 };
 
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<char8_t>
+    : public unary_function<char8_t, size_t>
+{
+    _LIBCPP_INLINE_VISIBILITY
+    size_t operator()(char8_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+#endif // !_LIBCPP_NO_HAS_CHAR8_T
+
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<char16_t>
     : public unary_function<char16_t, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

libcxx/test/libcxx/extensions/hash/specializations.pass.cpp

 {
     char str[] = "test";
     assert(__gnu_cxx::hash<const char *>()("test") ==
            std::hash<std::string>()("test"));
     assert(__gnu_cxx::hash<char *>()(str) == std::hash<std::string>()("test"));
     assert(__gnu_cxx::hash<char>()(42) == 42);
     assert(__gnu_cxx::hash<signed char>()(42) == 42);
     assert(__gnu_cxx::hash<unsigned char>()(42) == 42);
+    #ifndef _LIBCPP_NO_HAS_CHAR8_T
+    assert(__gnu_cxx::hash<char8_t>()(42) == 42);
+    #endif // _LIBCPP_NO_HAS_CHAR8_T
     assert(__gnu_cxx::hash<short>()(42) == 42);
     assert(__gnu_cxx::hash<unsigned short>()(42) == 42);
     assert(__gnu_cxx::hash<int>()(42) == 42);
     assert(__gnu_cxx::hash<unsigned int>()(42) == 42);
     assert(__gnu_cxx::hash<long>()(42) == 42);
     assert(__gnu_cxx::hash<unsigned long>()(42) == 42);
 
   return 0;
 }