1 // -*- C++ -*-
2 //===----------------------------------------------------------------------===//
3 //
4 //                     The LLVM Compiler Infrastructure
5 //
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
8 //
9 //===----------------------------------------------------------------------===//
10 #ifndef SUPPORT_POISONED_HASH_HELPER_HPP
11 #define SUPPORT_POISONED_HASH_HELPER_HPP
12 
13 #include <type_traits>
14 #include <cassert>
15 
16 #include "test_macros.h"
17 
18 #if TEST_STD_VER < 11
19 #error this header may only be used in C++11 or newer
20 #endif
21 
22 template <class ...Args> struct TypeList;
23 
24 // Test that the specified Hash meets the requirements of an enabled hash
25 template <class Hash, class Key, class InputKey = Key>
26 void test_hash_enabled(InputKey const& key = InputKey{});
27 
28 template <class T, class InputKey = T>
test_hash_enabled_for_type(InputKey const & key=InputKey{})29 void test_hash_enabled_for_type(InputKey const& key = InputKey{}) {
30   return test_hash_enabled<std::hash<T>, T, InputKey>(key);
31 }
32 
33 // Test that the specified Hash meets the requirements of a disabled hash.
34 template <class Hash, class Key>
35 void test_hash_disabled();
36 
37 template <class T>
test_hash_disabled_for_type()38 void test_hash_disabled_for_type() {
39   return test_hash_disabled<std::hash<T>, T>();
40 }
41 
42 namespace PoisonedHashDetail {
43   enum Enum {};
44   enum EnumClass : bool {};
45   struct Class {};
46 }
47 
48 // Each header that declares the template hash provides enabled
49 // specializations of hash for nullptr t and all cv-unqualified
50 // arithmetic, enumeration, and pointer types.
51 using LibraryHashTypes = TypeList<
52 #if TEST_STD_VER > 14
53       decltype(nullptr),
54 #endif
55       bool,
56       char,
57       signed char,
58       unsigned char,
59       wchar_t,
60 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
61       char16_t,
62       char32_t,
63 #endif
64       short,
65       unsigned short,
66       int,
67       unsigned int,
68       long,
69       unsigned long,
70       long long,
71       unsigned long long,
72 #ifndef _LIBCPP_HAS_NO_INT128
73       __int128_t,
74       __uint128_t,
75 #endif
76       float,
77       double,
78       long double,
79 #if TEST_STD_VER >= 14
80       // Enum types
81       PoisonedHashDetail::Enum,
82       PoisonedHashDetail::EnumClass,
83 #endif
84       // pointer types
85       void*,
86       void const*,
87       PoisonedHashDetail::Class*
88     >;
89 
90 
91 // Test that each of the library hash specializations for  arithmetic types,
92 // enum types, and pointer types are available and enabled.
93 template <class Types = LibraryHashTypes>
94 void test_library_hash_specializations_available(Types = Types{});
95 
96 
97 namespace PoisonedHashDetail {
98 
99 template <class T, class = typename T::foo_bar_baz>
instantiate(int)100 constexpr bool instantiate(int) { return true; }
instantiate(long)101 template <class> constexpr bool instantiate(long) { return true; }
instantiate()102 template <class T> constexpr bool instantiate() { return instantiate<T>(0); }
103 
104 template <class To>
105 struct ConvertibleToSimple {
operator ToPoisonedHashDetail::ConvertibleToSimple106   operator To() const {
107     return To{};
108   }
109 };
110 
111 template <class To>
112 struct ConvertibleTo {
113   To to{};
operator To&PoisonedHashDetail::ConvertibleTo114   operator To&() & { return to; }
operator To const&PoisonedHashDetail::ConvertibleTo115   operator To const&() const & { return to; }
operator To&&PoisonedHashDetail::ConvertibleTo116   operator To&&() && { return std::move(to); }
operator To const&&PoisonedHashDetail::ConvertibleTo117   operator To const&&() const && { return std::move(to); }
118 };
119 
120 template <class HashExpr,
121          class Res = typename std::result_of<HashExpr>::type>
can_hash(int)122 constexpr bool can_hash(int) {
123   return std::is_same<Res, size_t>::value;
124 }
can_hash(long)125 template <class> constexpr bool can_hash(long) { return false; }
can_hash()126 template <class T> constexpr bool can_hash() { return can_hash<T>(0); }
127 
128 } // namespace PoisonedHashDetail
129 
130 template <class Hash, class Key, class InputKey>
test_hash_enabled(InputKey const & key)131 void test_hash_enabled(InputKey const& key) {
132   using namespace PoisonedHashDetail;
133 
134   static_assert(std::is_destructible<Hash>::value, "");
135   // Enabled hash requirements
136   static_assert(std::is_default_constructible<Hash>::value, "");
137   static_assert(std::is_copy_constructible<Hash>::value, "");
138   static_assert(std::is_move_constructible<Hash>::value, "");
139   static_assert(std::is_copy_assignable<Hash>::value, "");
140   static_assert(std::is_move_assignable<Hash>::value, "");
141 
142 #if TEST_STD_VER > 14
143   static_assert(std::is_swappable<Hash>::value, "");
144 #elif defined(_LIBCPP_VERSION)
145   static_assert(std::__is_swappable<Hash>::value, "");
146 #endif
147 
148   // Hashable requirements
149   using CKey = ConvertibleTo<Key>;
150   static_assert(can_hash<Hash(Key&)>(), "");
151   static_assert(can_hash<Hash(Key const&)>(), "");
152   static_assert(can_hash<Hash(Key&&)>(), "");
153   static_assert(can_hash<Hash const&(Key&)>(), "");
154   static_assert(can_hash<Hash const&(Key const&)>(), "");
155   static_assert(can_hash<Hash const&(Key&&)>(), "");
156 
157   static_assert(can_hash<Hash(ConvertibleToSimple<Key>&)>(), "");
158   static_assert(can_hash<Hash(ConvertibleToSimple<Key> const&)>(), "");
159   static_assert(can_hash<Hash(ConvertibleToSimple<Key>&&)>(), "");
160 
161   static_assert(can_hash<Hash(ConvertibleTo<Key>&)>(), "");
162   static_assert(can_hash<Hash(ConvertibleTo<Key> const&)>(), "");
163   static_assert(can_hash<Hash(ConvertibleTo<Key> &&)>(), "");
164   static_assert(can_hash<Hash(ConvertibleTo<Key> const&&)>(), "");
165 
166   const Hash h{};
167   assert(h(key) == h(key));
168 
169 }
170 
171 template <class Hash, class Key>
test_hash_disabled()172 void test_hash_disabled() {
173   using namespace PoisonedHashDetail;
174 
175   // Disabled hash requirements
176   static_assert(!std::is_default_constructible<Hash>::value, "");
177   static_assert(!std::is_copy_constructible<Hash>::value, "");
178   static_assert(!std::is_move_constructible<Hash>::value, "");
179   static_assert(!std::is_copy_assignable<Hash>::value, "");
180   static_assert(!std::is_move_assignable<Hash>::value, "");
181 
182   static_assert(!std::is_function<
183       typename std::remove_pointer<
184           typename std::remove_reference<Hash>::type
185       >::type
186     >::value, "");
187 
188   // Hashable requirements
189   using CKey = ConvertibleTo<Key>;
190   static_assert(!can_hash<Hash(Key&)>(), "");
191   static_assert(!can_hash<Hash(Key const&)>(), "");
192   static_assert(!can_hash<Hash(Key&&)>(), "");
193   static_assert(!can_hash<Hash const&(Key&)>(), "");
194   static_assert(!can_hash<Hash const&(Key const&)>(), "");
195   static_assert(!can_hash<Hash const&(Key&&)>(), "");
196 
197   static_assert(!can_hash<Hash(ConvertibleToSimple<Key>&)>(), "");
198   static_assert(!can_hash<Hash(ConvertibleToSimple<Key> const&)>(), "");
199   static_assert(!can_hash<Hash(ConvertibleToSimple<Key>&&)>(), "");
200 
201   static_assert(!can_hash<Hash(ConvertibleTo<Key>&)>(), "");
202   static_assert(!can_hash<Hash(ConvertibleTo<Key> const&)>(), "");
203   static_assert(!can_hash<Hash(ConvertibleTo<Key> &&)>(), "");
204   static_assert(!can_hash<Hash(ConvertibleTo<Key> const&&)>(), "");
205 }
206 
207 
208 template <class First, class ...Rest>
209 struct TypeList<First, Rest...> {
210   template <template <class> class Trait, bool Expect = true>
assertTraitTypeList211   static constexpr bool assertTrait() {
212     static_assert(Trait<First>::value == Expect, "");
213     return TypeList<Rest...>::template assertTrait<Trait, Expect>();
214   }
215 
216   template <class Trait>
applyTraitTypeList217   static void applyTrait() {
218     Trait::template apply<First>();
219     TypeList<Rest...>::template applyTrait<Trait>();
220   }
221 };
222 
223 template <>
224 struct TypeList<> {
225   template <template <class> class Trait, bool Expect = true>
assertTraitTypeList226   static constexpr bool assertTrait() {
227     return true;
228   }
229   template <class Trait>
applyTraitTypeList230   static void applyTrait() {}
231 };
232 
233 
234 struct TestLibraryTrait {
235     template <class Type>
applyTestLibraryTrait236     static void apply() { test_hash_enabled<std::hash<Type>, Type>(); }
237 };
238 
239 template <class Types>
test_library_hash_specializations_available(Types)240 void test_library_hash_specializations_available(Types) {
241   Types::template applyTrait<TestLibraryTrait >();
242 }
243 
244 #endif // SUPPORT_POISONED_HASH_HELPER_HPP
245