Home | History | Annotate | Download | only in SemaCXX 
      1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wimplicit-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       n += 400;
    189     case 223:          // 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}}
    190       ;
    191   }
    192 
    193   long p = static_cast<long>(n) * n;
    194   switch (sizeof(p)) {
    195     case 9:
    196       n += static_cast<int>(p >> 32);
    197       [[clang::fallthrough]];  // no warning here
    198     case 5:
    199       n += static_cast<int>(p);
    200       [[clang::fallthrough]];  // no warning here
    201     default:
    202       n += 1;
    203       break;
    204   }
    205 
    206   return n;
    207 }
    208 
    209 enum Enum {
    210   Value1, Value2
    211 };
    212 
    213 int fallthrough_covered_enums(Enum e) {
    214   int n = 0;
    215   switch (e) {
    216     default:
    217       n += 17;
    218       [[clang::fallthrough]];  // no warning here, this shouldn't be treated as unreachable code
    219     case Value1:
    220       n += 19;
    221       break;
    222     case Value2:
    223       n += 21;
    224       break;
    225   }
    226   return n;
    227 }
    228 
    229 // Fallthrough annotations in local classes used to generate "fallthrough
    230 // annotation does not directly precede switch label" warning.
    231 void fallthrough_in_local_class() {
    232   class C {
    233     void f(int x) {
    234       switch (x) {
    235         case 0:
    236           x++;
    237           [[clang::fallthrough]]; // no diagnostics
    238         case 1:
    239           x++;
    240         default: // \
    241             expected-warning{{unannotated fall-through between switch labels}} \
    242             expected-note{{insert 'break;' to avoid fall-through}}
    243           break;
    244       }
    245     }
    246   };
    247 }
    248 
    249 // Fallthrough annotations in lambdas used to generate "fallthrough
    250 // annotation does not directly precede switch label" warning.
    251 void fallthrough_in_lambda() {
    252   (void)[] {
    253     int x = 0;
    254     switch (x) {
    255     case 0:
    256       x++;
    257       [[clang::fallthrough]]; // no diagnostics
    258     case 1:
    259       x++;
    260     default: // \
    261         expected-warning{{unannotated fall-through between switch labels}} \
    262         expected-note{{insert 'break;' to avoid fall-through}}
    263       break;
    264     }
    265   };
    266 }
    267 
    268 namespace PR18983 {
    269   void fatal() __attribute__((noreturn));
    270   int num();
    271   void test() {
    272     switch (num()) {
    273     case 1:
    274       fatal();
    275       // Don't issue a warning.
    276     case 2:
    277       break;
    278     }
    279   }
    280 }
    281 
    282 int fallthrough_placement_error(int n) {
    283   switch (n) {
    284       [[clang::fallthrough]]; // expected-warning{{fallthrough annotation in unreachable code}}
    285       n += 300;
    286     case 221:
    287       [[clang::fallthrough]]; // expected-error{{fallthrough annotation does not directly precede switch label}}
    288       return 1;
    289     case 222:
    290       [[clang::fallthrough]]; // expected-error{{fallthrough annotation does not directly precede switch label}}
    291       n += 400;
    292       [[clang::fallthrough]];
    293     case 223:
    294       [[clang::fallthrough]]; // expected-error{{fallthrough annotation does not directly precede switch label}}
    295   }
    296   return n;
    297 }
    298 
    299 int fallthrough_targets(int n) {
    300   [[clang::fallthrough]]; // expected-error{{fallthrough annotation is outside switch statement}}
    301 
    302   [[clang::fallthrough]]  // expected-error{{fallthrough attribute is only allowed on empty statements}}
    303   switch (n) {
    304     case 121:
    305       n += 400;
    306       [[clang::fallthrough]]; // no warning here, correct target
    307     case 123:
    308       [[clang::fallthrough]]  // expected-error{{fallthrough attribute is only allowed on empty statements}}
    309       n += 800;
    310       break;
    311     [[clang::fallthrough]]    // expected-error{{fallthrough attribute is only allowed on empty statements}} expected-note{{did you forget ';'?}}
    312     case 125:
    313       n += 1600;
    314   }
    315   return n;
    316 }
    317