Implement P0513R0 - "Poisoning the Hash"

Summary:
Exactly what the title says.

This patch also adds a `std::hash<nullptr_t>` specialization in C++17, but it was not added by this paper and I can't find the actual paper that adds it.

See http://wg21.link/P0513R0 for more info.

If there are no comments in the next couple of days I'll commit this

Reviewers: mclow.lists, K-ballo, EricWF

Reviewed By: EricWF

Subscribers: cfe-commits

Differential Revision: https://reviews.llvm.org/D28938

llvm-svn: 292684

3 files changed, 102 insertions, 0 deletions

diff --git a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp
new file mode 100644
index 00000000000..e9237c534fb
--- /dev/null
+++ b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp
@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// <memory>
+
+// Test that <memory> provides all of the arithmetic, enum, and pointer
+// hash specializations.
+
+#include <memory>
+
+#include "poisoned_hash_helper.hpp"
+
+int main() {
+  test_library_hash_specializations_available();
+}
diff --git a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
index 990cb58722b..5fba1fc0460 100644
--- a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
+++ b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
@@ -20,11 +20,25 @@
 #include <memory>
 #include <cassert>
 
+#if TEST_STD_VER >= 11
+#include "poisoned_hash_helper.hpp"
+
+struct A {};
+#endif
+
 int main()
 {
+  {
     int* ptr = new int;
     std::shared_ptr<int> p(ptr);
     std::hash<std::shared_ptr<int> > f;
     std::size_t h = f(p);
     assert(h == std::hash<int*>()(ptr));
+  }
+#if TEST_STD_VER >= 11
+  {
+    test_hash_enabled_for_type<std::shared_ptr<int>>();
+    test_hash_enabled_for_type<std::shared_ptr<A>>();
+  }
+#endif
 }
diff --git a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
index 5cd4ab1f83d..f989a017348 100644
--- a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
+++ b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
@@ -20,11 +20,76 @@
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 11
+#include "poisoned_hash_helper.hpp"
+#include "deleter_types.h"
+#include "min_allocator.h"
+
+template <class ValueT, class Del>
+void test_enabled_with_deleter() {
+  using UPtr = std::unique_ptr<ValueT, Del>;
+  using pointer = typename UPtr::pointer;
+  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>();
+}
+
+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>();
+}
+
+template <class T>
+struct std::hash<min_pointer<T, std::integral_constant<size_t, 1>>> {
+  size_t operator()(min_pointer<T, std::integral_constant<size_t, 1>> p) const {
+    if (!p) return 0;
+    return std::hash<T*>{}(std::addressof(*p));
+  }
+};
+
+struct A {};
+
+#endif // TEST_STD_VER >= 11
+
 int main()
 {
+  {
     int* ptr = new int;
     std::unique_ptr<int> p(ptr);
     std::hash<std::unique_ptr<int> > f;
     std::size_t h = f(p);
     assert(h == std::hash<int*>()(ptr));
+  }
+#if TEST_STD_VER >= 11
+  {
+    test_enabled_with_deleter<int, Deleter<int>>();
+    test_enabled_with_deleter<int[], Deleter<int[]>>();
+    test_enabled_with_deleter<int, CopyDeleter<int>>();
+    test_enabled_with_deleter<int, CopyDeleter<int[]>>();
+    test_enabled_with_deleter<int, NCDeleter<int>&>();
+    test_enabled_with_deleter<int[], NCDeleter<int[]>&>();
+    test_enabled_with_deleter<int, NCConstDeleter<int> const&>();
+    test_enabled_with_deleter<int[], NCConstDeleter<int[]> const&>();
+  }
+  {
+    test_enabled_with_deleter<int, PointerDeleter<int, 1>>();
+    test_enabled_with_deleter<int[], PointerDeleter<int[], 1>>();
+    test_enabled_with_deleter<A, PointerDeleter<A, 1>>();
+    test_enabled_with_deleter<A[], PointerDeleter<A[], 1>>();
+
+#if TEST_STD_VER > 14
+    test_disabled_with_deleter<int, PointerDeleter<int, 0>>();
+    test_disabled_with_deleter<int[], PointerDeleter<int[], 0>>();
+    test_disabled_with_deleter<A, PointerDeleter<A, 0>>();
+    test_disabled_with_deleter<A[], PointerDeleter<A[], 0>>();
+#endif
+  }
+#endif
 }