Even less reliance on Compiler.closedWorld

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 '../dart_types.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
@@ skipping 56 matching lines @@
       InterfaceType instanceType, this._compiler)
       : this.instanceType =
             instanceType == null || instanceType.containsTypeVariables
                 ? null
                 : instanceType;
 
   ClosedWorld get closedWorld => builder.closedWorld;
 
   CommonMasks get commonMasks => closedWorld.commonMasks;
 
+  GlobalTypeInferenceResults get _globalInferenceResults =>
+      _compiler.globalInference.results;
+
   /// Substituted type variables occurring in [type] into the context of
   /// [contextClass].
   DartType substInContext(DartType type) {
     if (contextClass != null) {
       ClassElement typeContext = Types.getClassContext(type);
       if (typeContext != null) {
         type = type.substByContext(contextClass.asInstanceOf(typeContext));
       }
     }
     if (instanceType != null) {
@@ skipping 112 matching lines @@
           if (scopeData != null &&
               scopeData.isCapturedVariable(parameterElement)) {
             // The parameter will be a field in the box passed as the
             // last parameter. So no need to have it.
             return;
           }
         }
         HInstruction parameter = builder.addParameter(
             parameterElement,
             TypeMaskFactory.inferredTypeForElement(
-                parameterElement, _compiler));
+                parameterElement, _globalInferenceResults));
         builder.parameters[parameterElement] = parameter;
         directLocals[parameterElement] = parameter;
       });
     }
 
     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.
@@ skipping 413 matching lines @@
     }
     return result;
   }
 
   Map<Element, TypeMask> cachedTypesOfCapturedVariables =
       new Map<Element, TypeMask>();
 
   TypeMask getTypeOfCapturedVariable(Element element) {
     assert(element.isField);
     return cachedTypesOfCapturedVariables.putIfAbsent(element, () {
-      return TypeMaskFactory.inferredTypeForElement(element, _compiler);
+      return TypeMaskFactory.inferredTypeForElement(
+          element, _globalInferenceResults);
     });
   }
 
   /// Variables stored in the current activation. These variables are
   /// being updated in try/catch blocks, and should be
   /// accessed indirectly through [HLocalGet] and [HLocalSet].
   Map<Local, HLocalValue> activationVariables = <Local, HLocalValue>{};
 }
 
 /// A synthetic local variable only used with the SSA graph.
 ///
 /// For instance used for holding return value of function or the exception of a
 /// try-catch statement.
 class SyntheticLocal extends Local {
   final String name;
   final ExecutableElement executableContext;
 
   // Avoid slow Object.hashCode.
   final int hashCode = _nextHashCode = (_nextHashCode + 1).toUnsigned(30);
   static int _nextHashCode = 0;
 
   SyntheticLocal(this.name, this.executableContext);
 
   toString() => 'SyntheticLocal($name)';
 }