clang/test/SemaCXX/switch-implicit-fallthrough.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wimplicit-fallthrough -Wunreachable-code-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     [[likely]] case 6:
  54       [[clang::fallthrough]];
  55     case 7:
  56       n += 400;
  57       [[clang::fallthrough]];
  58     case 9:  // no warning here, intended fall-through marked with an attribute
  59       n += 800;
  60       [[clang::fallthrough]];
  61     default: { // no warning here, intended fall-through marked with an attribute
  62       if (n % 2 == 0) {
  63         return 1;
  64       } else {
  65         [[clang::fallthrough]];
  66       }
  67     }
  68     case 10:  // no warning here, intended fall-through marked with an attribute
  69       if (n % 3 == 0) {
  70         n %= 3;
  71       } else {
  72         [[clang::fallthrough]];
  73       }
  74     case 110:  // expected-warning{{unannotated fall-through between switch labels}} but no fix-it hint as we have one fall-through annotation!
  75       n += 800;
  76   }
  77   switch (n / 30) {
  78     case 6:
  79       [[unlikely, clang::fallthrough]];
  80     case 11:
  81     case 12:  // no warning here, intended fall-through, no statement between labels
  82       n += 1600;
  83   }
  84   switch (n / 40) {
  85     case 13:
  86       if (n % 2 == 0) {
  87         return 1;
  88       } else {
  89         return 2;
  90       }
  91     case 15:  // no warning here, there's no fall-through
  92       n += 3200;
  93   }
  94   switch (n / 50) {
  95     case 17: {
  96       if (n % 2 == 0) {
  97         return 1;
  98       } else {
  99         return 2;
 100       }
 101     }
 102     case 19: { // no warning here, there's no fall-through
 103       n += 6400;
 104       return 3;
 105     }
 106     case 21: { // no warning here, there's no fall-through
 107       break;
 108     }
 109     case 23: // no warning here, there's no fall-through
 110       n += 128000;
 111       break;
 112     case 25: // no warning here, there's no fall-through
 113       break;
 114   }
 115
 116   return n;
 117 }
 118
 119 class ClassWithDtor {
 120 public:
 121   ~ClassWithDtor() {}
 122 };
 123
 124 void fallthrough2(int n) {
 125   switch (n) {
 126     case 0:
 127     {
 128       ClassWithDtor temp;
 129       break;
 130     }
 131     default: // no warning here, there's no fall-through
 132       break;
 133   }
 134 }
 135
 136 void fallthrough3(int n) {
 137   switch (n) {
 138     case 1:
 139       do {
 140         return;
 141       } while (0);
 142     case 2:
 143       do {
 144         ClassWithDtor temp;
 145         return;
 146       } while (0);
 147     case 3:
 148       break;
 149   }
 150 }
 151
 152 #define MY_SWITCH(X, Y, Z, U, V) switch (X) { case Y: Z; case U: V; }
 153 #define MY_SWITCH2(X, Y, Z) switch (X) { Y; Z; }
 154 #define MY_CASE(X, Y) case X: Y
 155 #define MY_CASE2(X, Y, U, V) case X: Y; case U: V
 156
 157 int fallthrough_macro1(int n) {
 158   MY_SWITCH(n, 13, n *= 2, 14, break)  // expected-warning{{unannotated fall-through between switch labels}}
 159
 160   switch (n + 1) {
 161     MY_CASE(33, n += 2);
 162     MY_CASE(44, break);  // expected-warning{{unannotated fall-through between switch labels}}
 163     MY_CASE(55, n += 3);
 164   }
 165
 166   switch (n + 3) {
 167     MY_CASE(333, return 333);
 168     MY_CASE2(444, n += 44, 4444, break);  // expected-warning{{unannotated fall-through between switch labels}}
 169     MY_CASE(555, n += 33);
 170   }
 171
 172   MY_SWITCH2(n + 4, MY_CASE(17, n *= 3), MY_CASE(19, break))  // expected-warning{{unannotated fall-through between switch labels}}
 173
 174   MY_SWITCH2(n + 5, MY_CASE(21, break), MY_CASE2(23, n *= 7, 25, break))  // expected-warning{{unannotated fall-through between switch labels}}
 175
 176   return n;
 177 }
 178
 179 void fallthrough_cfgblock_with_null_successor(int x) {
 180   (x && "") ? (void)(0) : (void)(1);
 181   switch (x) {}
 182 }
 183
 184 int fallthrough_position(int n) {
 185   switch (n) {
 186       n += 300;
 187       [[clang::fallthrough]];  // expected-warning{{fallthrough annotation in unreachable code}}
 188     case 221:
 189       return 1;
 190       [[clang::fallthrough]];  // expected-warning{{fallthrough annotation in unreachable code}}
 191     case 222:
 192       return 2;
 193       __attribute__((fallthrough)); // expected-warning{{fallthrough annotation in unreachable code}}
 194     case 223:
 195       n += 400;
 196     case 224: // 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}}
 197         ;
 198   }
 199
 200 #pragma clang diagnostic push
 201 #pragma clang diagnostic ignored "-Wunreachable-code-fallthrough"
 202   switch (n) {
 203       n += 300;
 204       [[clang::fallthrough]];  // no warning here
 205     case 221:
 206       return 1;
 207       [[clang::fallthrough]];  // no warning here
 208     case 222:
 209       return 2;
 210       __attribute__((fallthrough)); // no warning here
 211     case 223:
 212       if (1)
 213         return 3;
 214       __attribute__((fallthrough)); // no warning here
 215     case 224:
 216       n += 400;
 217   }
 218 #pragma clang diagnostic pop
 219
 220   long p = static_cast<long>(n) * n;
 221   switch (sizeof(p)) {
 222     case 9:
 223       n += static_cast<int>(p >> 32);
 224       [[clang::fallthrough]];  // no warning here
 225     case 5:
 226       n += static_cast<int>(p);
 227       [[clang::fallthrough]];  // no warning here
 228     default:
 229       n += 1;
 230       break;
 231   }
 232
 233   return n;
 234 }
 235
 236 enum Enum {
 237   Value1, Value2
 238 };
 239
 240 int fallthrough_covered_enums(Enum e) {
 241   int n = 0;
 242   switch (e) {
 243     default:
 244       n += 17;
 245       [[clang::fallthrough]];  // no warning here, this shouldn't be treated as unreachable code
 246     case Value1:
 247       n += 19;
 248       break;
 249     case Value2:
 250       n += 21;
 251       break;
 252   }
 253   return n;
 254 }
 255
 256 // Fallthrough annotations in local classes used to generate "fallthrough
 257 // annotation does not directly precede switch label" warning.
 258 void fallthrough_in_local_class() {
 259   class C {
 260     void f(int x) {
 261       switch (x) {
 262         case 0:
 263           x++;
 264           [[clang::fallthrough]]; // no diagnostics
 265         case 1:
 266           x++;
 267         default: // \
 268             expected-warning{{unannotated fall-through between switch labels}} \
 269             expected-note{{insert 'break;' to avoid fall-through}}
 270           break;
 271       }
 272     }
 273   };
 274 }
 275
 276 // Fallthrough annotations in lambdas used to generate "fallthrough
 277 // annotation does not directly precede switch label" warning.
 278 void fallthrough_in_lambda() {
 279   (void)[] {
 280     int x = 0;
 281     switch (x) {
 282     case 0:
 283       x++;
 284       [[clang::fallthrough]]; // no diagnostics
 285     case 1:
 286       x++;
 287     default: // \
 288         expected-warning{{unannotated fall-through between switch labels}} \
 289         expected-note{{insert 'break;' to avoid fall-through}}
 290       break;
 291     }
 292   };
 293 }
 294
 295 namespace PR18983 {
 296   void fatal() __attribute__((noreturn));
 297   int num();
 298   void test() {
 299     switch (num()) {
 300     case 1:
 301       fatal();
 302       // Don't issue a warning.
 303     case 2:
 304       break;
 305     }
 306   }
 307 }
 308
 309 int fallthrough_placement_error(int n) {
 310   switch (n) {
 311       [[clang::fallthrough]]; // expected-warning{{fallthrough annotation in unreachable code}}
 312       n += 300;
 313     case 221:
 314       [[clang::fallthrough]]; // expected-error{{fallthrough annotation does not directly precede switch label}}
 315       return 1;
 316     case 222:
 317       [[clang::fallthrough]]; // expected-error{{fallthrough annotation does not directly precede switch label}}
 318       n += 400;
 319       [[clang::fallthrough]];
 320     case 223:
 321       [[clang::fallthrough]]; // expected-error{{fallthrough annotation does not directly precede switch label}}
 322   }
 323   return n;
 324 }
 325
 326 int fallthrough_targets(int n) {
 327   [[clang::fallthrough]]; // expected-error{{fallthrough annotation is outside switch statement}}
 328
 329   [[clang::fallthrough]]  // expected-error{{'fallthrough' attribute only applies to empty statements}}
 330   switch (n) {
 331     case 121:
 332       n += 400;
 333       [[clang::fallthrough]]; // no warning here, correct target
 334     case 123:
 335       [[clang::fallthrough]]  // expected-error{{'fallthrough' attribute only applies to empty statements}}
 336       n += 800;
 337       break;
 338     [[clang::fallthrough]]    // expected-error{{'fallthrough' attribute is only allowed on empty statements}} expected-note{{did you forget ';'?}}
 339     case 125:
 340       n += 1600;
 341   }
 342   return n;
 343 }
 344
 345 int fallthrough_alt_spelling(int n) {
 346   switch (n) {
 347   case 0:
 348     n++;
 349     [[clang::fallthrough]];
 350   case 1:
 351     n++;
 352     [[clang::__fallthrough__]];
 353   case 2:
 354     n++;
 355     break;
 356   }
 357   return n;
 358 }
 359
 360 int fallthrough_attribute_spelling(int n) {
 361   switch (n) {
 362   case 0:
 363     n++;
 364     __attribute__((fallthrough));
 365   case 1:
 366     n++;
 367     break;
 368   }
 369   return n;
 370 }