// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
// Test switch statement.

// Tests some switch-case statements blocks that should and should not
// cause static warnings.
// This test is not testing runtime behavior, only static warnings.

// None of the cases blocks should cause a warning.
void testSwitch(int x) {
  // Catch all control flow leaving the switch.
  // Run switch in catch clause to check rethrow.
  TRY:
  try {
    throw x;
  } catch (x) {
    // Add loop as break/continue target.
    LOOP:
    do {
      switch (x) {
        case 0:
        case 1:
          nop(x);
          break; // Break switch.
        case 2:
          nop(x);
          break LOOP;
        case 3:
          nop(x);
          continue; // Continue loop.
        case 4:
          nop(x);
          continue LOOP;
        case 5:
          nop(x);
          continue LAST;
        // Avoid warning for "return;"" and "return e;" in same function.
        case 6: //     //# retnon: ok
          nop(x); //   //# retnon: continued
          return; //   //# retnon: continued
        case 7: //     //# retval: ok
          nop(x); //   //# retval: continued
          return x; // //# retval: continued
        case 8:
          nop(x);
          throw x;
        case 9:
          nop(x);
          rethrow;
        case 10:
        case 11:
          {
            nop(x);
            break; // Break switch.
          }
        case 12:
          {
            nop(x);
            break LOOP;
          }
        case 13:
          {
            nop(x);
            continue; // Continue loop.
          }
        case 14:
          {
            nop(x);
            continue LOOP;
          }
        case 15:
          {
            nop(x);
            continue LAST;
          }
        case 16: { //  //# retnon: continued
          nop(x); //   //# retnon: continued
          return; //   //# retnon: continued
        } //           //# retnon: continued
        case 17: { //  //# retval: continued
          nop(x); //   //# retval: continued
          return x; // //# retval: continued
        } //           //# retval: continued
        case 18:
          {
            nop(x);
            throw x;
          }
        case 19:
          {
            nop(x);
            rethrow;
          }
        LAST:
        case 20:
          {
            nop(x);
            // Fallthrough allowed on last statements.
          }
      }
    } while (false);
  } finally {
    // Catch all control flow leaving the switch and ignore it.
    // Use break instead of return to avoid warning for `return` and `return e`
    // in same function.
    break TRY;
  }
}

// All these switch cases should cause warnings.
void testSwitchWarn(x) {
  // Catch all control flow from the switch and ignore it.
  TRY:
  try {
    throw 0;
  } catch (e) {
    // Wrap in loop as target for continue/break.
    LOOP:
    do {
      switch (x) {
        case 0: //                         //# 01: static type warning
        case 1: { //                       //# 01: continued
          { //                             //# 01: continued
            nop(x); //                     //# 01: continued
            break;  // Break switch. //    //# 01: continued
          } //                             //# 01: continued
        } //                               //# 01: continued
        case 2: { //                       //# 02: static type warning
          { //                             //# 02: continued
            nop(x); //                     //# 02: continued
            break LOOP; //                 //# 02: continued
          } //                             //# 02: continued
        } //                               //# 02: continued
        case 3: { //                       //# 03: static type warning
          { //                             //# 03: continued
            nop(x); //                     //# 03: continued
            continue; // Continue loop.    //# 03: continued
          } //                             //# 03: continued
        } //                               //# 03: continued
        case 4: { //                       //# 04: static type warning
          { //                             //# 04: continued
            nop(x); //                     //# 04: continued
            continue LOOP; //              //# 04: continued
          } //                             //# 04: continued
        } //                               //# 04: continued
        case 5: { //                       //# 05: static type warning
          { //                             //# 05: continued
            nop(x); //                     //# 05: continued
            continue LAST; //              //# 05: continued
          } //                             //# 05: continued
        } //                               //# 05: continued
        case 6: { //                       //# 06: static type warning
          { //                             //# 06: continued
            nop(x); //                     //# 06: continued
            return; //                     //# 06: continued
          } //                             //# 06: continued
        } //                               //# 06: continued
        case 7: { //                       //# 07: static type warning
          { //                             //# 07: continued
            nop(x); //                     //# 07: continued
            return x; //                   //# 07: continued
          } //                             //# 07: continued
        } //                               //# 07: continued
        case 8: { //                       //# 08: static type warning
          { //                             //# 08: continued
            nop(x); //                     //# 08: continued
            throw x; //                    //# 08: continued
          } //                             //# 08: continued
        } //                               //# 08: continued
        case 9: { //                       //# 09: static type warning
          { //                             //# 09: continued
            nop(x); //                     //# 09: continued
            rethrow; //                    //# 09: continued
          } //                             //# 09: continued
        } //                               //# 09: continued
        case 10: //                        //# 10: static type warning
          while (true) break; //           //# 10: continued
        case 11: //                        //# 11: static type warning
          do break; while (true); //       //# 11: continued
        case 12: //                        //# 12: static type warning
          for (;;) break; //               //# 12: continued
        case 13: //                        //# 13: static type warning
          for (var _ in []) break; //      //# 13: continued
        case 14: //                        //# 14: static type warning
          if (x) break; else break; //     //# 14: continued
        case 15: //                        //# 15: static type warning
          (throw 0); //                    //# 15: continued
        case 16: //                        //# 16: static type warning
          nop(x); //      fallthrough. //  //# 16: continued
        case 17: //                        //# 17: static type warning
          L: break; //                     //# 17: continued
        LAST:
        case 99:
        // Last case can't cause static warning.
      }
    } while (false);
  } finally {
    // Catch all control flow leaving the switch and ignore it.
    // Use break instead of return to avoid warning for `return` and `return e`
    // in same function.
    break TRY;
  }
}

main() {
  // Ensure that all the cases compile and run (even if they might throw).
  for (int i = 0; i <= 20; i++) {
    testSwitch(i); // Just make sure it runs.
  }
  for (int i = 0; i <= 18; i++) {
    testSwitchWarn(i);
  }
}

/// Don't make it obvious that a switch case isn't doing anything.
void nop(x) {}