[libc++] LWG2148, LWG2543: Enable std::hash<Enum> in C++03 and C++11

[• Quuxplusone]

Summary

Fixes https://llvm.org/PR50257

[• Quuxplusone]

On second thought, don't git rm enum.compile.fail.cpp — it's the only test coverage we get for the "non-enabled" case in C++03 mode, because non_enum.pass.cpp isn't C++03-friendly.

[ldionne]

libcxx/test/std/utilities/function.objects/unord.hash/enum.pass.cpp

16

Can we remove this "not very portable" comment?

libcxx/include/__functional/hash.h

#elif defined(__x86_64__)
         __u.__t = __v;
         return __u.__s.__a ^ __u.__s.__b;
 #else
         return __scalar_hash<long double>::operator()(__v);
 #endif
     }
 };
 
-#if _LIBCPP_STD_VER > 11
-
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Tp, bool = is_enum<_Tp>::value>
 struct _LIBCPP_TEMPLATE_VIS __enum_hash
 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES)
     : public unary_function<_Tp, size_t>
 #endif
 {
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
     _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
     _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp argument_type;
 #endif
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(_Tp __v) const _NOEXCEPT
     {
         typedef typename underlying_type<_Tp>::type type;
-        return hash<type>{}(static_cast<type>(__v));
+        return hash<type>()(static_cast<type>(__v));
     }
 };
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS __enum_hash<_Tp, false> {
     __enum_hash() = delete;
     __enum_hash(__enum_hash const&) = delete;
     __enum_hash& operator=(__enum_hash const&) = delete;
 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS hash : public __enum_hash<_Tp>
 {
 };
-#endif
 
 #if _LIBCPP_STD_VER > 14
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<nullptr_t>
 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES)
   : public unary_function<nullptr_t, size_t>

libcxx/test/std/utilities/function.objects/unord.hash/enum.compile.fail.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <functional>
-
-//  Hashing a struct w/o a defined hash should fail.
-
-#include <functional>
-#include <cassert>
-#include <type_traits>
-
-struct X {};
-
-int main(int, char**)
-{
-    X x;
-    size_t h = std::hash<X>{} ( x );
-
-  return 0;
-}

libcxx/test/std/utilities/function.objects/unord.hash/enum.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
-// UNSUPPORTED: c++03, c++11
-
 // <functional>
 
 // make sure that we can hash enumeration values
 // Not very portable
 
 #include "test_macros.h"
 
 #include <functional>
 #include <cassert>
 #include <type_traits>
 #include <limits>
 

libcxx/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03
 
 // <functional>
 
 //  Hashing a struct w/o a defined hash should *not* fail, but it should
 // create a type that is not constructible and not callable.
 // See also: https://cplusplus.github.io/LWG/lwg-defects.html#2543
 
 #include <functional>

libcxx/test/support/poisoned_hash_helper.h

#endif
       unsigned long long,
 #ifndef TEST_HAS_NO_INT128
       __int128_t,
       __uint128_t,
 #endif
       float,
       double,
       long double,
-#if TEST_STD_VER >= 14
-      // Enum types
       PoisonedHashDetail::Enum,
       PoisonedHashDetail::EnumClass,
-#endif
-      // pointer types
       void*,
       void const*,
       PoisonedHashDetail::Class*
     >;
 
 
 // Test that each of the library hash specializations for  arithmetic types,
 // enum types, and pointer types are available and enabled.