Decouple LocalsHandler from Compiler and JavaScriptBackend

pkg/compiler/lib/src/ssa/locals_handler.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 '../closure.dart';
 import '../common.dart';
-import '../compiler.dart' show Compiler;
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
-import '../js_backend/js_backend.dart';
+import '../js_backend/native_data.dart';
+import '../js_backend/interceptor_data.dart';
 import '../native/native.dart' as native;
 import '../tree/tree.dart' as ast;
 import '../types/types.dart';
 import '../world.dart' show ClosedWorld;
 
 import 'graph_builder.dart';
 import 'nodes.dart';
 import 'types.dart';
 
 /// Keeps track of locals (including parameters and phis) when building. The
@@ skipping 31 matching lines @@
   ///     }
   ///     main() {
   ///       new Foo<String>('foo');
   ///     }
   ///
   /// [instanceType] is not used if it contains type variables, since these
   /// might not be in scope or from the current instance.
   ///
   final ResolutionInterfaceType instanceType;
 
-  final Compiler _compiler;
+  final NativeData _nativeData;
 
-  LocalsHandler(this.builder, this.executableContext,
-      ResolutionInterfaceType instanceType, this._compiler)
+  final InterceptorData _interceptorData;
+
+  LocalsHandler(
+      this.builder,
+      this.executableContext,
+      ResolutionInterfaceType instanceType,
+      this._nativeData,
+      this._interceptorData)
       : this.instanceType =
             instanceType == null || instanceType.containsTypeVariables
                 ? null
                 : instanceType;
 
   ClosedWorld get closedWorld => builder.closedWorld;
 
   CommonMasks get commonMasks => closedWorld.commonMasks;
 
   GlobalTypeInferenceResults get _globalInferenceResults =>
-      _compiler.globalInference.results;
+      builder.globalInferenceResults;
+
+  ClosureTask get _closureToClassMapper => builder.closureToClassMapper;
 
   /// Substituted type variables occurring in [type] into the context of
   /// [contextClass].
   ResolutionDartType substInContext(ResolutionDartType type) {
     if (contextClass != null) {
       ClassElement typeContext = Types.getClassContext(type);
       if (typeContext != null) {
         type = type.substByContext(contextClass.asInstanceOf(typeContext));
       }
     }
     if (instanceType != null) {
       type = type.substByContext(instanceType);
     }
     return type;
   }
 
   /// Creates a new [LocalsHandler] based on [other]. We only need to
   /// copy the [directLocals], since the other fields can be shared
   /// throughout the AST visit.
   LocalsHandler.from(LocalsHandler other)
       : directLocals = new Map<Local, HInstruction>.from(other.directLocals),
         redirectionMapping = other.redirectionMapping,
         executableContext = other.executableContext,
         instanceType = other.instanceType,
         builder = other.builder,
         closureData = other.closureData,
