• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 // UNSUPPORTED: c++98, c++03, c++11, c++14
11 
12 // type_traits
13 
14 // is_nothrow_callable
15 
16 #include <type_traits>
17 #include <functional>
18 
19 #include "test_macros.h"
20 
21 struct Tag {};
22 
23 struct Implicit {
ImplicitImplicit24   Implicit(int) noexcept {}
25 };
26 
27 struct ThrowsImplicit {
ThrowsImplicitThrowsImplicit28   ThrowsImplicit(int) {}
29 };
30 
31 struct Explicit {
ExplicitExplicit32   explicit Explicit(int) noexcept {}
33 };
34 
35 template <bool IsNoexcept, class Ret, class ...Args>
36 struct CallObject {
37   Ret operator()(Args&&...) const noexcept(IsNoexcept);
38 };
39 
40 template <class Fn>
throws_callable()41 constexpr bool throws_callable() {
42     return std::is_callable<Fn>::value &&
43         !std::is_nothrow_callable<Fn>::value;
44 }
45 
46 template <class Fn, class Ret>
throws_callable()47 constexpr bool throws_callable() {
48     return std::is_callable<Fn, Ret>::value &&
49         !std::is_nothrow_callable<Fn, Ret>::value;
50 }
51 
52 // FIXME(EricWF) Don't test the where noexcept is *not* part of the type system
53 // once implementations have caught up.
test_noexcept_function_pointers()54 void test_noexcept_function_pointers()
55 {
56     struct Dummy { void foo() noexcept {} static void bar() noexcept {} };
57 #if !defined(__cpp_noexcept_function_type)
58     {
59         // Check that PMF's and function pointers *work*. is_nothrow_callable will always
60         // return false because 'noexcept' is not part of the function type.
61         static_assert(throws_callable<decltype(&Dummy::foo)(Dummy&)>(), "");
62         static_assert(throws_callable<decltype(&Dummy::bar)()>(), "");
63     }
64 #else
65     {
66         // Check that PMF's and function pointers actually work and that
67         // is_nothrow_callable returns true for noexcept PMF's and function
68         // pointers.
69         static_assert(std::is_nothrow_callable<decltype(&Dummy::foo)(Dummy&)>::value, "");
70         static_assert(std::is_nothrow_callable<decltype(&Dummy::bar)()>::value, "");
71     }
72 #endif
73 }
74 
main()75 int main()
76 {
77     {
78         // Check that the conversion to the return type is properly checked
79         using Fn = CallObject<true, int>;
80         static_assert(std::is_nothrow_callable<Fn(), Implicit>::value, "");
81         static_assert(std::is_nothrow_callable<Fn(), double>::value, "");
82         static_assert(std::is_nothrow_callable<Fn(), const volatile void>::value, "");
83         static_assert(throws_callable<Fn(), ThrowsImplicit>(), "");
84         static_assert(!std::is_nothrow_callable<Fn(), Explicit>(), "");
85     }
86     {
87         // Check that the conversion to the parameters is properly checked
88         using Fn = CallObject<true, void, const Implicit&, const ThrowsImplicit&>;
89         static_assert(std::is_nothrow_callable<Fn(Implicit&, ThrowsImplicit&)>::value, "");
90         static_assert(std::is_nothrow_callable<Fn(int, ThrowsImplicit&)>::value, "");
91         static_assert(throws_callable<Fn(int, int)>(), "");
92         static_assert(!std::is_nothrow_callable<Fn()>::value, "");
93     }
94     {
95         // Check that the noexcept-ness of function objects is checked.
96         using Fn = CallObject<true, void>;
97         using Fn2 = CallObject<false, void>;
98         static_assert(std::is_nothrow_callable<Fn()>::value, "");
99         static_assert(throws_callable<Fn2()>(), "");
100     }
101     {
102         // Check that PMD derefs are noexcept
103         using Fn = int (Tag::*);
104         static_assert(std::is_nothrow_callable<Fn(Tag&)>::value, "");
105         static_assert(std::is_nothrow_callable<Fn(Tag&), Implicit>::value, "");
106         static_assert(throws_callable<Fn(Tag&), ThrowsImplicit>(), "");
107     }
108     {
109         // Check for is_nothrow_callable_v
110         using Fn = CallObject<true, int>;
111         static_assert(std::is_nothrow_callable_v<Fn()>, "");
112         static_assert(!std::is_nothrow_callable_v<Fn(int)>, "");
113     }
114     test_noexcept_function_pointers();
115 }
116