Handle break as continue

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 '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../common/names.dart';
@@ skipping 883 matching lines @@
         // The result of the update instruction isn't used, and can just
         // be dropped.
         pop();
       }
     }
 
     void buildBody() {
       forStatement.body.accept(this);
     }
 
+    JumpTarget jumpTarget = localsMap.getJumpTargetForFor(forStatement);
     loopHandler.handleLoop(
         forStatement,
         localsMap.getClosureRepresentationInfoForLoop(
             closureDataLookup, forStatement),
-        localsMap.getJumpTargetForFor(forStatement),
+        jumpTarget,
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   @override
   void visitForInStatement(ir.ForInStatement forInStatement) {
     if (forInStatement.isAsync) {
       _buildAsyncForIn(forInStatement);
@@ skipping 540 matching lines @@
   }
 
   @override
   void visitBreakStatement(ir.BreakStatement breakStatement) {
     assert(!isAborted());
     handleInTryStatement();
     JumpTarget target = localsMap.getJumpTargetForBreak(breakStatement);
     assert(target != null);
     JumpHandler handler = jumpTargets[target];
     assert(handler != null);
-    if (handler.labels.isNotEmpty) {
-      handler.generateBreak(handler.labels.first);
+    if (localsMap.generateContinueForBreak(breakStatement)) {
+      if (handler.labels.isNotEmpty) {
+        handler.generateContinue(handler.labels.first);
+      } else {
+        handler.generateContinue();
+      }
     } else {
-      handler.generateBreak();
+      if (handler.labels.isNotEmpty) {
+        handler.generateBreak(handler.labels.first);
+      } else {
+        handler.generateBreak();
+      }
     }
   }
 
   @override
   void visitLabeledStatement(ir.LabeledStatement labeledStatement) {
     ir.Statement body = labeledStatement.body;
     if (body is ir.WhileStatement ||
         body is ir.DoStatement ||
         body is ir.ForStatement ||
         body is ir.ForInStatement ||
         body is ir.SwitchStatement) {
       // loops and switches handle breaks on their own
       body.accept(this);
       return;
     }
-    JumpHandler handler = createJumpHandler(
-        labeledStatement, localsMap.getJumpTargetForLabel(labeledStatement));
+    JumpTarget jumpTarget = localsMap.getJumpTargetForLabel(labeledStatement);
+    if (jumpTarget == null) {
+      // The label is not needed.
+      body.accept(this);
+      return;
+    }
+
+    JumpHandler handler = createJumpHandler(labeledStatement, jumpTarget);
 
     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) {
@@ skipping 1968 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }