implement LabeledStatement and Break in kernel

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

 // 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../tree/tree.dart' as ast;
 
@@ skipping 88 matching lines @@
 
       if (bodyBlock != null) {
         continueHandlers.add(builder.localsHandler);
         bodyBlock.addSuccessor(updateBlock);
       }
 
       builder.open(updateBlock);
       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) {
         beginBodyBlock.setBlockFlow(
             new HLabeledBlockInformation.implicit(
                 new HSubGraphBlockInformation(bodyGraph), target,
                 isContinue: true),
             updateBlock);
       }
 
@@ skipping 90 matching lines @@
 
   /// Creates a new loop-header block. The previous [current] block
   /// is closed with an [HGoto] and replaced by the newly created block.
   /// Also notifies the locals handler that we're entering a loop.
   JumpHandler beginLoopHeader(T node) {
     assert(!builder.isAborted());
     HBasicBlock previousBlock = builder.close(new HGoto());
 
     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);
 
     builder.localsHandler.beginLoopHeader(loopEntry);
     return jumpHandler;
   }
 
   /// Ends the loop.
   ///
   /// It does this by:
@@ skipping 107 matching lines @@
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }
 
 // 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;
 
   KernelLoopHandler(KernelSsaBuilder builder)
       : this.builder = builder,
         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> {
   @override
   int defaultNode(ir.Node node) => HLoopBlockInformation.NOT_A_LOOP;
 
   @override
   int visitWhileStatement(ir.WhileStatement node) =>
       HLoopBlockInformation.WHILE_LOOP;
 
   @override
   int visitForStatement(ir.ForStatement node) => HLoopBlockInformation.FOR_LOOP;
 
   @override
   int visitDoStatement(ir.DoStatement node) =>
       HLoopBlockInformation.DO_WHILE_LOOP;
 
   @override
   int visitForInStatement(ir.ForInStatement node) =>
       HLoopBlockInformation.FOR_IN_LOOP;
 
   @override
   int visitSwitchStatement(ir.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }