Handle break as continue

pkg/compiler/lib/src/kernel/kernel_backend_strategy.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.kernel.backend_strategy;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../backend_strategy.dart';
 import '../closure.dart';
@@ skipping 262 matching lines @@
 
   KernelToLocalsMap getLocalsMap(MemberEntity member) {
     return _localsMaps.putIfAbsent(
         member, () => new KernelToLocalsMapImpl(member));
   }
 }
 
 class KernelToLocalsMapImpl implements KernelToLocalsMap {
   final List<MemberEntity> _members = <MemberEntity>[];
   Map<ir.VariableDeclaration, KLocal> _map = <ir.VariableDeclaration, KLocal>{};
-  Map<ir.LabeledStatement, KJumpTarget> _jumpTargetMap;
+  Map<ir.TreeNode, KJumpTarget> _jumpTargetMap;
+  Set<ir.BreakStatement> _breaksAsContinue;
 
   MemberEntity get currentMember => _members.last;
 
   // TODO(johnniwinther): Compute this eagerly from the root of the member.
   void _ensureJumpMap(ir.TreeNode node) {
     if (_jumpTargetMap == null) {
       JumpVisitor visitor = new JumpVisitor(currentMember);
 
       // Find the root node for the current member.
       while (node is! ir.Member) {
         node = node.parent;
       }
 
       node.accept(visitor);
       _jumpTargetMap = visitor.jumpTargetMap;
+      _breaksAsContinue = visitor.breaksAsContinue;
     }
   }
 
   KernelToLocalsMapImpl(MemberEntity member) {
     _members.add(member);
   }
 
   @override
   void enterInlinedMember(MemberEntity member) {
     _members.add(member);
   }
 
   @override
   void leaveInlinedMember(MemberEntity member) {
     assert(member == currentMember);
     _members.removeLast();
   }
 
   @override
   JumpTarget getJumpTargetForBreak(ir.BreakStatement node) {
     _ensureJumpMap(node.target);
-    JumpTarget target = _jumpTargetMap[node.target];
+    JumpTarget target = _jumpTargetMap[node];
     assert(target != null, failedAt(currentMember, 'No target for $node.'));
     return target;
   }
 
   @override
+  bool generateContinueForBreak(ir.BreakStatement node) {
+    return _breaksAsContinue.contains(node);
+  }
+
+  @override
   JumpTarget getJumpTargetForContinueSwitch(ir.ContinueSwitchStatement node) {
     _ensureJumpMap(node.target);
     throw new UnimplementedError(
         'KernelToLocalsMapImpl.getJumpTargetForContinueSwitch');
   }
 
   @override
   JumpTarget getJumpTargetForSwitchCase(ir.SwitchCase node) {
     _ensureJumpMap(node);
     throw new UnimplementedError(
         'KernelToLocalsMapImpl.getJumpTargetForSwitchCase');
   }
 
   @override
   JumpTarget getJumpTargetForDo(ir.DoStatement node) {
     _ensureJumpMap(node);
     return _jumpTargetMap[node.parent];
   }
 
   @override
   JumpTarget getJumpTargetForLabel(ir.LabeledStatement node) {
     _ensureJumpMap(node);
-    JumpTarget target = _jumpTargetMap[node];
-    assert(target != null, failedAt(currentMember, 'No target for $node.'));
-    return target;
+    return _jumpTargetMap[node];
   }
 
   @override
   JumpTarget getJumpTargetForSwitch(ir.SwitchStatement node) {
     _ensureJumpMap(node);
     throw new UnimplementedError(
         'KernelToLocalsMapImpl.getJumpTargetForSwitch');
   }
 
   @override
   JumpTarget getJumpTargetForFor(ir.ForStatement node) {
     _ensureJumpMap(node);
-    return _jumpTargetMap[node.parent];
+    return _jumpTargetMap[node];
   }
 
   @override
   JumpTarget getJumpTargetForForIn(ir.ForInStatement node) {
     _ensureJumpMap(node);
     return _jumpTargetMap[node.parent];
   }
 
   @override
   JumpTarget getJumpTargetForWhile(ir.WhileStatement node) {
     _ensureJumpMap(node);
     return _jumpTargetMap[node.parent];
   }
 
   @override
   Local getLocal(ir.VariableDeclaration node) {
     return _map.putIfAbsent(node, () {
       return new KLocal(node.name, currentMember);
     });
   }
 
   @override
   LoopClosureRepresentationInfo getClosureRepresentationInfoForLoop(
       ClosureDataLookup closureLookup, ir.TreeNode node) {
     return closureLookup.getClosureRepresentationInfoForLoop(node);
   }
 }
 
 class JumpVisitor extends ir.Visitor {
+  int index = 0;
   final MemberEntity member;
-  final Map<ir.LabeledStatement, KJumpTarget> jumpTargetMap =
-      <ir.LabeledStatement, KJumpTarget>{};
+  final Map<ir.TreeNode, KJumpTarget> jumpTargetMap =
+      <ir.TreeNode, KJumpTarget>{};
+  final Set<ir.BreakStatement> breaksAsContinue = new Set<ir.BreakStatement>();
 
   JumpVisitor(this.member);
 
-  KJumpTarget _getJumpTarget(ir.LabeledStatement node) {
+  KJumpTarget _getJumpTarget(ir.TreeNode node) {
     return jumpTargetMap.putIfAbsent(node, () {
-      return new KJumpTarget(member, jumpTargetMap.length);
+      return new KJumpTarget(member, index++);
     });
   }
 
   @override
   defaultNode(ir.Node node) => node.visitChildren(this);
 
+  bool _canBeBreakTarget(ir.TreeNode node) {
+    // TODO(johnniwinther): Add more.
+    return node is ir.ForStatement;
+  }
+
+  bool _canBeContinueTarget(ir.TreeNode node) {
+    // TODO(johnniwinther): Add more.
+    return node is ir.ForStatement;
+  }
+
   @override
   visitBreakStatement(ir.BreakStatement node) {
-    KJumpTarget target = _getJumpTarget(node.target);
-    target.isBreakTarget = true;
+    // TODO(johnniwinther): Add labels if the enclosing loop is not the implicit
+    // break target.
+    KJumpTarget target;
+    ir.TreeNode body = node.target.body;
+    ir.TreeNode parent = node.target.parent;
+    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;
+    } 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 KJumpTarget extends JumpTarget<ir.Node> {
   final MemberEntity memberContext;
   final int nestingLevel;
 
   KJumpTarget(this.memberContext, this.nestingLevel);
 
@@ skipping 12 matching lines @@
 
   @override
   List<LabelDefinition<ir.Node>> get labels {
     return const <LabelDefinition<ir.Node>>[];
   }
 
   @override
   ir.Node get statement {
     throw new UnimplementedError('KJumpTarget.statement');
   }
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.write('KJumpTarget[');
+    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(']');
+    return sb.toString();
+  }
 }
 
 class KLocal implements Local {
   final String name;
   final MemberEntity memberContext;
 
   KLocal(this.name, this.memberContext);
 
   @override
   Entity get executableContext => memberContext;
@@ skipping 53 matching lines @@
   Iterable<ClassEntity> sortClasses(Iterable<ClassEntity> classes) {
     return classes.toList()
       ..sort((ClassEntity a, ClassEntity b) {
         int r = _compareLibraries(a.library, b.library);
         if (r != 0) return r;
         return _compareNodes(
             a, elementMap.getClassNode(a), b, elementMap.getClassNode(b));
       });
   }
 }