1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wimplicit-fallthrough -Wunreachable-code-fallthrough %s
2 
3 
4 int fallthrough(int n) {
5   switch (n / 10) {
6       if (n - 1) {
7         n = 100;
8       } else if (n - 2) {
9         n = 101;
10       } else if (n - 3) {
11         n = 102;
12       }
13     case -1:  // no warning here, ignore fall-through from unreachable code
14       ;
15     case 0: {// expected-warning{{unannotated fall-through between switch labels}} expected-note{{insert '[[clang::fallthrough]];' to silence this warning}} expected-note{{insert 'break;' to avoid fall-through}}
16     }
17     case 1:  // expected-warning{{unannotated fall-through between switch labels}} expected-note{{insert '[[clang::fallthrough]];' to silence this warning}} expected-note{{insert 'break;' to avoid fall-through}}
18       n += 100         ;
19     case 3:  // expected-warning{{unannotated fall-through between switch labels}} expected-note{{insert '[[clang::fallthrough]];' to silence this warning}} expected-note{{insert 'break;' to avoid fall-through}}
20       if (n > 0)
21         n += 200;
22     case 4:  // expected-warning{{unannotated fall-through between switch labels}} expected-note{{insert '[[clang::fallthrough]];' to silence this warning}} expected-note{{insert 'break;' to avoid fall-through}}
23       if (n < 0)
24         ;
25     case 5:  // expected-warning{{unannotated fall-through between switch labels}} expected-note{{insert '[[clang::fallthrough]];' to silence this warning}} expected-note{{insert 'break;' to avoid fall-through}}
26       switch (n) {
27       case 111:
28         break;
29       case 112:
30         break;
31       case 113:
32         break    ;
33       }
34     case 6:  // expected-warning{{unannotated fall-through between switch labels}} expected-note{{insert '[[clang::fallthrough]];' to silence this warning}} expected-note{{insert 'break;' to avoid fall-through}}
35       n += 300;
36     case 66:  // expected-warning{{unannotated fall-through between switch labels}} expected-note{{insert 'break;' to avoid fall-through}}
37     case 67:
38     case 68:
39       break;
40   }
41   switch (n / 15) {
42 label_default:
43     default:
44       n += 333;
45       if (n % 10)
46         goto label_default;
47       break;
48     case 70:
49       n += 335;
50       break;
51   }
52   switch (n / 20) {
53     case 7:
54       n += 400;
55       [[clang::fallthrough]];
56     case 9:  // no warning here, intended fall-through marked with an attribute
57       n += 800;
58       [[clang::fallthrough]];
59     default: { // no warning here, intended fall-through marked with an attribute
60       if (n % 2 == 0) {
61         return 1;
62       } else {
63         [[clang::fallthrough]];
64       }
65     }
66     case 10:  // no warning here, intended fall-through marked with an attribute
67       if (n % 3 == 0) {
68         n %= 3;
69       } else {
70         [[clang::fallthrough]];
71       }
72     case 110:  // expected-warning{{unannotated fall-through between switch labels}} but no fix-it hint as we have one fall-through annotation!
73       n += 800;
74   }
75   switch (n / 30) {
76     case 11:
77     case 12:  // no warning here, intended fall-through, no statement between labels
78       n += 1600;
79   }
80   switch (n / 40) {
81     case 13:
82       if (n % 2 == 0) {
83         return 1;
84       } else {
85         return 2;
86       }
87     case 15:  // no warning here, there's no fall-through
88       n += 3200;
89   }
90   switch (n / 50) {
91     case 17: {
92       if (n % 2 == 0) {
93         return 1;
94       } else {
95         return 2;
96       }
97     }
98     case 19: { // no warning here, there's no fall-through
99       n += 6400;
100       return 3;
101     }
102     case 21: { // no warning here, there's no fall-through
103       break;
104     }
105     case 23: // no warning here, there's no fall-through
106       n += 128000;
107       break;
108     case 25: // no warning here, there's no fall-through
109       break;
110   }
111 
112   return n;
113 }
114 
115 class ClassWithDtor {
116 public:
117   ~ClassWithDtor() {}
118 };
119 
120 void fallthrough2(int n) {
121   switch (n) {
122     case 0:
123     {
124       ClassWithDtor temp;
125       break;
126     }
127     default: // no warning here, there's no fall-through
128       break;
129   }
130 }
131 
132 void fallthrough3(int n) {
133   switch (n) {
134     case 1:
135       do {
136         return;
137       } while (0);
138     case 2:
139       do {
140         ClassWithDtor temp;
141         return;
142       } while (0);
143     case 3:
144       break;
145   }
146 }
147 
148 #define MY_SWITCH(X, Y, Z, U, V) switch (X) { case Y: Z; case U: V; }
149 #define MY_SWITCH2(X, Y, Z) switch (X) { Y; Z; }
150 #define MY_CASE(X, Y) case X: Y
151 #define MY_CASE2(X, Y, U, V) case X: Y; case U: V
152 
153 int fallthrough_macro1(int n) {
154   MY_SWITCH(n, 13, n *= 2, 14, break)  // expected-warning{{unannotated fall-through between switch labels}}
155 
156   switch (n + 1) {
157     MY_CASE(33, n += 2);
158     MY_CASE(44, break);  // expected-warning{{unannotated fall-through between switch labels}}
159     MY_CASE(55, n += 3);
160   }
161 
162   switch (n + 3) {
163     MY_CASE(333, return 333);
164     MY_CASE2(444, n += 44, 4444, break);  // expected-warning{{unannotated fall-through between switch labels}}
165     MY_CASE(555, n += 33);
166   }
167 
168   MY_SWITCH2(n + 4, MY_CASE(17, n *= 3), MY_CASE(19, break))  // expected-warning{{unannotated fall-through between switch labels}}
169 
170   MY_SWITCH2(n + 5, MY_CASE(21, break), MY_CASE2(23, n *= 7, 25, break))  // expected-warning{{unannotated fall-through between switch labels}}
171 
172   return n;
173 }
174 
175 void fallthrough_cfgblock_with_null_successor(int x) {
176   (x && "") ? (void)(0) : (void)(1);
177   switch (x) {}
178 }
179 
180 int fallthrough_position(int n) {
181   switch (n) {
182       n += 300;
183       [[clang::fallthrough]];  // expected-warning{{fallthrough annotation in unreachable code}}
184     case 221:
185       return 1;
186       [[clang::fallthrough]];  // expected-warning{{fallthrough annotation in unreachable code}}
187     case 222:
188       return 2;
189       __attribute__((fallthrough)); // expected-warning{{fallthrough annotation in unreachable code}}
190     case 223:
191       n += 400;
192     case 224: // expected-warning{{unannotated fall-through between switch labels}} expected-note{{insert '[[clang::fallthrough]];' to silence this warning}} expected-note{{insert 'break;' to avoid fall-through}}
193         ;
194   }
195 
196 #pragma clang diagnostic push
197 #pragma clang diagnostic ignored "-Wunreachable-code-fallthrough"
198   switch (n) {
199       n += 300;
200       [[clang::fallthrough]];  // no warning here
201     case 221:
202       return 1;
203       [[clang::fallthrough]];  // no warning here
204     case 222:
205       return 2;
206       __attribute__((fallthrough)); // no warning here
207     case 223:
208       if (1)
209         return 3;
210       __attribute__((fallthrough)); // no warning here
211     case 224:
212       n += 400;
213   }
214 #pragma clang diagnostic pop
215 
216   long p = static_cast<long>(n) * n;
217   switch (sizeof(p)) {
218     case 9:
219       n += static_cast<int>(p >> 32);
220       [[clang::fallthrough]];  // no warning here
221     case 5:
222       n += static_cast<int>(p);
223       [[clang::fallthrough]];  // no warning here
224     default:
225       n += 1;
226       break;
227   }
228 
229   return n;
230 }
231 
232 enum Enum {
233   Value1, Value2
234 };
235 
236 int fallthrough_covered_enums(Enum e) {
237   int n = 0;
238   switch (e) {
239     default:
240       n += 17;
241       [[clang::fallthrough]];  // no warning here, this shouldn't be treated as unreachable code
242     case Value1:
243       n += 19;
244       break;
245     case Value2:
246       n += 21;
247       break;
248   }
249   return n;
250 }
251 
252 // Fallthrough annotations in local classes used to generate "fallthrough
253 // annotation does not directly precede switch label" warning.
254 void fallthrough_in_local_class() {
255   class C {
256     void f(int x) {
257       switch (x) {
258         case 0:
259           x++;
260           [[clang::fallthrough]]; // no diagnostics
261         case 1:
262           x++;
263         default: // \
264             expected-warning{{unannotated fall-through between switch labels}} \
265             expected-note{{insert 'break;' to avoid fall-through}}
266           break;
267       }
268     }
269   };
270 }
271 
272 // Fallthrough annotations in lambdas used to generate "fallthrough
273 // annotation does not directly precede switch label" warning.
274 void fallthrough_in_lambda() {
275   (void)[] {
276     int x = 0;
277     switch (x) {
278     case 0:
279       x++;
280       [[clang::fallthrough]]; // no diagnostics
281     case 1:
282       x++;
283     default: // \
284         expected-warning{{unannotated fall-through between switch labels}} \
285         expected-note{{insert 'break;' to avoid fall-through}}
286       break;
287     }
288   };
289 }
290 
291 namespace PR18983 {
292   void fatal() __attribute__((noreturn));
293   int num();
294   void test() {
295     switch (num()) {
296     case 1:
297       fatal();
298       // Don't issue a warning.
299     case 2:
300       break;
301     }
302   }
303 }
304 
305 int fallthrough_placement_error(int n) {
306   switch (n) {
307       [[clang::fallthrough]]; // expected-warning{{fallthrough annotation in unreachable code}}
308       n += 300;
309     case 221:
310       [[clang::fallthrough]]; // expected-error{{fallthrough annotation does not directly precede switch label}}
311       return 1;
312     case 222:
313       [[clang::fallthrough]]; // expected-error{{fallthrough annotation does not directly precede switch label}}
314       n += 400;
315       [[clang::fallthrough]];
316     case 223:
317       [[clang::fallthrough]]; // expected-error{{fallthrough annotation does not directly precede switch label}}
318   }
319   return n;
320 }
321 
322 int fallthrough_targets(int n) {
323   [[clang::fallthrough]]; // expected-error{{fallthrough annotation is outside switch statement}}
324 
325   [[clang::fallthrough]]  // expected-error{{'fallthrough' attribute only applies to empty statements}}
326   switch (n) {
327     case 121:
328       n += 400;
329       [[clang::fallthrough]]; // no warning here, correct target
330     case 123:
331       [[clang::fallthrough]]  // expected-error{{'fallthrough' attribute only applies to empty statements}}
332       n += 800;
333       break;
334     [[clang::fallthrough]]    // expected-error{{'fallthrough' attribute is only allowed on empty statements}} expected-note{{did you forget ';'?}}
335     case 125:
336       n += 1600;
337   }
338   return n;
339 }
340 
341 int fallthrough_alt_spelling(int n) {
342   switch (n) {
343   case 0:
344     n++;
345     [[clang::fallthrough]];
346   case 1:
347     n++;
348     [[clang::__fallthrough__]];
349   case 2:
350     n++;
351     break;
352   }
353   return n;
354 }
355 
356 int fallthrough_attribute_spelling(int n) {
357   switch (n) {
358   case 0:
359     n++;
360     __attribute__((fallthrough));
361   case 1:
362     n++;
363     break;
364   }
365   return n;
366 }
367