implement LabeledStatement and Break in kernel

pkg/compiler/lib/src/ssa/builder_kernel.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 'package:kernel/text/ast_to_text.dart' show debugNodeToString;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart';
 import '../constants/values.dart'
     show
         ConstantValue,
         InterceptorConstantValue,
         StringConstantValue,
         TypeConstantValue;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
 import '../native/native.dart' as native;
 import '../resolution/tree_elements.dart';
 import '../tree/dartstring.dart';
-import '../tree/nodes.dart' show FunctionExpression, Node;
+import '../tree/nodes.dart' show Node, BreakStatement;
 import '../types/masks.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart';
-import '../universe/use.dart' show StaticUse, TypeUse;
 import '../universe/side_effects.dart' show SideEffects;
-import '../world.dart' show ClosedWorld;
+import '../universe/use.dart' show StaticUse;
+import '../world.dart';
 import 'graph_builder.dart';
+import 'jump_handler.dart';
 import 'kernel_ast_adapter.dart';
 import 'kernel_string_builder.dart';
 import 'locals_handler.dart';
 import 'loop_handler.dart';
 import 'nodes.dart';
 import 'ssa_branch_builder.dart';
 import 'type_builder.dart';
 import 'types.dart' show TypeMaskFactory;
 
 class SsaKernelBuilderTask extends CompilerTask {
@@ skipping 774 matching lines @@
       assertStatement.message.accept(this);
       _pushStaticInvocation(astAdapter.assertThrow, <HInstruction>[pop()],
           astAdapter.assertThrowReturnType);
       pop();
     }
 
     handleIf(visitCondition: buildCondition, visitThen: fail);
   }
 
   @override
+  void visitBreakStatement(ir.BreakStatement breakStatement) {
+    assert(!isAborted());
+    JumpTarget target = astAdapter.getJumpTarget(breakStatement.target);
+    assert(target != null);
+    JumpHandler handler = jumpTargets[target];
+    assert(handler != null);
+    handler.generateBreak(handler.labels.first);
+  }
+
+  @override
+  void visitLabeledStatement(ir.LabeledStatement labeledStatement) {
+    JumpTarget target = astAdapter.getJumpTarget(labeledStatement);
+    JumpHandler handler = new JumpHandler(this, target);
+
+    ir.Statement body = labeledStatement.body;
+    if (body is ir.WhileStatement ||
+        body is ir.DoStatement ||
+        body is ir.ForStatement ||
+        body is ir.ForInStatement) {
+      // loops handle breaks on their own
+      body.accept(this);
+      return;
+    }
+    LocalsHandler beforeLocals = new LocalsHandler.from(localsHandler);
+
+    HBasicBlock newBlock = openNewBlock();
+    body.accept(this);
+    SubGraph bodyGraph = new SubGraph(newBlock, lastOpenedBlock);
+
+    HBasicBlock joinBlock = graph.addNewBlock();
+    List<LocalsHandler> breakHandlers = <LocalsHandler>[];
+    handler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
+      breakInstruction.block.addSuccessor(joinBlock);
+      breakHandlers.add(locals);
+    });
+
+    if (!isAborted()) {
+      goto(current, joinBlock);
+      breakHandlers.add(localsHandler);
+    }
+
+    open(joinBlock);
+    localsHandler = beforeLocals.mergeMultiple(breakHandlers, joinBlock);
+
+    // There was at least one reachable break, so the label is needed.
+    newBlock.setBlockFlow(
+        new HLabeledBlockInformation(
+            new HSubGraphBlockInformation(bodyGraph), handler.labels),
+        joinBlock);
+    handler.close();
+  }
+
+  @override
   void visitConditionalExpression(ir.ConditionalExpression conditional) {
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler);
     brancher.handleConditional(
         () => conditional.condition.accept(this),
         () => conditional.then.accept(this),
         () => conditional.otherwise.accept(this));
   }
 
   @override
   void visitLogicalExpression(ir.LogicalExpression logicalExpression) {
@@ skipping 1370 matching lines @@
     kernelBuilder.open(exitBlock);
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
   }
 }