Implement continue for switch.

sdk/lib/_internal/compiler/implementation/ssa/codegen.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 760 matching lines @@
     HExpressionInformation condition = info.condition;
     bool isConditionExpression = isJSCondition(condition);
 
     js.Loop loop;
 
     switch (info.kind) {
       // Treate all three "test-first" loops the same way.
       case HLoopBlockInformation.FOR_LOOP:
       case HLoopBlockInformation.WHILE_LOOP:
       case HLoopBlockInformation.FOR_IN_LOOP:
+      case HLoopBlockInformation.SWITCH_CONTINUE_LOOP:
         HBlockInformation initialization = info.initializer;
         int initializationType = TYPE_STATEMENT;
         if (initialization != null) {
           initializationType = expressionType(initialization);
           if (initializationType == TYPE_STATEMENT) {
             generateStatements(initialization);
             initialization = null;
           }
         }
         if (isConditionExpression &&
@@ skipping 132 matching lines @@
         }
         loop = new js.Do(unwrapStatement(body), jsCondition);
         currentContainer = oldContainer;
         break;
       default:
         compiler.internalError(
           'Unexpected loop kind: ${info.kind}',
           instruction: condition.conditionExpression);
     }
     attachLocationRange(loop, info.sourcePosition, info.endSourcePosition);
-    pushStatement(wrapIntoLabels(loop, info.labels));
+    js.Statement result = loop;
+    if (info.kind == HLoopBlockInformation.SWITCH_CONTINUE_LOOP) {
+      String continueLabelString =
+          backend.namer.implicitContinueLabelName(info.target);
+      result = new js.LabeledStatement(continueLabelString, result);
+    }
+    pushStatement(wrapIntoLabels(result, info.labels));
     return true;
   }
 
   bool visitLabeledBlockInfo(HLabeledBlockInformation labeledBlockInfo) {
     preLabeledBlock(labeledBlockInfo);
     Link<Element> continueOverrides = const Link<Element>();
 
     js.Block oldContainer = currentContainer;
     js.Block body = new js.Block.empty();
     js.Statement result = body;
@@ skipping 21 matching lines @@
       result = new js.LabeledStatement(labelName, result);
       continueAction[target] = implicitContinueAsBreak;
       continueOverrides = continueOverrides.prepend(target);
     } else {
       for (LabelElement label in labeledBlockInfo.labels) {
         if (label.isBreakTarget) {
           String labelName = backend.namer.breakLabelName(label);
           result = new js.LabeledStatement(labelName, result);
         }
       }
-      TargetElement target = labeledBlockInfo.target;
-      if (target.isSwitch) {
-        // This is an extra block around a switch that is generated
-        // as a nested if/else chain. We add an extra break target
-        // so that case code can break.
-        String labelName = backend.namer.implicitBreakLabelName(target);
-        result = new js.LabeledStatement(labelName, result);
-        breakAction[target] = implicitBreakWithLabel;
-      }
+    }
+    TargetElement target = labeledBlockInfo.target;
+    if (target.isSwitch) {
+      // This is an extra block around a switch that is generated
+      // as a nested if/else chain. We add an extra break target
+      // so that case code can break.
+      String labelName = backend.namer.implicitBreakLabelName(target);
+      result = new js.LabeledStatement(labelName, result);
+      breakAction[target] = implicitBreakWithLabel;
     }
 
     currentContainer = body;
     startLabeledBlock(labeledBlockInfo);
     generateStatements(labeledBlockInfo.body);
     endLabeledBlock(labeledBlockInfo);
 
     if (labeledBlockInfo.isContinue) {
       while (!continueOverrides.isEmpty) {
         continueAction.remove(continueOverrides.head);
@@ skipping 335 matching lines @@
   visitBreak(HBreak node) {
     assert(node.block.successors.length == 1);
     if (node.label != null) {
       LabelElement label = node.label;
       if (!tryCallAction(breakAction, label)) {
         pushStatement(new js.Break(backend.namer.breakLabelName(label)), node);
       }
     } else {
       TargetElement target = node.target;
       if (!tryCallAction(breakAction, target)) {
-        pushStatement(new js.Break(null), node);
+        if (node.breakSwitchContinueLoop) {
+          pushStatement(new js.Break(
+              backend.namer.implicitContinueLabelName(target)), node);
+        } else {
+          pushStatement(new js.Break(null), node);
+        }
       }
     }
   }
 
   visitContinue(HContinue node) {
     assert(node.block.successors.length == 1);
     if (node.label != null) {
       LabelElement label = node.label;
       if (!tryCallAction(continueAction, label)) {
         // TODO(floitsch): should this really be the breakLabelName?
         pushStatement(new js.Continue(backend.namer.breakLabelName(label)),
                       node);
       }
     } else {
       TargetElement target = node.target;
       if (!tryCallAction(continueAction, target)) {
-        pushStatement(new js.Continue(null), node);
+        if (target.statement is SwitchStatement) {
+          pushStatement(new js.Continue(
+              backend.namer.implicitContinueLabelName(target)), node);
+        } else {
+          pushStatement(new js.Continue(null), node);
+        }
       }
     }
   }
 
   visitExitTry(HExitTry node) {
     // An [HExitTry] is used to represent the control flow graph of a
     // try/catch block, ie the try body is always a predecessor
     // of the catch and finally. Here, we continue visiting the try
     // body by visiting the block that contains the user-level control
     // flow instruction.
@@ skipping 1607 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }