1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // <functional> 11 12 // template<class F> 13 // function(F) -> function<see-below>; 14 15 // UNSUPPORTED: c++03, c++11, c++14 16 17 #include <functional> 18 #include <type_traits> 19 #include <utility> 20 21 #include "test_macros.h" 22 23 struct R { }; 24 struct A1 { }; 25 struct A2 { }; 26 struct A3 { }; 27 28 #define DECLARE_FUNCTIONS_WITH_QUALS(N, ...) \ 29 struct f0_##N { R operator()() __VA_ARGS__ { return {}; } }; \ 30 struct f1_##N { R operator()(A1) __VA_ARGS__ { return {}; } }; \ 31 struct f2_##N { R operator()(A1, A2) __VA_ARGS__ { return {}; } }; \ 32 struct f3_##N { R operator()(A1, A2, A3) __VA_ARGS__ { return {}; } } \ 33 /**/ 34 35 DECLARE_FUNCTIONS_WITH_QUALS(0, /* nothing */); 36 DECLARE_FUNCTIONS_WITH_QUALS(1, const); 37 DECLARE_FUNCTIONS_WITH_QUALS(2, volatile); 38 DECLARE_FUNCTIONS_WITH_QUALS(3, const volatile); 39 DECLARE_FUNCTIONS_WITH_QUALS(4, &); 40 DECLARE_FUNCTIONS_WITH_QUALS(5 , const &); 41 DECLARE_FUNCTIONS_WITH_QUALS(6 , volatile &); 42 DECLARE_FUNCTIONS_WITH_QUALS(7 , const volatile &); 43 DECLARE_FUNCTIONS_WITH_QUALS(8 , noexcept); 44 DECLARE_FUNCTIONS_WITH_QUALS(9 , const noexcept); 45 DECLARE_FUNCTIONS_WITH_QUALS(10, volatile noexcept); 46 DECLARE_FUNCTIONS_WITH_QUALS(11, const volatile noexcept); 47 DECLARE_FUNCTIONS_WITH_QUALS(12, & noexcept); 48 DECLARE_FUNCTIONS_WITH_QUALS(13, const & noexcept); 49 DECLARE_FUNCTIONS_WITH_QUALS(14, volatile & noexcept); 50 DECLARE_FUNCTIONS_WITH_QUALS(15, const volatile & noexcept); 51 52 int main(int, char**) { 53 #define CHECK_FUNCTIONS(N) \ 54 do { \ 55 /* implicit */ \ 56 std::function g0 = f0_##N{}; \ 57 ASSERT_SAME_TYPE(decltype(g0), std::function<R()>); \ 58 \ 59 std::function g1 = f1_##N{}; \ 60 ASSERT_SAME_TYPE(decltype(g1), std::function<R(A1)>); \ 61 \ 62 std::function g2 = f2_##N{}; \ 63 ASSERT_SAME_TYPE(decltype(g2), std::function<R(A1, A2)>); \ 64 \ 65 std::function g3 = f3_##N{}; \ 66 ASSERT_SAME_TYPE(decltype(g3), std::function<R(A1, A2, A3)>); \ 67 \ 68 /* explicit */ \ 69 std::function g4{f0_##N{}}; \ 70 ASSERT_SAME_TYPE(decltype(g4), std::function<R()>); \ 71 \ 72 std::function g5{f1_##N{}}; \ 73 ASSERT_SAME_TYPE(decltype(g5), std::function<R(A1)>); \ 74 \ 75 std::function g6{f2_##N{}}; \ 76 ASSERT_SAME_TYPE(decltype(g6), std::function<R(A1, A2)>); \ 77 \ 78 std::function g7{f3_##N{}}; \ 79 ASSERT_SAME_TYPE(decltype(g7), std::function<R(A1, A2, A3)>); \ 80 \ 81 /* from std::function */ \ 82 std::function<R(A1)> unary; \ 83 std::function g8 = unary; \ 84 ASSERT_SAME_TYPE(decltype(g8), std::function<R(A1)>); \ 85 \ 86 std::function g9 = std::move(unary); \ 87 ASSERT_SAME_TYPE(decltype(g9), std::function<R(A1)>); \ 88 \ 89 std::function<R(A1&&)> unary_ref; \ 90 std::function g10 = unary_ref; \ 91 ASSERT_SAME_TYPE(decltype(g10), std::function<R(A1&&)>); \ 92 \ 93 std::function g11 = std::move(unary_ref); \ 94 ASSERT_SAME_TYPE(decltype(g11), std::function<R(A1&&)>); \ 95 } while (false) \ 96 /**/ 97 98 // Make sure we can deduce from function objects with valid call operators 99 CHECK_FUNCTIONS(0); 100 CHECK_FUNCTIONS(1); 101 CHECK_FUNCTIONS(2); 102 CHECK_FUNCTIONS(3); 103 CHECK_FUNCTIONS(4); 104 CHECK_FUNCTIONS(5); 105 CHECK_FUNCTIONS(6); 106 CHECK_FUNCTIONS(7); 107 CHECK_FUNCTIONS(8); 108 CHECK_FUNCTIONS(9); 109 CHECK_FUNCTIONS(10); 110 CHECK_FUNCTIONS(11); 111 CHECK_FUNCTIONS(12); 112 CHECK_FUNCTIONS(13); 113 CHECK_FUNCTIONS(14); 114 CHECK_FUNCTIONS(15); 115 116 return 0; 117 } 118 119 // Make sure we fail in a SFINAE-friendly manner when we try to deduce 120 // from a type without a valid call operator. 121 template <typename F, typename = decltype(std::function{std::declval<F>()})> 122 constexpr bool can_deduce() { return true; } 123 template <typename F> 124 constexpr bool can_deduce(...) { return false; } 125 126 struct invalid1 { }; 127 struct invalid2 { 128 template <typename ...Args> 129 void operator()(Args ...); 130 }; 131 struct invalid3 { 132 void operator()(int); 133 void operator()(long); 134 }; 135 static_assert(!can_deduce<invalid1>()); 136 static_assert(!can_deduce<invalid2>()); 137 static_assert(!can_deduce<invalid3>()); 138