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, c++17
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 // constexpr // constexpr in C++20
18 // invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)
19 // noexcept(is_nothrow_invocable_v<_Fn, _Args...>);
20
21 /// C++14 [func.def] 20.9.0
22 /// (1) The following definitions apply to this Clause:
23 /// (2) A call signature is the name of a return type followed by a parenthesized
24 /// comma-separated list of zero or more argument types.
25 /// (3) A callable type is a function object type (20.9) or a pointer to member.
26 /// (4) A callable object is an object of a callable type.
27 /// (5) A call wrapper type is a type that holds a callable object and supports
28 /// a call operation that forwards to that object.
29 /// (6) A call wrapper is an object of a call wrapper type.
30 /// (7) A target object is the callable object held by a call wrapper.
31
32 /// C++14 [func.require] 20.9.1
33 ///
34 /// Define INVOKE (f, t1, t2, ..., tN) as follows:
35 /// (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
36 /// type T or a reference to an object of type T or a reference to an object of a type derived from T;
37 /// (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
38 /// the types described in the previous item;
39 /// (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
40 /// reference to an object of type T or a reference to an object of a type derived from T;
41 /// (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
42 /// described in the previous item;
43 /// (1.5) - f(t1, t2, ..., tN) in all other cases.
44
45 #include <functional>
46 #include <type_traits>
47 #include <utility> // for std::move
48 #include <cassert>
49
50 #include "test_macros.h"
51
52 struct NonCopyable {
NonCopyableNonCopyable53 constexpr NonCopyable() {}
54 private:
55 NonCopyable(NonCopyable const&) = delete;
56 NonCopyable& operator=(NonCopyable const&) = delete;
57 };
58
59 struct TestClass {
TestClassTestClass60 constexpr explicit TestClass(int x) : data(x) {}
61
operator ()TestClass62 constexpr int& operator()(NonCopyable&&) & { return data; }
operator ()TestClass63 constexpr int const& operator()(NonCopyable&&) const & { return data; }
64
operator ()TestClass65 constexpr int&& operator()(NonCopyable&&) && { return std::move(data); }
operator ()TestClass66 constexpr int const&& operator()(NonCopyable&&) const && { return std::move(data); }
67
68 int data;
69 private:
70 TestClass(TestClass const&) = delete;
71 TestClass& operator=(TestClass const&) = delete;
72 };
73
74 struct DerivedFromTestClass : public TestClass {
DerivedFromTestClassDerivedFromTestClass75 constexpr explicit DerivedFromTestClass(int x) : TestClass(x) {}
76 };
77
78 static constexpr int data = 42;
foo(NonCopyable &&)79 constexpr const int& foo(NonCopyable&&) {
80 return data;
81 }
82
83 template <class Signature, class Expect, class Functor>
test_b12(Functor && f)84 constexpr void test_b12(Functor&& f) {
85 // Create the callable object.
86 typedef Signature TestClass::*ClassFunc;
87 ClassFunc func_ptr = &TestClass::operator();
88
89 // Create the dummy arg.
90 NonCopyable arg;
91
92 // Check that the deduced return type of invoke is what is expected.
93 typedef decltype(
94 std::invoke(func_ptr, std::forward<Functor>(f), std::move(arg))
95 ) DeducedReturnType;
96 static_assert((std::is_same<DeducedReturnType, Expect>::value), "");
97
98 // Check that result_of_t matches Expect.
99 typedef typename std::result_of<ClassFunc&&(Functor&&, NonCopyable&&)>::type
100 ResultOfReturnType;
101 static_assert((std::is_same<ResultOfReturnType, Expect>::value), "");
102
103 // Run invoke and check the return value.
104 DeducedReturnType ret =
105 std::invoke(func_ptr, std::forward<Functor>(f), std::move(arg));
106 assert(ret == 42);
107 }
108
109 template <class Expect, class Functor>
test_b34(Functor && f)110 constexpr void test_b34(Functor&& f) {
111 // Create the callable object.
112 typedef int TestClass::*ClassFunc;
113 ClassFunc func_ptr = &TestClass::data;
114
115 // Check that the deduced return type of invoke is what is expected.
116 typedef decltype(
117 std::invoke(func_ptr, std::forward<Functor>(f))
118 ) DeducedReturnType;
119 static_assert((std::is_same<DeducedReturnType, Expect>::value), "");
120
121 // Check that result_of_t matches Expect.
122 typedef typename std::result_of<ClassFunc&&(Functor&&)>::type
123 ResultOfReturnType;
124 static_assert((std::is_same<ResultOfReturnType, Expect>::value), "");
125
126 // Run invoke and check the return value.
127 DeducedReturnType ret =
128 std::invoke(func_ptr, std::forward<Functor>(f));
129 assert(ret == 42);
130 }
131
132 template <class Expect, class Functor>
test_b5(Functor && f)133 constexpr void test_b5(Functor&& f) {
134 NonCopyable arg;
135
136 // Check that the deduced return type of invoke is what is expected.
137 typedef decltype(
138 std::invoke(std::forward<Functor>(f), std::move(arg))
139 ) DeducedReturnType;
140 static_assert((std::is_same<DeducedReturnType, Expect>::value), "");
141
142 // Check that result_of_t matches Expect.
143 typedef typename std::result_of<Functor&&(NonCopyable&&)>::type
144 ResultOfReturnType;
145 static_assert((std::is_same<ResultOfReturnType, Expect>::value), "");
146
147 // Run invoke and check the return value.
148 DeducedReturnType ret = std::invoke(std::forward<Functor>(f), std::move(arg));
149 assert(ret == 42);
150 }
151
bullet_one_two_tests()152 constexpr bool bullet_one_two_tests() {
153 {
154 TestClass cl(42);
155 test_b12<int&(NonCopyable&&) &, int&>(cl);
156 test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
157
158 test_b12<int&&(NonCopyable&&) &&, int&&>(std::move(cl));
159 test_b12<int const&&(NonCopyable&&) const &&, int const&&>(std::move(cl));
160 }
161 {
162 DerivedFromTestClass cl(42);
163 test_b12<int&(NonCopyable&&) &, int&>(cl);
164 test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
165
166 test_b12<int&&(NonCopyable&&) &&, int&&>(std::move(cl));
167 test_b12<int const&&(NonCopyable&&) const &&, int const&&>(std::move(cl));
168 }
169 {
170 TestClass cl_obj(42);
171 std::reference_wrapper<TestClass> cl(cl_obj);
172 test_b12<int&(NonCopyable&&) &, int&>(cl);
173 test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
174
175 test_b12<int&(NonCopyable&&) &, int&>(std::move(cl));
176 test_b12<int const&(NonCopyable&&) const &, int const&>(std::move(cl));
177 }
178 {
179 DerivedFromTestClass cl_obj(42);
180 std::reference_wrapper<DerivedFromTestClass> cl(cl_obj);
181 test_b12<int&(NonCopyable&&) &, int&>(cl);
182 test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
183
184 test_b12<int&(NonCopyable&&) &, int&>(std::move(cl));
185 test_b12<int const&(NonCopyable&&) const &, int const&>(std::move(cl));
186 }
187 {
188 TestClass cl_obj(42);
189 TestClass *cl = &cl_obj;
190 test_b12<int&(NonCopyable&&) &, int&>(cl);
191 test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
192 }
193 {
194 DerivedFromTestClass cl_obj(42);
195 DerivedFromTestClass *cl = &cl_obj;
196 test_b12<int&(NonCopyable&&) &, int&>(cl);
197 test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
198 }
199 return true;
200 }
201
bullet_three_four_tests()202 constexpr bool bullet_three_four_tests() {
203 {
204 typedef TestClass Fn;
205 Fn cl(42);
206 test_b34<int&>(cl);
207 test_b34<int const&>(static_cast<Fn const&>(cl));
208
209 test_b34<int&&>(static_cast<Fn &&>(cl));
210 test_b34<int const&&>(static_cast<Fn const&&>(cl));
211 }
212 {
213 typedef DerivedFromTestClass Fn;
214 Fn cl(42);
215 test_b34<int&>(cl);
216 test_b34<int const&>(static_cast<Fn const&>(cl));
217
218 test_b34<int&&>(static_cast<Fn &&>(cl));
219 test_b34<int const&&>(static_cast<Fn const&&>(cl));
220 }
221 {
222 typedef TestClass Fn;
223 Fn cl(42);
224 test_b34<int&>(std::reference_wrapper<Fn>(cl));
225 test_b34<int const&>(std::reference_wrapper<Fn const>(cl));
226 }
227 {
228 typedef DerivedFromTestClass Fn;
229 Fn cl(42);
230 test_b34<int&>(std::reference_wrapper<Fn>(cl));
231 test_b34<int const&>(std::reference_wrapper<Fn const>(cl));
232 }
233 {
234 typedef TestClass Fn;
235 Fn cl_obj(42);
236 Fn* cl = &cl_obj;
237 test_b34<int&>(cl);
238 test_b34<int const&>(static_cast<Fn const*>(cl));
239 }
240 {
241 typedef DerivedFromTestClass Fn;
242 Fn cl_obj(42);
243 Fn* cl = &cl_obj;
244 test_b34<int&>(cl);
245 test_b34<int const&>(static_cast<Fn const*>(cl));
246 }
247 return true;
248 }
249
bullet_five_tests()250 constexpr bool bullet_five_tests() {
251 using FooType = const int&(NonCopyable&&);
252 {
253 FooType& fn = foo;
254 test_b5<const int &>(fn);
255 }
256 {
257 FooType* fn = foo;
258 test_b5<const int &>(fn);
259 }
260 {
261 typedef TestClass Fn;
262 Fn cl(42);
263 test_b5<int&>(cl);
264 test_b5<int const&>(static_cast<Fn const&>(cl));
265
266 test_b5<int&&>(static_cast<Fn &&>(cl));
267 test_b5<int const&&>(static_cast<Fn const&&>(cl));
268 }
269 return true;
270 }
271
main(int,char **)272 int main(int, char**) {
273 bullet_one_two_tests();
274 bullet_three_four_tests();
275 bullet_five_tests();
276
277 static_assert(bullet_one_two_tests());
278 static_assert(bullet_three_four_tests());
279 static_assert(bullet_five_tests());
280
281 return 0;
282 }
283