Decouple LocalsHandler from Compiler and JavaScriptBackend

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 127 matching lines @@
   /// Registry used to enqueue work during codegen, may be null to avoid
   /// enqueing any work.
   // TODO(sigmund,johnniwinther): get rid of registry entirely. We should be
   // able to return the impact as a result after building and avoid enqueing
   // things here. Later the codegen task can decide whether to enqueue
   // something. In the past this didn't matter as much because the SSA graph was
   // used only for codegen, but currently we want to experiment using it for
   // code-analysis too.
   final CodegenRegistry registry;
 
-  /// All results from the global type-inference analysis.
-  final GlobalTypeInferenceResults inferenceResults;
-
   /// Results from the global type-inference analysis corresponding to the
   /// current element being visited.
   ///
   /// Invariant: this property is updated together with [resolvedAst].
   GlobalTypeInferenceElementResult elementInferenceResults;
 
   final JavaScriptBackend backend;
   final ConstantSystem constantSystem;
   final RuntimeTypesSubstitutions rtiSubstitutions;
 
@@ skipping 37 matching lines @@
       this.target,
       this.resolvedAst,
       this.registry,
       JavaScriptBackend backend,
       this.closedWorld,
       this.nativeEmitter,
       SourceInformationStrategy sourceInformationFactory)
       : this.infoReporter = backend.compiler.dumpInfoTask,
         this.backend = backend,
         this.constantSystem = backend.constantSystem,
