implement LabeledStatement and Break in kernel

pkg/compiler/lib/src/ssa/loop_handler.dart

Index: pkg/compiler/lib/src/ssa/loop_handler.dart
diff --git a/pkg/compiler/lib/src/ssa/loop_handler.dart b/pkg/compiler/lib/src/ssa/loop_handler.dart
index e897820562d5be5c3631c76020dece051a5e7fca..7edcfebf088ef0769b1b108372865c5727f5a16e 100644
--- a/pkg/compiler/lib/src/ssa/loop_handler.dart
+++ b/pkg/compiler/lib/src/ssa/loop_handler.dart
@@ -106,12 +106,12 @@ abstract class LoopHandler<T> {
       builder.localsHandler =
           continueHandlers[0].mergeMultiple(continueHandlers, updateBlock);
 
-      List<LabelDefinition> labels = jumpHandler.labels();
+      List<LabelDefinition> labels = jumpHandler.labels;
       JumpTarget target = getTargetDefinition(loop);
-      if (!labels.isEmpty) {
+      if (labels.isNotEmpty) {
         beginBodyBlock.setBlockFlow(
             new HLabeledBlockInformation(
-                new HSubGraphBlockInformation(bodyGraph), jumpHandler.labels(),
+                new HSubGraphBlockInformation(bodyGraph), jumpHandler.labels,
                 isContinue: true),
             updateBlock);
       } else if (target != null && target.isContinueTarget) {
@@ -222,7 +222,7 @@ abstract class LoopHandler<T> {
 
     JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: true);
     HBasicBlock loopEntry = builder.graph
-        .addNewLoopHeaderBlock(jumpHandler.target, jumpHandler.labels());
+        .addNewLoopHeaderBlock(jumpHandler.target, jumpHandler.labels);
     previousBlock.addSuccessor(loopEntry);
     builder.open(loopEntry);
 
@@ -350,7 +350,7 @@ class _SsaLoopTypeVisitor extends ast.Visitor {
 
 // TODO(het): Since kernel simplifies loop breaks and continues, we should
 // rewrite the loop handler from scratch to account for the simplified structure
-class KernelLoopHandler extends LoopHandler<ir.Node> {
+class KernelLoopHandler extends LoopHandler<ir.TreeNode> {
   final KernelSsaBuilder builder;
 
   KernelAstAdapter get astAdapter => builder.astAdapter;
@@ -360,33 +360,35 @@ class KernelLoopHandler extends LoopHandler<ir.Node> {
         super(builder);
 
   @override
-  JumpHandler createJumpHandler(ir.Node node, {bool isLoopJump}) {
-    JumpTarget element = getTargetDefinition(node);
-    if (element == null || !identical(element.statement, node)) {
+  JumpHandler createJumpHandler(ir.TreeNode node, {bool isLoopJump}) {
+    if (node.parent is! ir.LabeledStatement) {
       // No breaks or continues to this node.
       return new NullJumpHandler(builder.compiler.reporter);
     }
-    if (isLoopJump && node is ast.SwitchStatement) {
-      // Create a special jump handler for loops created for switch statements
-      // with continue statements.
-      return new SwitchCaseJumpHandler(builder, element, getNode(node));
-    }
-    return new JumpHandler(builder, element);
+    // We must have already created a JumpHandler for the labeled statement
+    JumpHandler result =
+        builder.jumpTargets[astAdapter.getJumpTarget(node.parent)];
+    assert(result != null);
+    return result;
   }
 
   @override
-  ast.Node getNode(ir.Node node) => astAdapter.getNode(node);
+  ast.Node getNode(ir.TreeNode node) => astAdapter.getNode(node);
 
   @override
-  JumpTarget getTargetDefinition(ir.Node node) =>
-      astAdapter.getTargetDefinition(node);
+  JumpTarget getTargetDefinition(ir.TreeNode node) {
+    if (node.parent is ir.LabeledStatement) {
+      return astAdapter.getJumpTarget(node.parent);
+    }
+    return null;
+  }
 
   @override
-  int loopKind(ir.Node node) => node.accept(new _KernelLoopTypeVisitor());
+  int loopKind(ir.TreeNode node) => node.accept(new _KernelLoopTypeVisitor());
 
   // TODO(het): return the actual source information
   @override
-  SourceInformation loopSourceInformation(ir.Node node) => null;
+  SourceInformation loopSourceInformation(ir.TreeNode node) => null;
 }
 
 class _KernelLoopTypeVisitor extends ir.Visitor<int> {