1 // RUN: %clang_cc1 -fsyntax-only -verify -Wswitch-enum -Wcovered-switch-default -triple x86_64-linux-gnu %s
f(int z)2 void f (int z) {
3 while (z) {
4 default: z--; // expected-error {{statement not in switch}}
5 }
6 }
7
foo(int X)8 void foo(int X) {
9 switch (X) {
10 case 42: ; // expected-note {{previous case}}
11 case 5000000000LL: // expected-warning {{overflow}}
12 case 42: // expected-error {{duplicate case value '42'}}
13 ;
14
15 case 100 ... 99: ; // expected-warning {{empty case range}}
16
17 case 43: ; // expected-note {{previous case}}
18 case 43 ... 45: ; // expected-error {{duplicate case value}}
19
20 case 100 ... 20000:; // expected-note {{previous case}}
21 case 15000 ... 40000000:; // expected-error {{duplicate case value}}
22 }
23 }
24
test3(void)25 void test3(void) {
26 // empty switch;
27 switch (0); // expected-warning {{no case matching constant switch condition '0'}} \
28 // expected-warning {{switch statement has empty body}} \
29 // expected-note{{put the semicolon on a separate line to silence this warning}}
30 }
31
32 extern int g();
33
test4()34 void test4()
35 {
36 int cond;
37 switch (cond) {
38 case 0 && g():
39 case 1 || g():
40 break;
41 }
42
43 switch(cond) {
44 case g(): // expected-error {{expression is not an integer constant expression}}
45 case 0 ... g(): // expected-error {{expression is not an integer constant expression}}
46 break;
47 }
48
49 switch (cond) {
50 case 0 && g() ... 1 || g():
51 break;
52 }
53
54 switch (cond) {
55 case g() // expected-error {{expression is not an integer constant expression}}
56 && 0:
57 break;
58 }
59
60 switch (cond) {
61 case 0 ...
62 g() // expected-error {{expression is not an integer constant expression}}
63 || 1:
64 break;
65 }
66 }
67
test5(int z)68 void test5(int z) {
69 switch(z) {
70 default: // expected-note {{previous case defined here}}
71 default: // expected-error {{multiple default labels in one switch}}
72 break;
73 }
74 }
75
test6()76 void test6() {
77 char ch = 'a';
78 switch(ch) {
79 case 1234: // expected-warning {{overflow converting case value}}
80 break;
81 }
82 }
83
84 // PR5606
f0(int var)85 int f0(int var) {
86 switch (va) { // expected-error{{use of undeclared identifier 'va'}}
87 case 1:
88 break;
89 case 2:
90 return 1;
91 }
92 return 2;
93 }
94
test7()95 void test7() {
96 enum {
97 A = 1,
98 B
99 } a;
100 switch(a) { //expected-warning{{enumeration value 'B' not handled in switch}}
101 case A:
102 break;
103 }
104 switch(a) {
105 case B:
106 case A:
107 break;
108 }
109 switch(a) {
110 case A:
111 case B:
112 case 3: // expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
113 break;
114 }
115 switch(a) {
116 case A:
117 case B:
118 case 3 ... //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
119 4: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
120 break;
121 }
122 switch(a) {
123 case 1 ... 2:
124 break;
125 }
126 switch(a) {
127 case 0 ... 2: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
128 break;
129 }
130 switch(a) {
131 case 1 ... 3: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
132 break;
133 }
134 switch(a) {
135 case 0 ... //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
136 3: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
137 break;
138 }
139
140 }
141
test8()142 void test8() {
143 enum {
144 A,
145 B,
146 C = 1
147 } a;
148 switch(a) {
149 case A:
150 case B:
151 break;
152 }
153 switch(a) {
154 case A:
155 case C:
156 break;
157 }
158 switch(a) { //expected-warning{{enumeration value 'B' not handled in switch}}
159 case A:
160 break;
161 }
162 }
163
test9()164 void test9() {
165 enum {
166 A = 3,
167 C = 1
168 } a;
169 switch(a) {
170 case 0: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
171 case 1:
172 case 2: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
173 case 3:
174 case 4: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
175 break;
176 }
177 }
178
test10()179 void test10() {
180 enum {
181 A = 10,
182 C = 2,
183 B = 4,
184 D = 12
185 } a;
186 switch(a) {
187 case 0 ... //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
188 1: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
189 case 2 ... 4:
190 case 5 ... //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
191 9: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
192 case 10 ... 12:
193 case 13 ... //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
194 16: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
195 break;
196 }
197 }
198
test11()199 void test11() {
200 enum {
201 A = -1,
202 B,
203 C
204 } a;
205 switch(a) { //expected-warning{{enumeration value 'A' not handled in switch}}
206 case B:
207 case C:
208 break;
209 }
210
211 switch(a) { //expected-warning{{enumeration value 'A' not explicitly handled in switch}}
212 case B:
213 case C:
214 break;
215
216 default:
217 break;
218 }
219 }
220
test12()221 void test12() {
222 enum {
223 A = -1,
224 B = 4294967286
225 } a;
226 switch(a) {
227 case A:
228 case B:
229 break;
230 }
231 }
232
233 // <rdar://problem/7643909>
234 typedef enum {
235 val1,
236 val2,
237 val3
238 } my_type_t;
239
test13(my_type_t t)240 int test13(my_type_t t) {
241 switch(t) { // expected-warning{{enumeration value 'val3' not handled in switch}}
242 case val1:
243 return 1;
244 case val2:
245 return 2;
246 }
247 return -1;
248 }
249
250 // <rdar://problem/7658121>
251 enum {
252 EC0 = 0xFFFF0000,
253 EC1 = 0xFFFF0001,
254 };
255
test14(int a)256 int test14(int a) {
257 switch(a) {
258 case EC0: return 0;
259 case EC1: return 1;
260 }
261 return 0;
262 }
263
f1(unsigned x)264 void f1(unsigned x) {
265 switch (x) {
266 case -1: break;
267 default: break;
268 }
269 }
270
test15()271 void test15() {
272 int i = 0;
273 switch (1) { // expected-warning {{no case matching constant switch condition '1'}}
274 case 0: i = 0; break;
275 case 2: i++; break;
276 }
277 }
278
test16()279 void test16() {
280 const char c = '5';
281 switch (c) { // expected-warning {{no case matching constant switch condition '53'}}
282 case '6': return;
283 }
284 }
285
286 struct bitfield_member {
287 unsigned bf : 1;
288 };
289
290 // PR7359
test17(int x)291 void test17(int x) {
292 switch (x >= 17) { // expected-warning {{switch condition has boolean value}}
293 case 0: return;
294 }
295
296 switch ((int) (x <= 17)) {
297 case 0: return;
298 }
299
300 struct bitfield_member bm;
301 switch (bm.bf) { // no warning
302 case 0:
303 case 1:
304 return;
305 }
306 }
307
test18()308 int test18() {
309 enum { A, B } a;
310 switch (a) {
311 case A: return 0;
312 case B: return 1;
313 case 7: return 1; // expected-warning {{case value not in enumerated type}}
314 default: return 2; // expected-warning {{default label in switch which covers all enumeration values}}
315 }
316 }
317
318 // rdar://110822110
319 typedef enum {
320 kOne = 1,
321 } Ints;
322
rdar110822110(Ints i)323 void rdar110822110(Ints i)
324 {
325 switch (i) {
326 case kOne:
327 break;
328 case 2: // expected-warning {{case value not in enumerated type 'Ints'}}
329 break;
330 default: // expected-warning {{default label in switch which covers all enumeration values}}
331 break;
332 }
333 }
334
335 // PR9243
336 #define TEST19MACRO 5
test19(int i)337 void test19(int i) {
338 enum {
339 kTest19Enum1 = 7,
340 kTest19Enum2 = kTest19Enum1
341 };
342 const int a = 3;
343 switch (i) {
344 case 5: // expected-note {{previous case}}
345 case TEST19MACRO: // expected-error {{duplicate case value '5'}}
346
347 case 7: // expected-note {{previous case}}
348 case kTest19Enum1: // expected-error {{duplicate case value: '7' and 'kTest19Enum1' both equal '7'}} \
349 // expected-note {{previous case}}
350 case kTest19Enum1: // expected-error {{duplicate case value 'kTest19Enum1'}} \
351 // expected-note {{previous case}}
352 case kTest19Enum2: // expected-error {{duplicate case value: 'kTest19Enum1' and 'kTest19Enum2' both equal '7'}} \
353 // expected-note {{previous case}}
354 case (int)kTest19Enum2: //expected-error {{duplicate case value 'kTest19Enum2'}}
355
356 case 3: // expected-note {{previous case}}
357 case a: // expected-error {{duplicate case value: '3' and 'a' both equal '3'}} \
358 // expected-note {{previous case}}
359 case a: // expected-error {{duplicate case value 'a'}}
360 break;
361 }
362 }
363
364 // Allow the warning 'case value not in enumerated type' to be silenced with
365 // the following pattern.
366 //
367 // If 'case' expression refers to a static const variable of the correct enum
368 // type, then we count this as a sufficient declaration of intent by the user,
369 // so we silence the warning.
370 enum ExtendedEnum1 {
371 EE1_a,
372 EE1_b
373 };
374
375 enum ExtendedEnum1_unrelated { EE1_misc };
376
377 static const enum ExtendedEnum1 EE1_c = 100;
378 static const enum ExtendedEnum1_unrelated EE1_d = 101;
379
switch_on_ExtendedEnum1(enum ExtendedEnum1 e)380 void switch_on_ExtendedEnum1(enum ExtendedEnum1 e) {
381 switch(e) {
382 case EE1_a: break;
383 case EE1_b: break;
384 case EE1_c: break; // no-warning
385 case EE1_d: break; // expected-warning {{case value not in enumerated type 'enum ExtendedEnum1'}}
386 // expected-warning@-1 {{comparison of different enumeration types in switch statement ('enum ExtendedEnum1' and 'enum ExtendedEnum1_unrelated')}}
387 }
388 }
389
PR11778(char c,int n,long long ll)390 void PR11778(char c, int n, long long ll) {
391 // Do not reject this; we don't have duplicate case values because we
392 // check for duplicates in the promoted type.
393 switch (c) case 1: case 257: ; // expected-warning {{overflow}}
394
395 switch (n) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}}
396 switch ((int)ll) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}}
397 switch ((long long)n) case 0x100000001LL: case 1: ;
398 switch (ll) case 0x100000001LL: case 1: ;
399 }
400