Decouple LocalsHandler from Compiler and JavaScriptBackend

pkg/compiler/lib/src/ssa/builder_kernel.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 '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
@@ skipping 131 matching lines @@
       Kernel kernel) {
     this.compiler = compiler;
     this.loopHandler = new KernelLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
     graph.element = targetElement;
     // TODO(het): Should sourceInformationBuilder be in GraphBuilder?
     this.sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(resolvedAst);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
-    this.localsHandler = new LocalsHandler(this, targetElement, null, compiler);
+    this.localsHandler = new LocalsHandler(
+        this, targetElement, null, backend.nativeData, backend.interceptorData);
     this.astAdapter = new KernelAstAdapter(kernel, compiler.backend,
         resolvedAst, kernel.nodeToAst, kernel.nodeToElement);
     target = astAdapter.getInitialKernelNode(targetElement);
     if (targetElement is ConstructorBodyElement) {
       _targetIsConstructorBody = true;
     }
   }
 
   HGraph build() {
     // TODO(het): no reason to do this here...
@@ skipping 123 matching lines @@
     for (ir.Constructor body in constructorChain.reversed) {
       if (_isEmptyStatement(body.function.body)) continue;
 
       List<HInstruction> bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
 
       // Pass uncaptured arguments first, captured arguments in a box, then type
       // arguments.
 
       ConstructorElement constructorElement = astAdapter.getElement(body);
-      ClosureClassMap parameterClosureData = compiler.closureToClassMapper
+      ClosureClassMap parameterClosureData = closureToClassMapper
           .getClosureToClassMapping(constructorElement.resolvedAst);
 
       var functionSignature = astAdapter.getFunctionSignature(body.function);
       // Provide the parameters to the generative constructor body.
       functionSignature.orderedForEachParameter((ParameterElement parameter) {
         // If [parameter] is boxed, it will be a field in the box passed as the
         // last parameter. So no need to directly pass it.
         if (!localsHandler.isBoxed(parameter)) {
           bodyCallInputs.add(localsHandler.readLocal(parameter));
         }
@@ skipping 240 matching lines @@
   // TODO(sra): Re-implement type builder using Kernel types and the
   // `target` for context.
   @override
   Element get sourceElement => _sourceElementForTarget(target);
 
   Element _sourceElementForTarget(ir.Node target) {
     // For closure-converted (i.e. local functions) the source element is the
     // 'call' method of the class that represents the closure.
     if (target is ir.FunctionExpression) {
       LocalFunctionElement element = astAdapter.getElement(target);
-      ClosureClassMap classMap = compiler.closureToClassMapper
-          .getClosureToClassMapping(element.resolvedAst);
+      ClosureClassMap classMap =
+          closureToClassMapper.getClosureToClassMapping(element.resolvedAst);
       return classMap.callElement;
     }
     if (target is ir.FunctionDeclaration) {
       LocalFunctionElement element = astAdapter.getElement(target);
-      ClosureClassMap classMap = compiler.closureToClassMapper
-          .getClosureToClassMapping(element.resolvedAst);
+      ClosureClassMap classMap =
+          closureToClassMapper.getClosureToClassMapping(element.resolvedAst);
       return classMap.callElement;
     }
     Element element = astAdapter.getElement(target);
     return element;
   }
 
   @override
   void visitCheckLibraryIsLoaded(ir.CheckLibraryIsLoaded checkLoad) {
     HInstruction prefixConstant = graph.addConstantString(
         new DartString.literal(checkLoad.import.name), closedWorld);
@@ skipping 1922 matching lines @@
           astAdapter.getNode(invocation), MessageKind.JS_PLACEHOLDER_CAPTURE);
     }
 
     TypeMask ssaType =
         astAdapter.typeFromNativeBehavior(nativeBehavior, closedWorld);
 
     SourceInformation sourceInformation = null;
     push(new HForeignCode(nativeBehavior.codeTemplate, ssaType, inputs,
         isStatement: !nativeBehavior.codeTemplate.isExpression,
         effects: nativeBehavior.sideEffects,
-        nativeBehavior: nativeBehavior)..sourceInformation = sourceInformation);
+        nativeBehavior: nativeBehavior)
+      ..sourceInformation = sourceInformation);
   }
 
   void handleJsStringConcat(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2, 2)) {
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
     List<HInstruction> inputs = _visitPositionalArguments(invocation.arguments);
     push(new HStringConcat(inputs[0], inputs[1], commonMasks.stringType));
@@ skipping 35 matching lines @@
       push(new HInvokeDynamicSetter(selector, mask, null, inputs, type));
     } else {
       push(new HInvokeDynamicMethod(
           selector, mask, inputs, type, isIntercepted));
     }
   }
 
   @override
   visitFunctionNode(ir.FunctionNode node) {
     LocalFunctionElement methodElement = astAdapter.getElement(node);
-    ClosureClassMap nestedClosureData = compiler.closureToClassMapper
+    ClosureClassMap nestedClosureData = closureToClassMapper
         .getClosureToClassMapping(methodElement.resolvedAst);
     assert(nestedClosureData != null);
     assert(nestedClosureData.closureClassElement != null);
     ClosureClassElement closureClassElement =
         nestedClosureData.closureClassElement;
     MethodElement callElement = nestedClosureData.callElement;
 
     List<HInstruction> capturedVariables = <HInstruction>[];
     closureClassElement.closureFields.forEach((ClosureFieldElement field) {
       Local capturedLocal =
@@ skipping 27 matching lines @@
   void visitMethodInvocation(ir.MethodInvocation invocation) {
     // Handle `x == null` specially. When these come from null-aware operators,
     // there is no mapping in the astAdapter.
     if (_handleEqualsNull(invocation)) return;
     invocation.receiver.accept(this);
     HInstruction receiver = pop();
     Selector selector = astAdapter.getSelector(invocation);
     _pushDynamicInvocation(
         invocation,
         astAdapter.typeOfInvocation(invocation, closedWorld),
-        <HInstruction>[receiver]
-          ..addAll(
-              _visitArgumentsForDynamicTarget(selector, invocation.arguments)));
+        <HInstruction>[receiver]..addAll(
+            _visitArgumentsForDynamicTarget(selector, invocation.arguments)));
   }
 
   bool _handleEqualsNull(ir.MethodInvocation invocation) {
     if (invocation.name.name == '==') {
       ir.Arguments arguments = invocation.arguments;
       if (arguments.types.isEmpty &&
           arguments.positional.length == 1 &&
           arguments.named.isEmpty) {
         bool finish(ir.Expression comparand) {
           comparand.accept(this);
@@ skipping 602 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }