Clang Project

clang_source_code/test/SemaCXX/exceptions.cpp
1// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
2// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
3// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
4
5struct A; // expected-note 4 {{forward declaration of 'A'}}
6
7struct Abstract { virtual void f() = 0; }; // expected-note {{unimplemented pure virtual method 'f'}}
8
9void trys() {
10  int k = 42;
11  try {
12  } catch(int i) { // expected-note {{previous definition}}
13    int j = i;
14    int i; // expected-error {{redefinition of 'i'}}
15  } catch(float i) {
16  } catch(void v) { // expected-error {{cannot catch incomplete type 'void'}}
17  } catch(A a) { // expected-error {{cannot catch incomplete type 'A'}}
18  } catch(A *a) { // expected-error {{cannot catch pointer to incomplete type 'A'}}
19  } catch(A &a) { // expected-error {{cannot catch reference to incomplete type 'A'}}
20  } catch(Abstract) { // expected-error {{variable type 'Abstract' is an abstract class}}
21  } catch(...) {
22    int ref = k;
23    {
24      int ref = k;
25    }
26    int j = i; // expected-error {{use of undeclared identifier 'i'}}
27  }
28
29  try {
30  } catch(...) { // expected-error {{catch-all handler must come last}}
31  } catch(int) {
32  }
33}
34
35void throws() {
36  throw;
37  throw 0;
38  throw throw; // expected-error {{cannot throw object of incomplete type 'void'}}
39  throw (A*)0; // expected-error {{cannot throw pointer to object of incomplete type 'A'}}
40}
41
42void jumps() {
43l1:
44  goto l5;
45  goto l4; // expected-error {{cannot jump}}
46  goto l3; // expected-error {{cannot jump}}
47  goto l2; // expected-error {{cannot jump}}
48  goto l1;
49  try { // expected-note 4 {{jump bypasses initialization of try block}}
50  l2:
51    goto l5;
52    goto l4; // expected-error {{cannot jump}}
53    goto l3; // expected-error {{cannot jump}}
54    goto l2;
55    goto l1;
56  } catch(int) { // expected-note 4 {{jump bypasses initialization of catch block}}
57  l3:
58    goto l5;
59    goto l4; // expected-error {{cannot jump}}
60    goto l3;
61    goto l2; // expected-error {{cannot jump}}
62    goto l1;
63  } catch(...) { // expected-note 4 {{jump bypasses initialization of catch block}}
64  l4:
65    goto l5;
66    goto l4;
67    goto l3; // expected-error {{cannot jump}}
68    goto l2; // expected-error {{cannot jump}}
69    goto l1;
70  }
71l5:
72  goto l5;
73  goto l4; // expected-error {{cannot jump}}
74  goto l3; // expected-error {{cannot jump}}
75  goto l2; // expected-error {{cannot jump}}
76  goto l1;
77}
78
79struct BadReturn {
80  BadReturn() try {
81  } catch(...) {
82    // Try to hide
83    try {
84    } catch(...) {
85      {
86        if (0)
87          return; // expected-error {{return in the catch of a function try block of a constructor is illegal}}
88      }
89    }
90  }
91  BadReturn(int);
92};
93
94BadReturn::BadReturn(int) try {
95} catch(...) {
96  // Try to hide
97  try {
98  } catch(int) {
99    return; // expected-error {{return in the catch of a function try block of a constructor is illegal}}
100  } catch(...) {
101    {
102      if (0)
103        return; // expected-error {{return in the catch of a function try block of a constructor is illegal}}
104    }
105  }
106}
107
108// Cannot throw an abstract type.
109class foo {
110public:
111  foo() {}
112  void bar () {
113    throw *this; // expected-error{{cannot throw an object of abstract type 'foo'}}
114  }
115  virtual void test () = 0; // expected-note{{unimplemented pure virtual method 'test'}}
116};
117
118namespace PR6831 {
119  namespace NA { struct S; }
120  namespace NB { struct S; }
121  
122  void f() {
123    using namespace NA;
124    using namespace NB;
125    try {
126    } catch (int S) { 
127    }
128  }
129}
130
131namespace Decay {
132  struct A {
133    void f() throw (A[10]);
134  };
135
136  template<typename T> struct B {
137    void f() throw (B[10]);
138  };
139  template struct B<int>;
140
141  void f() throw (int[10], int(*)());
142  void f() throw (int*, int());
143
144  template<typename T> struct C {
145    void f() throw (T);
146#if __cplusplus <= 199711L
147    // expected-error@-2 {{pointer to incomplete type 'Decay::E' is not allowed in exception specification}}
148#endif
149  };
150  struct D {
151    C<D[10]> c;
152  };
153  struct E;
154#if __cplusplus <= 199711L
155  // expected-note@-2 {{forward declaration of 'Decay::E'}}
156#endif
157
158  C<E[10]> e;
159#if __cplusplus <= 199711L
160  // expected-note@-2 {{in instantiation of template class 'Decay::C<Decay::E [10]>' requested here}}
161#endif
162}
163
164void rval_ref() throw (int &&); // expected-error {{rvalue reference type 'int &&' is not allowed in exception specification}}
165#if __cplusplus <= 199711L
166// expected-warning@-2 {{rvalue references are a C++11 extension}}
167#endif
168
169namespace HandlerInversion {
170struct B {};
171struct D : B {};
172struct D2 : D {};
173
174void f1() {
175  try {
176  } catch (B &b) { // expected-note {{for type 'HandlerInversion::B &'}}
177  } catch (D &d) { // expected-warning {{exception of type 'HandlerInversion::D &' will be caught by earlier handler}}
178  }
179}
180
181void f2() {
182  try {
183  } catch (B *b) { // expected-note {{for type 'HandlerInversion::B *'}}
184  } catch (D *d) { // expected-warning {{exception of type 'HandlerInversion::D *' will be caught by earlier handler}}
185  }
186}
187
188void f3() {
189  try {
190  } catch (D &d) { // Ok
191  } catch (B &b) {
192  }
193}
194
195void f4() {
196  try {
197  } catch (B &b) { // Ok
198  }
199}
200
201void f5() {
202  try {
203  } catch (int) {
204  } catch (float) {
205  }
206}
207
208void f6() {
209  try {
210  } catch (B &b) {  // expected-note {{for type 'HandlerInversion::B &'}}
211  } catch (D2 &d) {  // expected-warning {{exception of type 'HandlerInversion::D2 &' will be caught by earlier handler}}
212  }
213}
214
215void f7() {
216  try {
217  } catch (B *b) { // Ok
218  } catch (D &d) { // Ok
219  }
220
221  try {
222  } catch (B b) { // Ok
223  } catch (D *d) { // Ok
224  }
225}
226
227void f8() {
228  try {
229  } catch (const B &b) {  // expected-note {{for type 'const HandlerInversion::B &'}}
230  } catch (D2 &d) {  // expected-warning {{exception of type 'HandlerInversion::D2 &' will be caught by earlier handler}}
231  }
232
233  try {
234  } catch (B &b) {  // expected-note {{for type 'HandlerInversion::B &'}}
235  } catch (const D2 &d) {  // expected-warning {{exception of type 'const HandlerInversion::D2 &' will be caught by earlier handler}}
236  }
237
238  try {
239  } catch (B b) { // expected-note {{for type 'HandlerInversion::B'}}
240  } catch (D &d) { // expected-warning {{exception of type 'HandlerInversion::D &' will be caught by earlier handler}}
241  }
242}
243}
244
245namespace ConstVolatileThrow {
246struct S {
247  S() {}         // expected-note{{candidate constructor not viable}}
248  S(const S &s); // expected-note{{candidate constructor not viable}}
249};
250
251typedef const volatile S CVS;
252
253void f() {
254  throw CVS(); // expected-error{{no matching constructor for initialization}}
255}
256}
257
258namespace ConstVolatileCatch {
259struct S {
260  S() {}
261  S(const volatile S &s);
262
263private:
264  S(const S &s); // expected-note {{declared private here}}
265};
266
267void f();
268
269void g() {
270  try {
271    f();
272  } catch (volatile S s) { // expected-error {{calling a private constructor}}
273  }
274}
275}
276
277namespace PR28047 {
278void test1(int i) {
279  try {
280  } catch (int(*)[i]) { // expected-error{{cannot catch variably modified type}}
281  }
282}
283void test2() {
284  int i;
285  try {
286  } catch (int(*)[i]) { // expected-error{{cannot catch variably modified type}}
287  }
288}
289}
290
CodeThinker, Enjoy your reading code