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 // PR7359 test17(int x)287 void test17(int x) { 288 switch (x >= 17) { // expected-warning {{switch condition has boolean value}} 289 case 0: return; 290 } 291 292 switch ((int) (x <= 17)) { 293 case 0: return; 294 } 295 } 296 test18()297 int test18() { 298 enum { A, B } a; 299 switch (a) { 300 case A: return 0; 301 case B: return 1; 302 case 7: return 1; // expected-warning {{case value not in enumerated type}} 303 default: return 2; // expected-warning {{default label in switch which covers all enumeration values}} 304 } 305 } 306 307 // rdar://110822110 308 typedef enum { 309 kOne = 1, 310 } Ints; 311 rdar110822110(Ints i)312 void rdar110822110(Ints i) 313 { 314 switch (i) { 315 case kOne: 316 break; 317 case 2: // expected-warning {{case value not in enumerated type 'Ints'}} 318 break; 319 default: // expected-warning {{default label in switch which covers all enumeration values}} 320 break; 321 } 322 } 323 324 // PR9243 325 #define TEST19MACRO 5 test19(int i)326 void test19(int i) { 327 enum { 328 kTest19Enum1 = 7, 329 kTest19Enum2 = kTest19Enum1 330 }; 331 const int a = 3; 332 switch (i) { 333 case 5: // expected-note {{previous case}} 334 case TEST19MACRO: // expected-error {{duplicate case value '5'}} 335 336 case 7: // expected-note {{previous case}} 337 case kTest19Enum1: // expected-error {{duplicate case value: '7' and 'kTest19Enum1' both equal '7'}} \ 338 // expected-note {{previous case}} 339 case kTest19Enum1: // expected-error {{duplicate case value 'kTest19Enum1'}} \ 340 // expected-note {{previous case}} 341 case kTest19Enum2: // expected-error {{duplicate case value: 'kTest19Enum1' and 'kTest19Enum2' both equal '7'}} \ 342 // expected-note {{previous case}} 343 case (int)kTest19Enum2: //expected-error {{duplicate case value 'kTest19Enum2'}} 344 345 case 3: // expected-note {{previous case}} 346 case a: // expected-error {{duplicate case value: '3' and 'a' both equal '3'}} \ 347 // expected-note {{previous case}} 348 case a: // expected-error {{duplicate case value 'a'}} 349 break; 350 } 351 } 352 353 // Allow the warning 'case value not in enumerated type' to be silenced with 354 // the following pattern. 355 // 356 // If 'case' expression refers to a static const variable of the correct enum 357 // type, then we count this as a sufficient declaration of intent by the user, 358 // so we silence the warning. 359 enum ExtendedEnum1 { 360 EE1_a, 361 EE1_b 362 }; 363 364 enum ExtendedEnum1_unrelated { EE1_misc }; 365 366 static const enum ExtendedEnum1 EE1_c = 100; 367 static const enum ExtendedEnum1_unrelated EE1_d = 101; 368 switch_on_ExtendedEnum1(enum ExtendedEnum1 e)369 void switch_on_ExtendedEnum1(enum ExtendedEnum1 e) { 370 switch(e) { 371 case EE1_a: break; 372 case EE1_b: break; 373 case EE1_c: break; // no-warning 374 case EE1_d: break; // expected-warning {{case value not in enumerated type 'enum ExtendedEnum1'}} 375 } 376 } 377 PR11778(char c,int n,long long ll)378 void PR11778(char c, int n, long long ll) { 379 // Do not reject this; we don't have duplicate case values because we 380 // check for duplicates in the promoted type. 381 switch (c) case 1: case 257: ; // expected-warning {{overflow}} 382 383 switch (n) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}} 384 switch ((int)ll) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}} 385 switch ((long long)n) case 0x100000001LL: case 1: ; 386 switch (ll) case 0x100000001LL: case 1: ; 387 } 388