1 //===----------------------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 // UNSUPPORTED: c++03, c++11, c++14 10 11 // <functional> 12 13 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS 14 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS 15 16 // template<class F, class... Args> 17 // invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) // C++17 18 // noexcept(is_nothrow_invocable_v<_Fn, _Args...>); 19 20 /// C++14 [func.def] 20.9.0 21 /// (1) The following definitions apply to this Clause: 22 /// (2) A call signature is the name of a return type followed by a parenthesized 23 /// comma-separated list of zero or more argument types. 24 /// (3) A callable type is a function object type (20.9) or a pointer to member. 25 /// (4) A callable object is an object of a callable type. 26 /// (5) A call wrapper type is a type that holds a callable object and supports 27 /// a call operation that forwards to that object. 28 /// (6) A call wrapper is an object of a call wrapper type. 29 /// (7) A target object is the callable object held by a call wrapper. 30 31 /// C++14 [func.require] 20.9.1 32 /// 33 /// Define INVOKE (f, t1, t2, ..., tN) as follows: 34 /// (1.1) - (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is an object of 35 /// type T or a reference to an object of type T or a reference to an object of a type derived from T; 36 /// (1.2) - ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is not one of 37 /// the types described in the previous item; 38 /// (1.3) - t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is an object of type T or a 39 /// reference to an object of type T or a reference to an object of a type derived from T; 40 /// (1.4) - (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1 is not one of the types 41 /// described in the previous item; 42 /// (1.5) - f(t1, t2, ..., tN) in all other cases. 43 44 #include <functional> 45 #include <type_traits> 46 #include <utility> // for std::move 47 #include <cassert> 48 49 #include "test_macros.h" 50 51 struct NonCopyable { 52 NonCopyable() {} 53 private: 54 NonCopyable(NonCopyable const&) = delete; 55 NonCopyable& operator=(NonCopyable const&) = delete; 56 }; 57 58 struct TestClass { 59 explicit TestClass(int x) : data(x) {} 60 61 int& operator()(NonCopyable&&) & { return data; } 62 int const& operator()(NonCopyable&&) const & { return data; } 63 int volatile& operator()(NonCopyable&&) volatile & { return data; } 64 int const volatile& operator()(NonCopyable&&) const volatile & { return data; } 65 66 int&& operator()(NonCopyable&&) && { return std::move(data); } 67 int const&& operator()(NonCopyable&&) const && { return std::move(data); } 68 int volatile&& operator()(NonCopyable&&) volatile && { return std::move(data); } 69 int const volatile&& operator()(NonCopyable&&) const volatile && { return std::move(data); } 70 71 int data; 72 private: 73 TestClass(TestClass const&) = delete; 74 TestClass& operator=(TestClass const&) = delete; 75 }; 76 77 struct DerivedFromTestClass : public TestClass { 78 explicit DerivedFromTestClass(int x) : TestClass(x) {} 79 }; 80 81 int& foo(NonCopyable&&) { 82 static int data = 42; 83 return data; 84 } 85 86 template <class Signature, class Expect, class Functor> 87 void test_b12(Functor&& f) { 88 // Create the callable object. 89 typedef Signature TestClass::*ClassFunc; 90 ClassFunc func_ptr = &TestClass::operator(); 91 92 // Create the dummy arg. 93 NonCopyable arg; 94 95 // Check that the deduced return type of invoke is what is expected. 96 typedef decltype( 97 std::invoke(func_ptr, std::forward<Functor>(f), std::move(arg)) 98 ) DeducedReturnType; 99 static_assert((std::is_same<DeducedReturnType, Expect>::value), ""); 100 101 // Check that result_of_t matches Expect. 102 typedef typename std::result_of<ClassFunc&&(Functor&&, NonCopyable&&)>::type 103 ResultOfReturnType; 104 static_assert((std::is_same<ResultOfReturnType, Expect>::value), ""); 105 106 // Run invoke and check the return value. 107 DeducedReturnType ret = 108 std::invoke(func_ptr, std::forward<Functor>(f), std::move(arg)); 109 assert(ret == 42); 110 } 111 112 template <class Expect, class Functor> 113 void test_b34(Functor&& f) { 114 // Create the callable object. 115 typedef int TestClass::*ClassFunc; 116 ClassFunc func_ptr = &TestClass::data; 117 118 // Check that the deduced return type of invoke is what is expected. 119 typedef decltype( 120 std::invoke(func_ptr, std::forward<Functor>(f)) 121 ) DeducedReturnType; 122 static_assert((std::is_same<DeducedReturnType, Expect>::value), ""); 123 124 // Check that result_of_t matches Expect. 125 typedef typename std::result_of<ClassFunc&&(Functor&&)>::type 126 ResultOfReturnType; 127 static_assert((std::is_same<ResultOfReturnType, Expect>::value), ""); 128 129 // Run invoke and check the return value. 130 DeducedReturnType ret = 131 std::invoke(func_ptr, std::forward<Functor>(f)); 132 assert(ret == 42); 133 } 134 135 template <class Expect, class Functor> 136 void test_b5(Functor&& f) { 137 NonCopyable arg; 138 139 // Check that the deduced return type of invoke is what is expected. 140 typedef decltype( 141 std::invoke(std::forward<Functor>(f), std::move(arg)) 142 ) DeducedReturnType; 143 static_assert((std::is_same<DeducedReturnType, Expect>::value), ""); 144 145 // Check that result_of_t matches Expect. 146 typedef typename std::result_of<Functor&&(NonCopyable&&)>::type 147 ResultOfReturnType; 148 static_assert((std::is_same<ResultOfReturnType, Expect>::value), ""); 149 150 // Run invoke and check the return value. 151 DeducedReturnType ret = std::invoke(std::forward<Functor>(f), std::move(arg)); 152 assert(ret == 42); 153 } 154 155 void bullet_one_two_tests() { 156 { 157 TestClass cl(42); 158 test_b12<int&(NonCopyable&&) &, int&>(cl); 159 test_b12<int const&(NonCopyable&&) const &, int const&>(cl); 160 test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl); 161 test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl); 162 163 test_b12<int&&(NonCopyable&&) &&, int&&>(std::move(cl)); 164 test_b12<int const&&(NonCopyable&&) const &&, int const&&>(std::move(cl)); 165 test_b12<int volatile&&(NonCopyable&&) volatile &&, int volatile&&>(std::move(cl)); 166 test_b12<int const volatile&&(NonCopyable&&) const volatile &&, int const volatile&&>(std::move(cl)); 167 } 168 { 169 DerivedFromTestClass cl(42); 170 test_b12<int&(NonCopyable&&) &, int&>(cl); 171 test_b12<int const&(NonCopyable&&) const &, int const&>(cl); 172 test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl); 173 test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl); 174 175 test_b12<int&&(NonCopyable&&) &&, int&&>(std::move(cl)); 176 test_b12<int const&&(NonCopyable&&) const &&, int const&&>(std::move(cl)); 177 test_b12<int volatile&&(NonCopyable&&) volatile &&, int volatile&&>(std::move(cl)); 178 test_b12<int const volatile&&(NonCopyable&&) const volatile &&, int const volatile&&>(std::move(cl)); 179 } 180 { 181 TestClass cl_obj(42); 182 std::reference_wrapper<TestClass> cl(cl_obj); 183 test_b12<int&(NonCopyable&&) &, int&>(cl); 184 test_b12<int const&(NonCopyable&&) const &, int const&>(cl); 185 test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl); 186 test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl); 187 188 test_b12<int&(NonCopyable&&) &, int&>(std::move(cl)); 189 test_b12<int const&(NonCopyable&&) const &, int const&>(std::move(cl)); 190 test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(std::move(cl)); 191 test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(std::move(cl)); 192 } 193 { 194 DerivedFromTestClass cl_obj(42); 195 std::reference_wrapper<DerivedFromTestClass> cl(cl_obj); 196 test_b12<int&(NonCopyable&&) &, int&>(cl); 197 test_b12<int const&(NonCopyable&&) const &, int const&>(cl); 198 test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl); 199 test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl); 200 201 test_b12<int&(NonCopyable&&) &, int&>(std::move(cl)); 202 test_b12<int const&(NonCopyable&&) const &, int const&>(std::move(cl)); 203 test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(std::move(cl)); 204 test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(std::move(cl)); 205 } 206 { 207 TestClass cl_obj(42); 208 TestClass *cl = &cl_obj; 209 test_b12<int&(NonCopyable&&) &, int&>(cl); 210 test_b12<int const&(NonCopyable&&) const &, int const&>(cl); 211 test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl); 212 test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl); 213 } 214 { 215 DerivedFromTestClass cl_obj(42); 216 DerivedFromTestClass *cl = &cl_obj; 217 test_b12<int&(NonCopyable&&) &, int&>(cl); 218 test_b12<int const&(NonCopyable&&) const &, int const&>(cl); 219 test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl); 220 test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl); 221 } 222 } 223 224 void bullet_three_four_tests() { 225 { 226 typedef TestClass Fn; 227 Fn cl(42); 228 test_b34<int&>(cl); 229 test_b34<int const&>(static_cast<Fn const&>(cl)); 230 test_b34<int volatile&>(static_cast<Fn volatile&>(cl)); 231 test_b34<int const volatile&>(static_cast<Fn const volatile &>(cl)); 232 233 test_b34<int&&>(static_cast<Fn &&>(cl)); 234 test_b34<int const&&>(static_cast<Fn const&&>(cl)); 235 test_b34<int volatile&&>(static_cast<Fn volatile&&>(cl)); 236 test_b34<int const volatile&&>(static_cast<Fn const volatile&&>(cl)); 237 } 238 { 239 typedef DerivedFromTestClass Fn; 240 Fn cl(42); 241 test_b34<int&>(cl); 242 test_b34<int const&>(static_cast<Fn const&>(cl)); 243 test_b34<int volatile&>(static_cast<Fn volatile&>(cl)); 244 test_b34<int const volatile&>(static_cast<Fn const volatile &>(cl)); 245 246 test_b34<int&&>(static_cast<Fn &&>(cl)); 247 test_b34<int const&&>(static_cast<Fn const&&>(cl)); 248 test_b34<int volatile&&>(static_cast<Fn volatile&&>(cl)); 249 test_b34<int const volatile&&>(static_cast<Fn const volatile&&>(cl)); 250 } 251 { 252 typedef TestClass Fn; 253 Fn cl(42); 254 test_b34<int&>(std::reference_wrapper<Fn>(cl)); 255 test_b34<int const&>(std::reference_wrapper<Fn const>(cl)); 256 test_b34<int volatile&>(std::reference_wrapper<Fn volatile>(cl)); 257 test_b34<int const volatile&>(std::reference_wrapper<Fn const volatile>(cl)); 258 } 259 { 260 typedef DerivedFromTestClass Fn; 261 Fn cl(42); 262 test_b34<int&>(std::reference_wrapper<Fn>(cl)); 263 test_b34<int const&>(std::reference_wrapper<Fn const>(cl)); 264 test_b34<int volatile&>(std::reference_wrapper<Fn volatile>(cl)); 265 test_b34<int const volatile&>(std::reference_wrapper<Fn const volatile>(cl)); 266 } 267 { 268 typedef TestClass Fn; 269 Fn cl_obj(42); 270 Fn* cl = &cl_obj; 271 test_b34<int&>(cl); 272 test_b34<int const&>(static_cast<Fn const*>(cl)); 273 test_b34<int volatile&>(static_cast<Fn volatile*>(cl)); 274 test_b34<int const volatile&>(static_cast<Fn const volatile *>(cl)); 275 } 276 { 277 typedef DerivedFromTestClass Fn; 278 Fn cl_obj(42); 279 Fn* cl = &cl_obj; 280 test_b34<int&>(cl); 281 test_b34<int const&>(static_cast<Fn const*>(cl)); 282 test_b34<int volatile&>(static_cast<Fn volatile*>(cl)); 283 test_b34<int const volatile&>(static_cast<Fn const volatile *>(cl)); 284 } 285 } 286 287 void bullet_five_tests() { 288 using FooType = int&(NonCopyable&&); 289 { 290 FooType& fn = foo; 291 test_b5<int &>(fn); 292 } 293 { 294 FooType* fn = foo; 295 test_b5<int &>(fn); 296 } 297 { 298 typedef TestClass Fn; 299 Fn cl(42); 300 test_b5<int&>(cl); 301 test_b5<int const&>(static_cast<Fn const&>(cl)); 302 test_b5<int volatile&>(static_cast<Fn volatile&>(cl)); 303 test_b5<int const volatile&>(static_cast<Fn const volatile &>(cl)); 304 305 test_b5<int&&>(static_cast<Fn &&>(cl)); 306 test_b5<int const&&>(static_cast<Fn const&&>(cl)); 307 test_b5<int volatile&&>(static_cast<Fn volatile&&>(cl)); 308 test_b5<int const volatile&&>(static_cast<Fn const volatile&&>(cl)); 309 } 310 } 311 312 struct CopyThrows { 313 CopyThrows() {} 314 CopyThrows(CopyThrows const&) {} 315 CopyThrows(CopyThrows&&) noexcept {} 316 }; 317 318 struct NoThrowCallable { 319 void operator()() noexcept {} 320 void operator()(CopyThrows) noexcept {} 321 }; 322 323 struct ThrowsCallable { 324 void operator()() {} 325 }; 326 327 struct MemberObj { 328 int x; 329 }; 330 331 void noexcept_test() { 332 { 333 NoThrowCallable obj; ((void)obj); // suppress unused warning 334 CopyThrows arg; ((void)arg); // suppress unused warning 335 static_assert(noexcept(std::invoke(obj)), ""); 336 static_assert(!noexcept(std::invoke(obj, arg)), ""); 337 static_assert(noexcept(std::invoke(obj, std::move(arg))), ""); 338 } 339 { 340 ThrowsCallable obj; ((void)obj); // suppress unused warning 341 static_assert(!noexcept(std::invoke(obj)), ""); 342 } 343 { 344 MemberObj obj{42}; ((void)obj); // suppress unused warning. 345 static_assert(noexcept(std::invoke(&MemberObj::x, obj)), ""); 346 } 347 } 348 349 int main(int, char**) { 350 bullet_one_two_tests(); 351 bullet_three_four_tests(); 352 bullet_five_tests(); 353 noexcept_test(); 354 355 return 0; 356 } 357