-        this.rtiSubstitutions = backend.rtiSubstitutions,
-        this.inferenceResults = backend.compiler.globalInference.results {
+        this.rtiSubstitutions = backend.rtiSubstitutions {
     assert(target.isImplementation);
     compiler = backend.compiler;
     elementInferenceResults = _resultOf(target);
     assert(elementInferenceResults != null);
     graph.element = target;
     sourceElementStack.add(target);
     sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(resolvedAst);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
-    localsHandler = new LocalsHandler(this, target, null, compiler);
+    localsHandler = new LocalsHandler(
+        this, target, null, backend.nativeData, backend.interceptorData);
     loopHandler = new SsaLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
   }
 
   BackendHelpers get helpers => backend.helpers;
 
   RuntimeTypesEncoder get rtiEncoder => backend.rtiEncoder;
 
   Element get targetElement => target;
 
@@ skipping 22 matching lines @@
   MemberElement get sourceElement => sourceElementStack.last;
 
   /// Helper to retrieve global inference results for [element] with special
   /// care for `ConstructorBodyElement`s which don't exist at the time the
   /// global analysis run.
   ///
   /// Note: this helper is used selectively. When we know that we are in a
   /// context were we don't expect to see a constructor body element, we
   /// directly fetch the data from the global inference results.
   GlobalTypeInferenceElementResult _resultOf(MemberElement element) =>
-      inferenceResults.resultOfMember(
+      globalInferenceResults.resultOfMember(
           element is ConstructorBodyElementX ? element.constructor : element);
 
   /// Build the graph for [target].
   HGraph build() {
     assert(invariant(target, target.isImplementation));
     HInstruction.idCounter = 0;
     // TODO(sigmund): remove `result` and return graph directly, need to ensure
     // that it can never be null (see result in buildFactory for instance).
     var result;
     if (target.isGenerativeConstructor) {
@@ skipping 176 matching lines @@
       // Generative constructors of native classes should not be called directly
       // and have an extra argument that causes problems with inlining.
       if (function.isGenerativeConstructor &&
           backend.nativeData.isNativeOrExtendsNative(function.enclosingClass)) {
         return false;
       }
 
       // A generative constructor body is not seen by global analysis,
       // so we should not query for its type.
       if (!function.isGenerativeConstructorBody) {
-        if (inferenceResults.resultOfMember(function).throwsAlways) {
+        if (globalInferenceResults.resultOfMember(function).throwsAlways) {
           isReachable = false;
           return false;
         }
       }
 
       return true;
     }
 
     bool doesNotContainCode() {
       // A function with size 1 does not contain any code.
@@ skipping 113 matching lines @@
     return false;
   }
 
   bool get allInlinedFunctionsCalledOnce {
     return inliningStack.isEmpty || inliningStack.last.allFunctionsCalledOnce;
   }
 
   bool isFunctionCalledOnce(MethodElement element) {
     // ConstructorBodyElements are not in the type inference graph.
     if (element is ConstructorBodyElement) return false;
-    return inferenceResults.resultOfMember(element).isCalledOnce;
+    return globalInferenceResults.resultOfMember(element).isCalledOnce;
   }
 
   bool isCalledOnce(MethodElement element) {
     return allInlinedFunctionsCalledOnce && isFunctionCalledOnce(element);
   }
 
   inlinedFrom(ResolvedAst resolvedAst, f()) {
     MemberElement element = resolvedAst.element;
     assert(element is FunctionElement || element is VariableElement);
     return reporter.withCurrentElement(element.implementation, () {
@@ skipping 186 matching lines @@
    * When inlining a function, [:return:] statements are not emitted as
    * [HReturn] instructions. Instead, the value of a synthetic element is
    * updated in the [localsHandler]. This function creates such an element and
    * stores it in the [returnLocal] field.
    */
   void setupStateForInlining(
       FunctionElement function, List<HInstruction> compiledArguments,
       {ResolutionInterfaceType instanceType}) {
     ResolvedAst resolvedAst = function.resolvedAst;
     assert(resolvedAst != null);
-    localsHandler = new LocalsHandler(this, function, instanceType, compiler);
+    localsHandler = new LocalsHandler(this, function, instanceType,
+        backend.nativeData, backend.interceptorData);
     localsHandler.closureData =
-        compiler.closureToClassMapper.getClosureToClassMapping(resolvedAst);
+        closureToClassMapper.getClosureToClassMapping(resolvedAst);
     returnLocal = new SyntheticLocal("result", function);
     localsHandler.updateLocal(returnLocal, graph.addConstantNull(closedWorld));
 
     inTryStatement = false; // TODO(lry): why? Document.
 
     int argumentIndex = 0;
     if (function.isInstanceMember) {
       localsHandler.updateLocal(localsHandler.closureData.thisLocal,
           compiledArguments[argumentIndex++]);
     }
@@ skipping 143 matching lines @@
         if (parameter.isInitializingFormal) {
           InitializingFormalElement fieldParameterElement = parameter;
           fieldValues[fieldParameterElement.fieldElement] = argument;
         }
       });
 
       // Build the initializers in the context of the new constructor.
       ResolvedAst oldResolvedAst = resolvedAst;
       resolvedAst = callee.resolvedAst;
       final oldElementInferenceResults = elementInferenceResults;
-      elementInferenceResults = inferenceResults.resultOfMember(callee);
+      elementInferenceResults = globalInferenceResults.resultOfMember(callee);
       ClosureClassMap oldClosureData = localsHandler.closureData;
       ClosureClassMap newClosureData =
-          compiler.closureToClassMapper.getClosureToClassMapping(resolvedAst);
+          closureToClassMapper.getClosureToClassMapping(resolvedAst);
       localsHandler.closureData = newClosureData;
       if (resolvedAst.kind == ResolvedAstKind.PARSED) {
         localsHandler.enterScope(resolvedAst.node, callee);
       }
       buildInitializers(callee, constructorResolvedAsts, fieldValues);
       localsHandler.closureData = oldClosureData;
       resolvedAst = oldResolvedAst;
       elementInferenceResults = oldElementInferenceResults;
     });
   }
@@ skipping 151 matching lines @@
           // Unassigned fields of native classes are not initialized to
           // prevent overwriting pre-initialized native properties.
           if (!backend.nativeData.isNativeOrExtendsNative(classElement)) {
             fieldValues[member] = graph.addConstantNull(closedWorld);
           }
         } else {
           ast.Node right = initializer;
           ResolvedAst savedResolvedAst = resolvedAst;
           resolvedAst = fieldResolvedAst;
           final oldElementInferenceResults = elementInferenceResults;
-          elementInferenceResults = inferenceResults.resultOfMember(member);
+          elementInferenceResults =
+              globalInferenceResults.resultOfMember(member);
           // In case the field initializer uses closures, run the
           // closure to class mapper.
-          compiler.closureToClassMapper.getClosureToClassMapping(resolvedAst);
+          closureToClassMapper.getClosureToClassMapping(resolvedAst);
           inlinedFrom(fieldResolvedAst, () => right.accept(this));
           resolvedAst = savedResolvedAst;
           elementInferenceResults = oldElementInferenceResults;
           fieldValues[member] = pop();
         }
       });
     });
   }
 
   /**
@@ skipping 141 matching lines @@
       List bodyCallInputs = <HInstruction>[];
       if (isNativeUpgradeFactory) {
         if (interceptor == null) {
           ConstantValue constant = new InterceptorConstantValue(classElement);
           interceptor = graph.addConstant(constant, closedWorld);
         }
         bodyCallInputs.add(interceptor);
       }
       bodyCallInputs.add(newObject);
       ast.Node node = constructorResolvedAst.node;
-      ClosureClassMap parameterClosureData = compiler.closureToClassMapper
-          .getClosureToClassMapping(constructorResolvedAst);
+      ClosureClassMap parameterClosureData =
+          closureToClassMapper.getClosureToClassMapping(constructorResolvedAst);
 
       FunctionSignature functionSignature = body.functionSignature;
       // 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 1669 matching lines @@
     // Until now we only handle these as getters.
     invariant(node, deferredLoader.isDeferredLoaderGetter);
     FunctionEntity loadFunction = helpers.loadLibraryWrapper;
     PrefixElement prefixElement = deferredLoader.enclosingElement;
     String loadId =
         compiler.deferredLoadTask.getImportDeferName(node, prefixElement);
     var inputs = [
       graph.addConstantString(new ast.DartString.literal(loadId), closedWorld)
     ];
     push(new HInvokeStatic(loadFunction, inputs, commonMasks.nonNullType,
-        targetCanThrow: false)..sourceInformation = sourceInformation);
+        targetCanThrow: false)
+      ..sourceInformation = sourceInformation);
   }
 
   generateSuperNoSuchMethodSend(
       ast.Send node, Selector selector, List<HInstruction> arguments) {
     String name = selector.name;
 
     ClassElement cls = currentNonClosureClass;
     MethodElement element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
     if (!Selectors.noSuchMethod_.signatureApplies(element)) {
       ClassElement objectClass = commonElements.objectClass;
@@ skipping 415 matching lines @@
         var constant = inputs[0];
         int value = constant.constant.primitiveValue;
         if (0 <= value && value < 0x100000000) canThrow = false;
       }
       HForeignCode foreign = new HForeignCode(code, elementType, inputs,
           nativeBehavior: behavior,
           throwBehavior: canThrow
               ? native.NativeThrowBehavior.MAY
               : native.NativeThrowBehavior.NEVER);
       push(foreign);
-      if (inferenceResults.isFixedArrayCheckedForGrowable(send)) {
+      if (globalInferenceResults.isFixedArrayCheckedForGrowable(send)) {
         js.Template code = js.js.parseForeignJS(r'#.fixed$length = Array');
         // We set the instruction as [canThrow] to avoid it being dead code.
         // We need a finer grained side effect.
         add(new HForeignCode(code, commonMasks.nullType, [stack.last],
             throwBehavior: native.NativeThrowBehavior.MAY));
       }
     } else if (isGrowableListConstructorCall) {
       push(buildLiteralList(<HInstruction>[]));
       stack.last.instructionType = elementType;
     } else {
@@ skipping 644 matching lines @@
     } else if (element.isSetter) {
       code = "# = #";
     } else {
       var args = new List.filled(arguments.length, '#').join(',');
       code = element.isConstructor ? "new #($args)" : "#($args)";
     }
     js.Template codeTemplate = js.js.parseForeignJS(code);
     nativeBehavior.codeTemplate = codeTemplate;
 
     return new HForeignCode(codeTemplate, commonMasks.dynamicType, inputs,
-        nativeBehavior: nativeBehavior)..sourceInformation = sourceInformation;
+        nativeBehavior: nativeBehavior)
+      ..sourceInformation = sourceInformation;
   }
 
   void pushInvokeStatic(
       ast.Node location, MethodElement element, List<HInstruction> arguments,
       {TypeMask typeMask,
       ResolutionInterfaceType instanceType,
       SourceInformation sourceInformation}) {
     assert(element.isDeclaration);
     // TODO(johnniwinther): Use [sourceInformation] instead of [location].
     if (tryInlineMethod(element, null, null, arguments, location,
@@ skipping 2644 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }