Move local properties to KernelToLocalsMap

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 '../closure.dart';
 import '../common.dart';
 import '../compiler.dart';
@@ skipping 16 matching lines @@
 import '../universe/selector.dart';
 import '../world.dart';
 import 'graph_builder.dart';
 import 'jump_handler.dart' show SwitchCaseJumpHandler;
 import 'locals_handler.dart';
 import 'types.dart';
 
 /// A helper class that abstracts all accesses of the AST from Kernel nodes.
 ///
 /// The goal is to remove all need for the AST from the Kernel SSA builder.
-class KernelAstAdapter extends KernelToElementMapMixin {
+class KernelAstAdapter extends KernelToElementMapMixin
+    implements KernelToLocalsMap {
   final Kernel kernel;
   final JavaScriptBackend _backend;
   final Map<ir.Node, ast.Node> _nodeToAst;
   final Map<ir.Node, Element> _nodeToElement;
   final Map<ir.VariableDeclaration, SyntheticLocal> _syntheticLocals =
       <ir.VariableDeclaration, SyntheticLocal>{};
   // TODO(efortuna): In an ideal world the TreeNodes should be some common
   // interface we create for both ir.Statements and ir.SwitchCase (the
   // ContinueSwitchStatement's target is a SwitchCase) rather than general
   // TreeNode. Talking to Asger about this.
@@ skipping 159 matching lines @@
   ast.Node getNodeOrNull(ir.Node node) {
     return _nodeToAst[node];
   }
 
   void assertNodeIsSynthetic(ir.Node node) {
     assert(invariant(
         CURRENT_ELEMENT_SPANNABLE, kernel.syntheticNodes.contains(node),
         message: "No synthetic marker found for $node"));
   }
 
+  @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;
   }
 
   FunctionSignature getFunctionSignature(ir.FunctionNode function) {
@@ skipping 33 matching lines @@
 
   // Is the member a lazy initialized static or top-level member?
   bool isLazyStatic(ir.Member member) {
     if (member is ir.Field) {
       FieldElement field = _nodeToElement[member];
       return field.constant == null;
     }
     return false;
   }
 
-  LibraryElement get jsHelperLibrary =>
-      _compiler.commonElements.jsHelperLibrary;
-
   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);
     });
   }
 
-  bool isInForeignLibrary(ir.Member member) =>
-      _backend.isForeign(getElement(member));
-
   native.NativeBehavior getNativeBehavior(ir.Node node) {
     return elements.getNativeData(getNode(node));
   }
 
   js.Name getNameForJsGetName(ir.Node argument, ConstantValue constant) {
     int index = _extractEnumIndexFromConstantValue(
         constant, _compiler.commonElements.jsGetNameEnum);
     if (index == null) return null;
     return _backend.namer
         .getNameForJsGetName(getNode(argument), JsGetName.values[index]);
@@ skipping 265 matching lines @@
   @override
   ast.Node get statement => null;
 
   String toString() => 'Target:$targetStatement';
 }
 
 /// Special [JumpHandler] implementation used to handle continue statements
 /// targeting switch cases.
 class KernelSwitchCaseJumpHandler extends SwitchCaseJumpHandler {
   KernelSwitchCaseJumpHandler(GraphBuilder builder, JumpTarget target,
-      ir.SwitchStatement switchStatement, KernelAstAdapter astAdapter)
+      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 =
-          astAdapter.getJumpTarget(switchCase, isContinueTarget: true);
+          localsMap.getJumpTarget(switchCase, isContinueTarget: true);
       assert(continueTarget is KernelJumpTarget);
       targetIndexMap[continueTarget] = switchIndex;
       assert(builder.jumpTargets[continueTarget] == null);
       builder.jumpTargets[continueTarget] = this;
       switchIndex++;
     }
   }
 }
 
 class KernelAstTypeInferenceMap implements KernelToTypeInferenceMap {
@@ skipping 100 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);
   }
 }