Debian Codegraph @

clang-tools-extra/test/clang-tidy/checkers/bugprone/throw-keyword-missing.cpp

raw
1 // RUN: %check_clang_tidy %s bugprone-throw-keyword-missing %t -- -- -fexceptions
2
3 namespace std {
4
5 // std::string declaration (taken from test/clang-tidy/readability-redundant-string-cstr-msvc.cpp).
6 template <typename T>
7 class allocator {};
8 template <typename T>
9 class char_traits {};
10 template <typename C, typename T = std::char_traits<C>, typename A = std::allocator<C>>
11 struct basic_string {
12 basic_string();
13 basic_string(const basic_string &);
14 // MSVC headers define two constructors instead of using optional arguments.
15 basic_string(const C *);
16 basic_string(const C *, const A &);
17 ~basic_string();
18 };
19 typedef basic_string<char> string;
20 typedef basic_string<wchar_t> wstring;
21
22 // std::exception and std::runtime_error declaration.
23 struct exception {
24 exception();
25 exception(const exception &other);
26 virtual ~exception();
27 };
28
29 struct runtime_error : public exception {
30 explicit runtime_error(const std::string &what_arg);
31 };
32
33 } // namespace std
34
35 // The usage of this class should never emit a warning.
36 struct RegularClass {};
37
38 // Class name contains the substring "exception", in certain cases using this class should emit a warning.
39 struct RegularException {
40 RegularException() {}
41
42 // Constructors with a single argument are treated differently (cxxFunctionalCastExpr).
43 RegularException(int) {}
44 };
45
46 // --------------
47
48 void stdExceptionNotTrownTest(int i) {
49 if (i < 0)
50 // CHECK-MESSAGES: :[[@LINE+1]]:5: warning: suspicious exception object created but not thrown; did you mean 'throw {{.*}}'? [bugprone-throw-keyword-missing]
51 std::exception();
52
53 if (i > 0)
54 // CHECK-MESSAGES: :[[@LINE+1]]:5: warning: suspicious exception
55 std::runtime_error("Unexpected argument");
56 }
57
58 void stdExceptionThrownTest(int i) {
59 if (i < 0)
60 throw std::exception();
61
62 if (i > 0)
63 throw std::runtime_error("Unexpected argument");
64 }
65
66 void regularClassNotThrownTest(int i) {
67 if (i < 0)
68 RegularClass();
69 }
70
71 void regularClassThrownTest(int i) {
72 if (i < 0)
73 throw RegularClass();
74 }
75
76 void nameContainsExceptionNotThrownTest(int i) {
77 if (i < 0)
78 // CHECK-MESSAGES: :[[@LINE+1]]:5: warning: suspicious exception
79 RegularException();
80
81 if (i > 0)
82 // CHECK-MESSAGES: :[[@LINE+1]]:5: warning: suspicious exception
83 RegularException(5);
84 }
85
86 void nameContainsExceptionThrownTest(int i) {
87 if (i < 0)
88 throw RegularException();
89
90 if (i > 0)
91 throw RegularException(5);
92 }
93
94 template <class Exception>
95 void f(int i, Exception excToBeThrown) {}
96
97 template <class SomeType>
98 void templ(int i) {
99 if (i > 0)
100 SomeType();
101 }
102
103 void funcCallWithTempExcTest() {
104 f(5, RegularException());
105
106 templ<RegularException>(4);
107 templ<RegularClass>(4);
108 }
109
110 // Global variable initialization test.
111 RegularException exc = RegularException();
112 RegularException *excptr = new RegularException();
113
114 void localVariableInitTest() {
115 RegularException exc = RegularException();
116 RegularException *excptr = new RegularException();
117 }
118
119 class CtorInitializerListTest {
120 RegularException exc;
121 RegularException exc2{};
122
123 CtorInitializerListTest() : exc(RegularException()) {}
124
125 CtorInitializerListTest(int) try : exc(RegularException()) {
126 // Constructor body
127 } catch (...) {
128 // CHECK-MESSAGES: :[[@LINE+1]]:5: warning: suspicious exception
129 RegularException();
130 }
131
132 CtorInitializerListTest(float);
133 };
134
135 CtorInitializerListTest::CtorInitializerListTest(float) try : exc(RegularException()) {
136 // Constructor body
137 } catch (...) {
138 // CHECK-MESSAGES: :[[@LINE+1]]:3: warning: suspicious exception
139 RegularException();
140 }
141
142 RegularException funcReturningExceptionTest(int i) {
143 return RegularException();
144 }
145
146 void returnedValueTest() {
147 funcReturningExceptionTest(3);
148 }
149
150 struct ClassBracedInitListTest {
151 ClassBracedInitListTest(RegularException exc) {}
152 };
153
154 void foo(RegularException, ClassBracedInitListTest) {}
155
156 void bracedInitListTest() {
157 RegularException exc{};
158 ClassBracedInitListTest test = {RegularException()};
159 foo({}, {RegularException()});
160 }
161
162 typedef std::exception ERROR_BASE;
163 class RegularError : public ERROR_BASE {};
164
165 void typedefTest() {
166 // CHECK-MESSAGES: :[[@LINE+1]]:3: warning: suspicious exception
167 RegularError();
168 }
169
170 struct ExceptionRAII {
171 ExceptionRAII() {}
172 ~ExceptionRAII() {}
173 };
174
175 void exceptionRAIITest() {
176 ExceptionRAII E;
177 }
178
179 namespace std {
180 typedef decltype(sizeof(void*)) size_t;
181 }
182
183 void* operator new(std::size_t, void*);
184
185 void placeMentNewTest() {
186 alignas(RegularException) unsigned char expr[sizeof(RegularException)];
187 new (expr) RegularException{};
188 }