Home | History | Annotate | Download | only in Sema
      1 // RUN: %clang_cc1 -fsyntax-only -verify -Wswitch-enum -Wcovered-switch-default %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();
     33 
     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 
     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() {
     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() {
     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 
    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 
    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 
    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 
    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 
    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 
    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() {
    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() {
    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
    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 
    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 
    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
    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