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 {
53     constexpr NonCopyable() {}
54 private:
55     NonCopyable(NonCopyable const&) = delete;
56     NonCopyable& operator=(NonCopyable const&) = delete;
57 };
58 
59 struct TestClass {
60     constexpr explicit TestClass(int x) : data(x) {}
61 
62     constexpr int& operator()(NonCopyable&&) & { return data; }
63     constexpr int const& operator()(NonCopyable&&) const & { return data; }
64 
65     constexpr int&& operator()(NonCopyable&&) && { return std::move(data); }
66     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 {
75     constexpr explicit DerivedFromTestClass(int x) : TestClass(x) {}
76 };
77 
78 static constexpr int data = 42;
79 constexpr const int& foo(NonCopyable&&) {
80     return data;
81 }
82 
83 template <class Signature,  class Expect, class Functor>
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>
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>
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 
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 
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 
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 
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