Refactoring to prepare for kernel based jump targets

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:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 211 matching lines @@
   @override
   Local getLocal(ir.VariableDeclaration variable) {
     // If this is a synthetic local, return the synthetic local
     if (variable.name == null) {
       return _syntheticLocals.putIfAbsent(
           variable, () => new SyntheticLocal("x", null, null));
     }
     return getElement(variable) as LocalElement;
   }
 
+  @override
+  JumpTarget getJumpTargetForBreak(ir.BreakStatement node) {
+    return getJumpTarget(node.target);
+  }
+
+  @override
+  JumpTarget getJumpTargetForLabel(ir.LabeledStatement node) {
+    return getJumpTarget(node);
+  }
+
+  @override
+  JumpTarget getJumpTargetForSwitch(ir.SwitchStatement node) {
+    return getJumpTarget(node);
+  }
+
+  @override
+  JumpTarget getJumpTargetForContinueSwitch(ir.ContinueSwitchStatement node) {
+    return getJumpTarget(node.target);
+  }
+
+  @override
+  JumpTarget getJumpTargetForSwitchCase(ir.SwitchCase node) {
+    return getJumpTarget(node, isContinueTarget: true);
+  }
+
+  @override
+  JumpTarget getJumpTargetForDo(ir.DoStatement node) {
+    return getJumpTarget(node);
+  }
+
+  @override
+  JumpTarget getJumpTargetForFor(ir.ForStatement node) {
+    return getJumpTarget(node);
+  }
+
+  @override
+  JumpTarget getJumpTargetForForIn(ir.ForInStatement node) {
+    return getJumpTarget(node);
+  }
+
+  @override
+  JumpTarget getJumpTargetForWhile(ir.WhileStatement node) {
+    return getJumpTarget(node);
+  }
+
   KernelJumpTarget getJumpTarget(ir.TreeNode node,
       {bool isContinueTarget: false}) {
     return _jumpTargets.putIfAbsent(node, () {
       if (node is ir.LabeledStatement && _jumpTargets.containsKey(node.body)) {
         return _jumpTargets[node.body];
       }
       return new KernelJumpTarget(node, this,
           makeContinueLabel: isContinueTarget);
     });
   }
@@ skipping 137 matching lines @@
   }
 
   @override
   ResolutionDartType visitInvalidType(ir.InvalidType node) {
     // Root uses such a `o is Unresolved` and `o as Unresolved` must be special
     // cased in the builder, nested invalid types are treated as `dynamic`.
     return const ResolutionDynamicType();
   }
 }
 
-class KernelJumpTarget extends JumpTarget<ast.Node> {
+class KernelJumpTarget implements JumpTargetX {
   static int index = 0;
 
   /// Pointer to the actual executable statements that a jump target refers to.
   /// If this jump target was not initially constructed with a LabeledStatement,
   /// this value is identical to originalStatement. This Node is actually of
   /// type either ir.Statement or ir.SwitchCase.
   ir.Node targetStatement;
 
   /// The original statement used to construct this jump target.
   /// If this jump target was not initially constructed with a LabeledStatement,
@@ skipping 43 matching lines @@
     }
 
     if (makeContinueLabel) {
       labels.add(
           new LabelDefinitionX(null, 'L${index++}', this)..setContinueTarget());
       isContinueTarget = true;
     }
   }
 
   @override
-  LabelDefinition<ast.Node> addLabel(ast.Label label, String labelName) {
-    LabelDefinition result = new LabelDefinitionX(label, labelName, this);
+  LabelDefinition<ast.Node> addLabel(ast.Label label, String labelName,
+      {bool isBreakTarget: false}) {
+    LabelDefinitionX result = new LabelDefinitionX(label, labelName, this);
     labels.add(result);
+    if (isBreakTarget) {
+      result.setBreakTarget();
+    }
     return result;
   }
 
   @override
   ExecutableElement get executableContext => null;
 
   @override
   MemberElement get memberContext => null;
 
   @override
@@ skipping 21 matching lines @@
       ir.SwitchStatement switchStatement, KernelToLocalsMap localsMap)
       : super(builder, target) {
     // The switch case indices must match those computed in
     // [KernelSsaBuilder.buildSwitchCaseConstants].
     // Switch indices are 1-based so we can bypass the synthetic loop when no
     // cases match simply by branching on the index (which defaults to null).
     // TODO
     int switchIndex = 1;
     for (ir.SwitchCase switchCase in switchStatement.cases) {
       JumpTarget continueTarget =
-          localsMap.getJumpTarget(switchCase, isContinueTarget: true);
+          localsMap.getJumpTargetForSwitchCase(switchCase);
       assert(continueTarget is KernelJumpTarget);
       targetIndexMap[continueTarget] = switchIndex;
       assert(builder.jumpTargets[continueTarget] == null);
       builder.jumpTargets[continueTarget] = this;
       switchIndex++;
     }
   }
 }
 
 class KernelAstTypeInferenceMap implements KernelToTypeInferenceMap {
@@ skipping 105 matching lines @@
   TypeMask selectorTypeOf(Selector selector, TypeMask mask) {
     return TypeMaskFactory.inferredTypeForSelector(
         selector, mask, _globalInferenceResults);
   }
 
   TypeMask typeFromNativeBehavior(
       native.NativeBehavior nativeBehavior, ClosedWorld closedWorld) {
     return TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
   }
 }