Clang Project

clang_source_code/test/SemaCXX/return-noreturn.cpp
1// RUN: %clang_cc1 %s -fsyntax-only -fcxx-exceptions -verify -Wreturn-type -Wmissing-noreturn -Wno-unreachable-code -Wno-covered-switch-default
2// RUN: %clang_cc1 %s -fsyntax-only -fcxx-exceptions -std=c++11 -verify -Wreturn-type -Wmissing-noreturn -Wno-unreachable-code -Wno-covered-switch-default
3
4// A destructor may be marked noreturn and should still influence the CFG.
5void pr6884_abort() __attribute__((noreturn));
6
7struct pr6884_abort_struct {
8  pr6884_abort_struct() {}
9  ~pr6884_abort_struct() __attribute__((noreturn)) { pr6884_abort(); }
10};
11
12struct other { ~other() {} };
13
14// Ensure that destructors from objects are properly modeled in the CFG despite
15// the presence of switches, case statements, labels, and blocks. These tests
16// try to cover bugs reported in both PR6884 and PR10063.
17namespace abort_struct_complex_cfgs {
18  int basic(int x) {
19    switch (x) { default: pr6884_abort(); }
20  }
21  int f1(int x) {
22    switch (x) default: pr6884_abort_struct();
23  }
24  int f2(int x) {
25    switch (x) { default: pr6884_abort_struct(); }
26  }
27  int f2_positive(int x) {
28    switch (x) { default: ; }
29  } // expected-warning {{control reaches end of non-void function}}
30  int f3(int x) {
31    switch (x) { default: { pr6884_abort_struct(); } }
32  }
33  int f4(int x) {
34    switch (x) default: L1: L2: case 4: pr6884_abort_struct();
35  }
36  int f5(int x) {
37    switch (x) default: L1: { L2: case 4: pr6884_abort_struct(); }
38  }
39  int f6(int x) {
40    switch (x) default: L1: L2: case 4: { pr6884_abort_struct(); }
41  }
42
43  // FIXME: detect noreturn destructors triggered by calls to delete.
44  int f7(int x) {
45    switch (x) default: L1: L2: case 4: {
46      pr6884_abort_struct *p = new pr6884_abort_struct();
47      delete p;
48    }
49  } // expected-warning {{control reaches end of non-void function}}
50
51  // Test that these constructs work even when extraneous blocks are created
52  // before and after the switch due to implicit destructors.
53  int g1(int x) {
54    other o;
55    switch (x) default: pr6884_abort_struct();
56  }
57  int g2(int x) {
58    other o;
59    switch (x) { default: pr6884_abort_struct(); }
60  }
61  int g2_positive(int x) {
62    other o;
63    switch (x) { default: ; }
64  } // expected-warning {{control reaches end of non-void function}}
65  int g3(int x) {
66    other o;
67    switch (x) { default: { pr6884_abort_struct(); } }
68  }
69  int g4(int x) {
70    other o;
71    switch (x) default: L1: L2: case 4: pr6884_abort_struct();
72  }
73  int g5(int x) {
74    other o;
75    switch (x) default: L1: { L2: case 4: pr6884_abort_struct(); }
76  }
77  int g6(int x) {
78    other o;
79    switch (x) default: L1: L2: case 4: { pr6884_abort_struct(); }
80  }
81
82  // Test that these constructs work even with variables carrying the no-return
83  // destructor instead of temporaries.
84  int h1(int x) {
85    other o;
86    switch (x) default: pr6884_abort_struct a;
87  }
88  int h2(int x) {
89    other o;
90    switch (x) { default: pr6884_abort_struct a; }
91  }
92  int h3(int x) {
93    other o;
94    switch (x) { default: { pr6884_abort_struct a; } }
95  }
96  int h4(int x) {
97    other o;
98    switch (x) default: L1: L2: case 4: pr6884_abort_struct a;
99  }
100  int h5(int x) {
101    other o;
102    switch (x) default: L1: { L2: case 4: pr6884_abort_struct a; }
103  }
104  int h6(int x) {
105    other o;
106    switch (x) default: L1: L2: case 4: { pr6884_abort_struct a; }
107  }
108}
109
110// PR9380
111struct PR9380 {
112  ~PR9380();
113};
114struct PR9380_B : public PR9380 {
115  PR9380_B( const PR9380& str );
116};
117void test_PR9380(const PR9380& aKey) {
118  const PR9380& flatKey = PR9380_B(aKey);
119}
120
121// Array of objects with destructors.  This is purely a coverage test case.
122void test_array() {
123  PR9380 a[2];
124}
125
126// Test classes wrapped in typedefs.  This is purely a coverage test case
127// for CFGImplictDtor::getDestructorDecl().
128void test_typedefs() {
129  typedef PR9380 PR9380_Ty;
130  PR9380_Ty test;
131  PR9380_Ty test2[20];
132}
133
134// PR9412 - Handle CFG traversal with null successors.
135enum PR9412_MatchType { PR9412_Exact };
136
137template <PR9412_MatchType type> int PR9412_t() {
138  switch (type) {
139    case PR9412_Exact:
140    default:
141        break;
142  }
143} // expected-warning {{control reaches end of non-void function}}
144
145void PR9412_f() {
146    PR9412_t<PR9412_Exact>(); // expected-note {{in instantiation of function template specialization 'PR9412_t<PR9412_Exact>' requested here}}
147}
148
149struct NoReturn {
150  ~NoReturn() __attribute__((noreturn));
151  operator bool() const;
152};
153struct Return {
154  ~Return();
155  operator bool() const;
156};
157
158int testTernaryUnconditionalNoreturn() {
159  true ? NoReturn() : NoReturn();
160}
161
162int testTernaryStaticallyConditionalNoretrunOnTrue() {
163  true ? NoReturn() : Return();
164}
165
166int testTernaryStaticallyConditionalRetrunOnTrue() {
167  true ? Return() : NoReturn();
168} // expected-warning {{control reaches end of non-void function}}
169
170int testTernaryStaticallyConditionalNoretrunOnFalse() {
171  false ? Return() : NoReturn();
172}
173
174int testTernaryStaticallyConditionalRetrunOnFalse() {
175  false ? NoReturn() : Return();
176} // expected-warning {{control reaches end of non-void function}}
177
178int testTernaryConditionalNoreturnTrueBranch(bool value) {
179  value ? (NoReturn() || NoReturn()) : Return();
180} // expected-warning {{control may reach end of non-void function}}
181
182int testTernaryConditionalNoreturnFalseBranch(bool value) {
183  value ? Return() : (NoReturn() || NoReturn());
184} // expected-warning {{control may reach end of non-void function}}
185
186int testConditionallyExecutedComplexTernaryTrueBranch(bool value) {
187  value || (true ? NoReturn() : true);
188} // expected-warning {{control may reach end of non-void function}}
189
190int testConditionallyExecutedComplexTernaryFalseBranch(bool value) {
191  value || (false ? true : NoReturn());
192} // expected-warning {{control may reach end of non-void function}}
193
194int testStaticallyExecutedLogicalOrBranch() {
195  false || NoReturn();
196}
197
198int testStaticallyExecutedLogicalAndBranch() {
199  true && NoReturn();
200}
201
202int testStaticallySkippedLogicalOrBranch() {
203  true || NoReturn();
204} // expected-warning {{control reaches end of non-void function}}
205
206int testStaticallySkppedLogicalAndBranch() {
207  false && NoReturn();
208} // expected-warning {{control reaches end of non-void function}}
209
210int testConditionallyExecutedComplexLogicalBranch(bool value) {
211  value || (true && NoReturn());
212} // expected-warning {{control may reach end of non-void function}}
213
214int testConditionallyExecutedComplexLogicalBranch2(bool value) {
215  (true && value) || (true && NoReturn());
216} // expected-warning {{control may reach end of non-void function}}
217
218int testConditionallyExecutedComplexLogicalBranch3(bool value) {
219  (false && (Return() || true)) || (true && NoReturn());
220}
221
222int testConditionallyExecutedComplexLogicalBranch4(bool value) {
223  false || ((Return() || true) && (true && NoReturn()));
224}
225
226#if __cplusplus >= 201103L
227namespace LambdaVsTemporaryDtor {
228  struct Y { ~Y(); };
229  struct X { template<typename T> X(T, Y = Y()) {} };
230
231  struct Fatal { ~Fatal() __attribute__((noreturn)); };
232  struct FatalCopy { FatalCopy(); FatalCopy(const FatalCopy&, Fatal F = Fatal()); };
233
234  void foo();
235
236  int bar() {
237    X work([](){ Fatal(); });
238    foo();
239  } // expected-warning {{control reaches end of non-void function}}
240
241  int baz() {
242    FatalCopy fc;
243    X work([fc](){});
244    foo();
245  } // ok, initialization of lambda does not return
246}
247#endif
248
249// Ensure that function-try-blocks also check for return values properly.
250int functionTryBlock1(int s) try {
251  return 0;
252} catch (...) {
253} // expected-warning {{control may reach end of non-void function}}
254
255int functionTryBlock2(int s) try {
256} catch (...) {
257  return 0;
258} // expected-warning {{control may reach end of non-void function}}
259
260int functionTryBlock3(int s) try {
261  return 0;
262} catch (...) {
263  return 0;
264} // ok, both paths return.
265
CodeThinker, Enjoy your reading code