283 lines · cpp
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-exception6//7//===----------------------------------------------------------------------===//8 9// UNSUPPORTED: c++03, c++11, c++14, c++1710 11// <functional>12 13// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS14// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS15 16// template<class F, class... Args>17// constexpr // constexpr in C++2018// 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.022/// (1) The following definitions apply to this Clause:23/// (2) A call signature is the name of a return type followed by a parenthesized24/// 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 supports28/// 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.133///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 of36/// 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 of38/// 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 a40/// 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 types42/// 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::move48#include <cassert>49 50#include "test_macros.h"51 52struct NonCopyable {53 constexpr NonCopyable() {}54private:55 NonCopyable(NonCopyable const&) = delete;56 NonCopyable& operator=(NonCopyable const&) = delete;57};58 59struct 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;69private:70 TestClass(TestClass const&) = delete;71 TestClass& operator=(TestClass const&) = delete;72};73 74struct DerivedFromTestClass : public TestClass {75 constexpr explicit DerivedFromTestClass(int x) : TestClass(x) {}76};77 78static constexpr int data = 42;79constexpr const int& foo(NonCopyable&&) {80 return data;81}82 83template <class Signature, class Expect, class Functor>84constexpr 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&&)>::type100 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 109template <class Expect, class Functor>110constexpr 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&&)>::type123 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 132template <class Expect, class Functor>133constexpr 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&&)>::type144 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 152constexpr 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 202constexpr 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 250constexpr 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 272int 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