Fix labeled break statements.

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
@@ skipping 359 matching lines @@
     if (member is ir.Field) {
       FieldElement field = _nodeToElement[member];
       return field.constant == null;
     }
     return false;
   }
 
   LibraryElement get jsHelperLibrary => _backend.helpers.jsHelperLibrary;
 
   KernelJumpTarget getJumpTarget(ir.TreeNode node,
-          {bool isContinueTarget: false}) =>
-      _jumpTargets.putIfAbsent(node, () {
-        if (node is ir.LabeledStatement &&
-            _jumpTargets.containsKey((node as ir.LabeledStatement).body)) {
-          return _jumpTargets[(node as ir.LabeledStatement).body];
-        }
-        return new KernelJumpTarget(node, makeContinueLabel: isContinueTarget);
-      });
-
-  LabelDefinition getTargetLabel(ir.Node node) =>
-      elements.getTargetLabel(getNode(node));
+      {bool isContinueTarget: false}) {
+    return _jumpTargets.putIfAbsent(node, () {
+      if (node is ir.LabeledStatement &&
+          _jumpTargets.containsKey((node as ir.LabeledStatement).body)) {
+        return _jumpTargets[(node as ir.LabeledStatement).body];
+      }
+      return new KernelJumpTarget(node, this,
+          makeContinueLabel: isContinueTarget);
+    });
+  }
 
   ir.Class get mapLiteralClass =>
       kernel.classes[_backend.helpers.mapLiteralClass];
 
   ir.Procedure get mapLiteralConstructor =>
       kernel.functions[_backend.helpers.mapLiteralConstructor];
 
   ir.Procedure get mapLiteralConstructorEmpty =>
       kernel.functions[_backend.helpers.mapLiteralConstructorEmpty];
 
@@ skipping 598 matching lines @@
   /// If this jump target was not initially constructed with a LabeledStatement,
   /// this value is identical to targetStatement.
   ir.Node originalStatement;
 
   @override
   bool isBreakTarget = false;
 
   @override
   bool isContinueTarget = false;
 
-  KernelJumpTarget(this.targetStatement, {bool makeContinueLabel = false}) {
-    labels = <LabelDefinition>[];
+  KernelJumpTarget(this.targetStatement, KernelAstAdapter adapter,
+      {bool makeContinueLabel = false}) {
     originalStatement = targetStatement;
-    if (targetStatement is ir.LabeledStatement) {
+    this.labels = <LabelDefinition>[];
+    if (targetStatement is ir.WhileStatement ||
+        targetStatement is ir.DoStatement ||
+        targetStatement is ir.ForStatement ||
+        targetStatement is ir.ForInStatement) {
+      // Currently these labels are set at resolution on the element itself.
+      // Once that gets updated, this logic can change downstream.
+      JumpTarget target = adapter.elements
+          .getTargetDefinition(adapter.getNode(targetStatement));
+      if (target != null) {
+        labels.addAll(target.labels);
+        isBreakTarget = target.isBreakTarget;
+        isContinueTarget = target.isContinueTarget;
+      }
+    } else if (targetStatement is ir.LabeledStatement) {
       targetStatement = (targetStatement as ir.LabeledStatement).body;
       labels.add(
           new LabelDefinitionX(null, 'L${index++}', this)..setBreakTarget());
       isBreakTarget = true;
-    } else if (makeContinueLabel) {
+    }
+
+    if (makeContinueLabel) {
       labels.add(
           new LabelDefinitionX(null, 'L${index++}', this)..setContinueTarget());
       isContinueTarget = true;
     }
   }
 
   @override
   LabelDefinition addLabel(ast.Label label, String labelName) {
     LabelDefinition result = new LabelDefinitionX(label, labelName, this);
     labels.add(result);
@@ skipping 45 matching lines @@
       JumpTarget continueTarget =
           astAdapter.getJumpTarget(switchCase, isContinueTarget: true);
       assert(continueTarget is KernelJumpTarget);
       targetIndexMap[continueTarget] = switchIndex;
       assert(builder.jumpTargets[continueTarget] == null);
       builder.jumpTargets[continueTarget] = this;
       switchIndex++;
     }
   }
 }