-        _compiler = other._compiler,
+        _nativeData = other._nativeData,
+        _interceptorData = other._interceptorData,
         activationVariables = other.activationVariables,
         cachedTypeOfThis = other.cachedTypeOfThis,
         cachedTypesOfCapturedVariables = other.cachedTypesOfCapturedVariables;
 
   /// Redirects accesses from element [from] to element [to]. The [to] element
   /// must be a boxed variable or a variable that is stored in a closure-field.
   void redirectElement(Local from, CapturedVariable to) {
     assert(redirectionMapping[from] == null);
     redirectionMapping[from] = to;
     assert(isStoredInClosureField(from) || isBoxed(from));
@@ skipping 67 matching lines @@
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
   /// Documentation wanted -- johnniwinther
   ///
   /// Invariant: [function] must be an implementation element.
   void startFunction(MemberElement element, ast.Node node) {
     assert(invariant(element, element.isImplementation));
-    closureData = _compiler.closureToClassMapper
-        .getClosureToClassMapping(element.resolvedAst);
+    closureData =
+        _closureToClassMapper.getClosureToClassMapping(element.resolvedAst);
 
     if (element is MethodElement) {
       MethodElement functionElement = element;
       FunctionSignature params = functionElement.functionSignature;
       ClosureScope scopeData = closureData.capturingScopes[node];
       params.orderedForEachParameter((ParameterElement parameterElement) {
         if (element.isGenerativeConstructorBody) {
           if (scopeData != null &&
               scopeData.isCapturedVariable(parameterElement)) {
             // The parameter will be a field in the box passed as the
@@ skipping 11 matching lines @@
     }
 
     enterScope(node, element);
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.forEachFreeVariable((Local from, CapturedVariable to) {
       redirectElement(from, to);
     });
-    JavaScriptBackend backend = _compiler.backend;
     if (closureData.isClosure) {
       // Inside closure redirect references to itself to [:this:].
       HThis thisInstruction =
           new HThis(closureData.thisLocal, commonMasks.nonNullType);
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
     } else if (element.isInstanceMember) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
       HThis thisInstruction = new HThis(closureData.thisLocal, getTypeOfThis());
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       directLocals[closureData.thisLocal] = thisInstruction;
     }
 
     // If this method is an intercepted method, add the extra
     // parameter to it, that is the actual receiver for intercepted
     // classes, or the same as [:this:] for non-intercepted classes.
     ClassElement cls = element.enclosingClass;
 
     // When the class extends a native class, the instance is pre-constructed
     // and passed to the generative constructor factory function as a parameter.
     // Instead of allocating and initializing the object, the constructor
     // 'upgrades' the native subclass object by initializing the Dart fields.
     bool isNativeUpgradeFactory = element.isGenerativeConstructor &&
-        backend.nativeData.isNativeOrExtendsNative(cls);
-    if (backend.interceptorData.isInterceptedMethod(element)) {
+        _nativeData.isNativeOrExtendsNative(cls);
+    if (_interceptorData.isInterceptedMethod(element)) {
       bool isInterceptedClass =
-          backend.interceptorData.isInterceptedClass(cls.declaration);
+          _interceptorData.isInterceptedClass(cls.declaration);
       String name = isInterceptedClass ? 'receiver' : '_';
       SyntheticLocal parameter = new SyntheticLocal(name, executableContext);
       HParameterValue value = new HParameterValue(parameter, getTypeOfThis());
       builder.graph.explicitReceiverParameter = value;
       builder.graph.entry.addAfter(directLocals[closureData.thisLocal], value);
       if (builder.lastAddedParameter == null) {
         // If this is the first parameter inserted, make sure it stays first.
         builder.lastAddedParameter = value;
       }
       if (isInterceptedClass) {
@@ skipping 42 matching lines @@
     return closureData.variablesUsedInTryOrGenerator.contains(local);
   }
 
   /// Returns an [HInstruction] for the given element. If the element is
   /// boxed or stored in a closure then the method generates code to retrieve
   /// the value.
   HInstruction readLocal(Local local, {SourceInformation sourceInformation}) {
     if (isAccessedDirectly(local)) {
       if (directLocals[local] == null) {
         if (local is TypeVariableElement) {
-          _compiler.reporter.internalError(_compiler.currentElement,
+          throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
               "Runtime type information not available for $local.");
         } else {
-          _compiler.reporter.internalError(
+          throw new SpannableAssertionFailure(
               local, "Cannot find value $local in ${directLocals.keys}.");
         }
       }
       HInstruction value = directLocals[local];
       if (sourceInformation != null) {
         value = new HRef(value, sourceInformation);
         builder.add(value);
       }
       return value;
     } else if (isStoredInClosureField(local)) {
@@ skipping 335 matching lines @@
   final int hashCode = _nextHashCode = (_nextHashCode + 1).toUnsigned(30);
   static int _nextHashCode = 0;
 
   SyntheticLocal(this.name, this.executableContext);
 
   @override
   MemberElement get memberContext => executableContext.memberContext;
 
   toString() => 'SyntheticLocal($name)';
 }