Implement LWG 2148: Make non-enum default hash specialization well-formed

[EricWF]

Summary

This patch removes the static_assert for non-enum types in the primary hash template. Instead non-enum types create a hash<T> specialization that is not constructible nor callable.

See also:

• http://cplusplus.github.io/LWG/lwg-active.html#2543
• https://llvm.org/bugs/show_bug.cgi?id=28917

[mclow.lists]

This looks good to me.
However, we don't usually change libc++ for issue resolutions that have not yet adopted. We wait until they've "official".

[EricWF]

In D23331#511204, @mclow.lists wrote:

This looks good to me.
However, we don't usually change libc++ for issue resolutions that have not yet adopted. We wait until they've "official".

Exactly why I put this up for review. However I've had two separate people ask about the status of this change. Clearly users want it and dislike the current behavior.
I think we can safely adopt this change now ever though it hasn't been officially accepted.

include/functional

         return __u.__s.__a ^ __u.__s.__b;
 #else
         return __scalar_hash<long double>::operator()(__v);
 #endif
     }
 };
 
 #if _LIBCPP_STD_VER > 11
-template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY hash
+
+template <class _Tp, bool = is_enum<_Tp>::value>
+struct _LIBCPP_TYPE_VIS_ONLY __enum_hash
     : public unary_function<_Tp, size_t>
 {
-    static_assert(is_enum<_Tp>::value, "This hash only works for enumeration types");
-
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(_Tp __v) const _NOEXCEPT
     {
         typedef typename underlying_type<_Tp>::type type;
         return hash<type>{}(static_cast<type>(__v));
     }
 };
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY __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_TYPE_VIS_ONLY hash : public __enum_hash<_Tp>
+{
+};
 #endif
 
 
 #if _LIBCPP_STD_VER > 14
 
 template <class _Fn, class ..._Args>
 result_of_t<_Fn&&(_Args&&...)>
 invoke(_Fn&& __f, _Args&&... __args)

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
+
 // <functional>
 
 // make sure that we can hash enumeration values
 // Not very portable
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 14
-
 #include <functional>
 #include <cassert>
 #include <type_traits>
 #include <limits>
 
 enum class Colors { red, orange, yellow, green, blue, indigo, violet };
 enum class Cardinals { zero, one, two, three, five=5 };
 enum class LongColors : short { red, orange, yellow, green, blue, indigo, violet };
int main()
 
     test<Colors>();
     test<ShortColors>();
     test<LongColors>();
     test<EightBitColors>();
 
     test<Fruits>();
 }
-#else
-int main () {}
-#endif

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <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: http://cplusplus.github.io/LWG/lwg-active.html#2543
+
+#include <functional>
+#include <cassert>
+#include <type_traits>
+
+#include "test_macros.h"
+
+struct X {};
+
+int main()
+{
+    using H = std::hash<X>;
+    static_assert(!std::is_default_constructible<H>::value, "");
+    static_assert(!std::is_copy_constructible<H>::value, "");
+    static_assert(!std::is_move_constructible<H>::value, "");
+    static_assert(!std::is_copy_assignable<H>::value, "");
+    static_assert(!std::is_move_assignable<H>::value, "");
+#if TEST_STD_VER > 14
+    static_assert(!std::is_callable<H(X&)>::value, "");
+    static_assert(!std::is_callable<H(X const&)>::value, "");
+#endif
+}