Even less reliance on Compiler.closedWorld

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 '../constants/expressions.dart';
 import '../common.dart';
 import '../common/names.dart';
@@ skipping 51 matching lines @@
     }
     _typeConverter = new DartTypeConverter(this);
   }
 
   Compiler get _compiler => _backend.compiler;
   TreeElements get elements => _resolvedAst.elements;
   DiagnosticReporter get reporter => _compiler.reporter;
   Element get _target => _resolvedAst.element;
   ClosedWorld get _closedWorld => _compiler.closedWorld;
 
+  GlobalTypeInferenceResults get _globalInferenceResults =>
+      _compiler.globalInference.results;
+
   GlobalTypeInferenceElementResult _resultOf(Element e) =>
-      _compiler.globalInference.results.resultOf(e);
+      _globalInferenceResults.resultOf(e);
 
   ConstantValue getConstantForSymbol(ir.SymbolLiteral node) {
     if (kernel.syntheticNodes.contains(node)) {
       return _backend.constantSystem.createSymbol(_compiler, node.value);
     }
     ast.Node astNode = getNode(node);
     ConstantValue constantValue = _backend.constants
         .getConstantValueForNode(astNode, _resolvedAst.elements);
     assert(invariant(astNode, constantValue != null,
         message: 'No constant computed for $node'));
@@ skipping 42 matching lines @@
     return getElement(variable) as LocalElement;
   }
 
   bool getCanThrow(ir.Node procedure) {
     FunctionElement function = getElement(procedure);
     return !_closedWorld.getCannotThrow(function);
   }
 
   TypeMask returnTypeOf(ir.Member node) {
     return TypeMaskFactory.inferredReturnTypeForElement(
-        getElement(node), _compiler);
+        getElement(node), _globalInferenceResults);
   }
 
   SideEffects getSideEffects(ir.Node node) {
     return _closedWorld.getSideEffectsOfElement(getElement(node));
   }
 
   CallStructure getCallStructure(ir.Arguments arguments) {
     int argumentCount = arguments.positional.length + arguments.named.length;
     List<String> namedArguments = arguments.named.map((e) => e.name).toList();
     return new CallStructure(argumentCount, namedArguments);
@@ skipping 111 matching lines @@
     if (mask.isContainer && (mask as ContainerTypeMask).length != null) {
       // A container on which we have inferred the length.
       return true;
     }
     // TODO(sra): Recognize any combination of fixed length indexables.
     if (mask.containsOnly(
             _closedWorld.backendClasses.fixedListImplementation) ||
         mask.containsOnly(
             _closedWorld.backendClasses.constListImplementation) ||
         mask.containsOnlyString(_closedWorld) ||
-        backend.isTypedArray(mask)) {
+        _closedWorld.commonMasks.isTypedArray(mask)) {
       return true;
     }
     return false;
   }
 
   TypeMask inferredIndexType(ir.ForInStatement forInStatement) {
-    return TypeMaskFactory.inferredTypeForSelector(
-        new Selector.index(), typeOfIterator(forInStatement), _compiler);
+    return TypeMaskFactory.inferredTypeForSelector(new Selector.index(),
+        typeOfIterator(forInStatement), _globalInferenceResults);
   }
 
   TypeMask inferredTypeOf(ir.Member node) {
-    return TypeMaskFactory.inferredTypeForElement(getElement(node), _compiler);
+    return TypeMaskFactory.inferredTypeForElement(
+        getElement(node), _globalInferenceResults);
   }
 
   TypeMask selectorTypeOf(Selector selector, TypeMask mask) {
-    return TypeMaskFactory.inferredTypeForSelector(selector, mask, _compiler);
+    return TypeMaskFactory.inferredTypeForSelector(
+        selector, mask, _globalInferenceResults);
   }
 
   TypeMask typeFromNativeBehavior(native.NativeBehavior nativeBehavior) {
-    return TypeMaskFactory.fromNativeBehavior(nativeBehavior, _compiler);
+    return TypeMaskFactory.fromNativeBehavior(nativeBehavior, _closedWorld);
   }
 
   ConstantValue getConstantFor(ir.Node node) {
     ConstantValue constantValue =
         _backend.constants.getConstantValueForNode(getNode(node), elements);
     assert(invariant(getNode(node), constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
   }
 
@@ skipping 53 matching lines @@
   ir.Procedure get mapLiteralUntypedMaker =>
       kernel.functions[_backend.helpers.mapLiteralUntypedMaker];
 
   MemberElement get jsIndexableLength => _backend.helpers.jsIndexableLength;
 
   ir.Procedure get checkConcurrentModificationError =>
       kernel.functions[_backend.helpers.checkConcurrentModificationError];
 
   TypeMask get checkConcurrentModificationErrorReturnType =>
       TypeMaskFactory.inferredReturnTypeForElement(
-          _backend.helpers.checkConcurrentModificationError, _compiler);
+          _backend.helpers.checkConcurrentModificationError,
+          _globalInferenceResults);
 
   ir.Procedure get checkSubtype =>
       kernel.functions[_backend.helpers.checkSubtype];
 
   ir.Procedure get checkSubtypeOfRuntimeType =>
       kernel.functions[_backend.helpers.checkSubtypeOfRuntimeType];
 
   ir.Procedure get assertHelper =>
       kernel.functions[_backend.helpers.assertHelper];
 
-  TypeMask get throwTypeErrorType => TypeMaskFactory
-      .inferredReturnTypeForElement(_backend.helpers.throwTypeError, _compiler);
+  TypeMask get throwTypeErrorType =>
+      TypeMaskFactory.inferredReturnTypeForElement(
+          _backend.helpers.throwTypeError, _globalInferenceResults);
 
-  TypeMask get assertHelperReturnType => TypeMaskFactory
-      .inferredReturnTypeForElement(_backend.helpers.assertHelper, _compiler);
+  TypeMask get assertHelperReturnType =>
+      TypeMaskFactory.inferredReturnTypeForElement(
+          _backend.helpers.assertHelper, _globalInferenceResults);
 
   ir.Procedure get assertTest => kernel.functions[_backend.helpers.assertTest];
 
-  TypeMask get assertTestReturnType => TypeMaskFactory
-      .inferredReturnTypeForElement(_backend.helpers.assertTest, _compiler);
+  TypeMask get assertTestReturnType =>
+      TypeMaskFactory.inferredReturnTypeForElement(
+          _backend.helpers.assertTest, _globalInferenceResults);
 
   ir.Procedure get assertThrow =>
       kernel.functions[_backend.helpers.assertThrow];
 
   ir.Procedure get setRuntimeTypeInfo =>
       kernel.functions[_backend.helpers.setRuntimeTypeInfo];
 
-  TypeMask get assertThrowReturnType => TypeMaskFactory
-      .inferredReturnTypeForElement(_backend.helpers.assertThrow, _compiler);
+  TypeMask get assertThrowReturnType =>
+      TypeMaskFactory.inferredReturnTypeForElement(
+          _backend.helpers.assertThrow, _globalInferenceResults);
 
   ir.Procedure get runtimeTypeToString =>
       kernel.functions[_backend.helpers.runtimeTypeToString];
 
   ir.Procedure get createRuntimeType =>
       kernel.functions[_backend.helpers.createRuntimeType];
 
   TypeMask get createRuntimeTypeReturnType =>
       TypeMaskFactory.inferredReturnTypeForElement(
-          _backend.helpers.createRuntimeType, _compiler);
+          _backend.helpers.createRuntimeType, _globalInferenceResults);
 
   ir.Class get objectClass => kernel.classes[_compiler.coreClasses.objectClass];
 
   ir.Procedure get currentIsolate =>
       kernel.functions[_backend.helpers.currentIsolate];
 
   ir.Procedure get callInIsolate =>
       kernel.functions[_backend.helpers.callInIsolate];
 
   bool isInForeignLibrary(ir.Member member) =>
@@ skipping 432 matching lines @@
     astAdapter.reporter.internalError(
         CURRENT_ELEMENT_SPANNABLE, "Unexpected constant target: $element.");
     return null;
   }
 
   @override
   ConstantExpression visitStringLiteral(ir.StringLiteral node) {
     return new StringConstantExpression(node.value);
   }
 }