Handle labelled breaks

pkg/compiler/lib/src/js_model/locals.dart

 // Copyright (c) 2017, 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.
 
 library dart2js.js_model.locals;
 
 import 'package:kernel/ast.dart' as ir;
 
 import 'closure.dart' show JClosureClass;
 import '../closure.dart';
@@ skipping 153 matching lines @@
   }
 
   @override
   CapturedLoopScope getCapturedLoopScope(
       ClosureDataLookup closureLookup, ir.TreeNode node) {
     return closureLookup.getCapturedLoopScope(node);
   }
 }
 
 class JumpVisitor extends ir.Visitor {
-  int index = 0;
+  int jumpIndex = 0;
+  int labelIndex = 0;
   final MemberEntity member;
   final Map<ir.TreeNode, JJumpTarget> jumpTargetMap =
       <ir.TreeNode, JJumpTarget>{};
   final Set<ir.BreakStatement> breaksAsContinue = new Set<ir.BreakStatement>();
 
   JumpVisitor(this.member);
 
   JJumpTarget _getJumpTarget(ir.TreeNode node) {
     return jumpTargetMap.putIfAbsent(node, () {
-      return new JJumpTarget(member, index++);
+      return new JJumpTarget(member, jumpIndex++);
     });
   }
 
   @override
   defaultNode(ir.Node node) => node.visitChildren(this);
 
   bool _canBeBreakTarget(ir.TreeNode node) {
     return node is ir.ForStatement ||
         node is ir.ForInStatement ||
         node is ir.WhileStatement ||
@@ skipping 19 matching lines @@
     if (_canBeBreakTarget(body)) {
       // We have code like
       //
       //     l1: for (int i = 0; i < 10; i++) {
       //        break l1:
       //     }
       //
       // and can therefore use the for loop as the break target.
       target = _getJumpTarget(body);
       target.isBreakTarget = true;
+      ir.TreeNode search = node;
+      bool needsLabel = false;
+      while (search != node.target) {
+        if (_canBeBreakTarget(search)) {
+          needsLabel = search != body;
+          break;
+        }
+        search = search.parent;
+      }
+      if (needsLabel) {
+        target.addLabel(node.target, 'label${labelIndex++}',
+            isBreakTarget: true);
+      }
     } else if (_canBeContinueTarget(parent)) {
       // We have code like
       //
       //     for (int i = 0; i < 10; i++) l1: {
       //        break l1:
       //     }
       //
       // and can therefore use the for loop as a continue target.
       target = _getJumpTarget(parent);
       target.isContinueTarget = true;
       breaksAsContinue.add(node);
     } else {
       target = _getJumpTarget(node.target);
       target.isBreakTarget = true;
     }
     jumpTargetMap[node] = target;
     super.visitBreakStatement(node);
   }
 }
 
 class JJumpTarget extends JumpTarget<ir.Node> {
   final MemberEntity memberContext;
   final int nestingLevel;
+  List<LabelDefinition<ir.Node>> _labels;
 
   JJumpTarget(this.memberContext, this.nestingLevel);
 
   bool isBreakTarget = false;
   bool isContinueTarget = false;
   bool isSwitch = false;
 
   @override
   Entity get executableContext => memberContext;
 
   @override
   LabelDefinition<ir.Node> addLabel(ir.Node label, String labelName,
       {bool isBreakTarget: false}) {
-    throw new UnimplementedError('KJumpTarget.addLabel');
+    _labels ??= <LabelDefinition<ir.Node>>[];
+    LabelDefinition<ir.Node> labelDefinition = new JLabelDefinition(
+        this, label, labelName,
+        isBreakTarget: isBreakTarget);
+    _labels.add(labelDefinition);
+    return labelDefinition;
   }
 
   @override
   List<LabelDefinition<ir.Node>> get labels {
-    return const <LabelDefinition<ir.Node>>[];
+    return _labels ?? const <LabelDefinition<ir.Node>>[];
   }
 
   @override
   ir.Node get statement {
-    throw new UnimplementedError('KJumpTarget.statement');
+    throw new UnimplementedError('JJumpTarget.statement');
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
-    sb.write('KJumpTarget[');
+    sb.write('JJumpTarget(');
     sb.write('memberContext=');
     sb.write(memberContext);
     sb.write(',nestingLevel=');
     sb.write(nestingLevel);
     sb.write(',isBreakTarget=');
     sb.write(isBreakTarget);
     sb.write(',isContinueTarget=');
     sb.write(isContinueTarget);
-    sb.write(']');
+    if (_labels != null) {
+      sb.write(',labels=');
+      sb.write(_labels);
+    }
+    sb.write(')');
     return sb.toString();
   }
 }
+
+class JLabelDefinition extends LabelDefinition<ir.Node> {
+  final JumpTarget<ir.Node> target;
+  final ir.Node label;
+  final String labelName;
+  final bool isBreakTarget;
+  final bool isContinueTarget;
+
+  JLabelDefinition(this.target, this.label, this.labelName,
+      {this.isBreakTarget: false, this.isContinueTarget: false});
+
+  @override
+  String get name => labelName;
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.write('JLabelDefinition(');
+    sb.write('label=');
+    sb.write(label);
+    sb.write(',labelName=');
+    sb.write(labelName);
+    sb.write(',isBreakTarget=');
+    sb.write(isBreakTarget);
+    sb.write(',isContinueTarget=');
+    sb.write(isContinueTarget);
+    sb.write(')');
+    return sb.toString();
+  }
+}
 
 class JLocal implements Local {
   final String name;
   final MemberEntity memberContext;
 
   /// True if this local represents a local parameter.
   final bool isRegularParameter;
 
   JLocal(this.name, this.memberContext, [isParameter = false])
       : isRegularParameter = isParameter;
 
   @override
   Entity get executableContext => memberContext;
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('local(');
     if (memberContext.enclosingClass != null) {
       sb.write(memberContext.enclosingClass.name);
       sb.write('.');
     }
     sb.write(memberContext.name);
     sb.write('#');
     sb.write(name);
     sb.write(')');
     return sb.toString();
   }
 }