Handle for-loop with simple break in compile_from_dill_test

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';
+import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/tasks.dart';
 import '../compiler.dart';
 import '../elements/entities.dart';
 import '../elements/entity_utils.dart' as utils;
 import '../elements/jumps.dart';
 import '../enqueue.dart';
 import '../io/source_information.dart';
 import '../js/js_source_mapping.dart';
 import '../js_backend/backend.dart';
@@ skipping 251 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;
 
   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.

[Siggi Cherem (dart-lang), 2017/06/23 19:34:00]

I know this will go away when you do it eagerly, but any reason why not fetch
the root node from `currentMember` (I guess that will require having access to
that global member-ir map here)?

[Johnni Winther, 2017/06/26 09:04:18]

Your guess is right.

+      while (node is! ir.Member) {
+        node = node.parent;
+      }
+
+      node.accept(visitor);
+      _jumpTargetMap = visitor.jumpTargetMap;
+    }
+  }
+
   KernelToLocalsMapImpl(MemberEntity member) {
     _members.add(member);
   }
 
   @override
   void enterInlinedMember(MemberEntity member) {
     _members.add(member);
   }
 
   @override
   void leaveInlinedMember(MemberEntity member) {
     assert(member == currentMember);
     _members.removeLast();

[Siggi Cherem (dart-lang), 2017/06/23 19:34:00]

do we need to clear the _jumpTargetMap when we enter/leave? or have a stack of
them (like we have a stack of members)?

[Johnni Winther, 2017/06/26 09:04:18]

Yes, something like it. I think we need to split inlined member from
KernelToLocalsMap.

[Siggi Cherem (dart-lang), 2017/06/26 16:44:14]

Can you add a note about it here? (maybe TODO(redemption)) - just want to make
sure we don't accidentally hit this when we start implementing inlining and
forget about it.

   }
 
   @override
   JumpTarget getJumpTargetForBreak(ir.BreakStatement node) {
-    throw new UnimplementedError('KernelToLocalsMapImpl.getJumpTargetForBreak');
+    _ensureJumpMap(node.target);
+    JumpTarget target = _jumpTargetMap[node.target];
+    assert(target != null, failedAt(currentMember, 'No target for $node.'));
+    return target;
   }
 
   @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) {
-    // TODO(johnniwinther): Support do statement as jump target.
-    return null;
+    _ensureJumpMap(node);
+    return _jumpTargetMap[node.parent];
   }
 
   @override
   JumpTarget getJumpTargetForLabel(ir.LabeledStatement node) {
-    throw new UnimplementedError('KernelToLocalsMapImpl.getJumpTargetForLabel');
+    _ensureJumpMap(node);
+    JumpTarget target = _jumpTargetMap[node];
+    assert(target != null, failedAt(currentMember, 'No target for $node.'));
+    return target;
   }
 
   @override
   JumpTarget getJumpTargetForSwitch(ir.SwitchStatement node) {
+    _ensureJumpMap(node);
     throw new UnimplementedError(
         'KernelToLocalsMapImpl.getJumpTargetForSwitch');
   }
 
   @override
   JumpTarget getJumpTargetForFor(ir.ForStatement node) {
-    // TODO(johnniwinther): Support for statement as jump target.
-    return null;
+    _ensureJumpMap(node);
+    return _jumpTargetMap[node.parent];
   }
 
   @override
   JumpTarget getJumpTargetForForIn(ir.ForInStatement node) {
-    // TODO(johnniwinther): Support for-in statement as jump target.
-    return null;
+    _ensureJumpMap(node);
+    return _jumpTargetMap[node.parent];
   }
 
   @override
   JumpTarget getJumpTargetForWhile(ir.WhileStatement node) {
-    // TODO(johnniwinther): Support while statement as jump target.
-    return null;
+    _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 {
+  final MemberEntity member;
+  final Map<ir.LabeledStatement, KJumpTarget> jumpTargetMap =
+      <ir.LabeledStatement, KJumpTarget>{};
+
+  JumpVisitor(this.member);
+
+  KJumpTarget _getJumpTarget(ir.LabeledStatement node) {
+    return jumpTargetMap.putIfAbsent(node, () {
+      return new KJumpTarget(member, jumpTargetMap.length);
+    });
+  }
+
+  @override
+  defaultNode(ir.Node node) => node.visitChildren(this);
+
+  @override
+  visitBreakStatement(ir.BreakStatement node) {
+    KJumpTarget target = _getJumpTarget(node.target);
+    target.isBreakTarget = true;
+    super.visitBreakStatement(node);
+  }
+}
+
+class KJumpTarget extends JumpTarget<ir.Node> {
+  final MemberEntity memberContext;
+  final int nestingLevel;
+
+  KJumpTarget(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');
+  }
+
+  @override
+  List<LabelDefinition<ir.Node>> get labels {
+    return const <LabelDefinition<ir.Node>>[];
+  }
+
+  @override
+  ir.Node get statement {
+    throw new UnimplementedError('KJumpTarget.statement');
+  }
+}
+
 class KLocal implements Local {
   final String name;
   final MemberEntity memberContext;
 
   KLocal(this.name, this.memberContext);
 
   @override
   Entity get executableContext => memberContext;
 
   String toString() {
@@ skipping 51 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));
       });
   }
 }