clang/test/Sema/switch.c

   1 // RUN: %clang_cc1 -fsyntax-only -verify -Wswitch-enum -Wcovered-switch-default -triple x86_64-linux-gnu %s
   2 void f (int z) {
   3   while (z) {
   4     default: z--;            // expected-error {{statement not in switch}}
   5   }
   6 }
   7
   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
  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(void);
  33
  34 void test4(void)
  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
  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
  76 void test6(void) {
  77   char ch = 'a';
  78   switch(ch) {
  79     case 1234:  // expected-warning {{overflow converting case value}}
  80       break;
  81   }
  82 }
  83
  84 // PR5606
  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
  95 void test7(void) {
  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 (unnamed 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 (unnamed enum}}
 119         4: //expected-warning{{case value not in enumerated type 'enum (unnamed 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 (unnamed enum}}
 128       break;
 129   }
 130   switch(a) {
 131     case 1 ... 3: //expected-warning{{case value not in enumerated type 'enum (unnamed enum}}
 132       break;
 133   }
 134   switch(a) {
 135     case 0 ...  //expected-warning{{case value not in enumerated type 'enum (unnamed enum}}
 136       3:  //expected-warning{{case value not in enumerated type 'enum (unnamed enum}}
 137       break;
 138   }
 139
 140 }
 141
 142 void test8(void) {
 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
 164 void test9(void) {
 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 (unnamed enum}}
 171     case 1:
 172     case 2: //expected-warning{{case value not in enumerated type 'enum (unnamed enum}}
 173     case 3:
 174     case 4: //expected-warning{{case value not in enumerated type 'enum (unnamed enum}}
 175       break;
 176   }
 177 }
 178
 179 void test10(void) {
 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 (unnamed enum}}
 188             1:  //expected-warning{{case value not in enumerated type 'enum (unnamed enum}}
 189     case 2 ... 4:
 190     case 5 ...  //expected-warning{{case value not in enumerated type 'enum (unnamed enum}}
 191               9:  //expected-warning{{case value not in enumerated type 'enum (unnamed enum}}
 192     case 10 ... 12:
 193     case 13 ...  //expected-warning{{case value not in enumerated type 'enum (unnamed enum}}
 194               16: //expected-warning{{case value not in enumerated type 'enum (unnamed enum}}
 195       break;
 196   }
 197 }
 198
 199 void test11(void) {
 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
 221 void test12(void) {
 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
 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
 256 int test14(int a) {
 257   switch(a) {
 258   case EC0: return 0;
 259   case EC1: return 1;
 260   }
 261   return 0;
 262 }
 263
 264 void f1(unsigned x) {
 265   switch (x) {
 266   case -1: break;
 267   default: break;
 268   }
 269 }
 270
 271 void test15(void) {
 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
 279 void test16(void) {
 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
 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
 308 int test18(void) {
 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
 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
 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
 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
 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 }