Reduce use of 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 49 matching lines @@
     for (LocalFunctionElement localFunction in kernel.localFunctions.keys) {
       _nodeToElement[kernel.localFunctions[localFunction]] = localFunction;
     }
     _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;
 
   GlobalTypeInferenceElementResult _resultOf(Element e) =>
       _compiler.globalInference.results.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
@@ skipping 40 matching lines @@
     // If this is a synthetic local, return the synthetic local
     if (variable.name == null) {
       return _syntheticLocals.putIfAbsent(
           variable, () => new SyntheticLocal("x", null));
     }
     return getElement(variable) as LocalElement;
   }
 
   bool getCanThrow(ir.Node procedure) {
     FunctionElement function = getElement(procedure);
-    return !_compiler.closedWorld.getCannotThrow(function);
+    return !_closedWorld.getCannotThrow(function);
   }
 
   TypeMask returnTypeOf(ir.Member node) {
     return TypeMaskFactory.inferredReturnTypeForElement(
         getElement(node), _compiler);
   }
 
   SideEffects getSideEffects(ir.Node node) {
-    return _compiler.closedWorld.getSideEffectsOfElement(getElement(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);
   }
 
   FunctionSignature getFunctionSignature(ir.FunctionNode function) {
     return getElement(function).asFunctionElement().functionSignature;
@@ skipping 57 matching lines @@
       return _compiler.closedWorld.commonMasks.dynamicType;
     }
     return _resultOf(_target).typeOfSend(getNode(send));
   }
 
   TypeMask typeOfGet(ir.PropertyGet getter) {
     return _resultOf(_target).typeOfSend(getNode(getter));
   }
 
   TypeMask typeOfSet(ir.PropertySet setter) {
-    return _compiler.closedWorld.commonMasks.dynamicType;
+    return _closedWorld.commonMasks.dynamicType;
   }
 
   TypeMask typeOfSend(ir.Expression send) {
     assert(send is ir.InvocationExpression || send is ir.PropertyGet);
     return _resultOf(_target).typeOfSend(getNode(send));
   }
 
   TypeMask typeOfListLiteral(Element owner, ir.ListLiteral listLiteral) {
     ast.Node node = getNodeOrNull(listLiteral);
     if (node == null) {
       assertNodeIsSynthetic(listLiteral);
-      return _compiler.closedWorld.commonMasks.growableListType;
+      return _closedWorld.commonMasks.growableListType;
     }
     return _resultOf(owner).typeOfNewList(getNode(listLiteral)) ??
-        _compiler.closedWorld.commonMasks.dynamicType;
+        _closedWorld.commonMasks.dynamicType;
   }
 
   TypeMask typeOfIterator(ir.ForInStatement forInStatement) {
     return _resultOf(_target).typeOfIterator(getNode(forInStatement));
   }
 
   TypeMask typeOfIteratorCurrent(ir.ForInStatement forInStatement) {
     return _resultOf(_target).typeOfIteratorCurrent(getNode(forInStatement));
   }
 
   TypeMask typeOfIteratorMoveNext(ir.ForInStatement forInStatement) {
     return _resultOf(_target).typeOfIteratorMoveNext(getNode(forInStatement));
   }
 
   bool isJsIndexableIterator(ir.ForInStatement forInStatement) {
     TypeMask mask = typeOfIterator(forInStatement);
-    ClosedWorld closedWorld = _compiler.closedWorld;
     return mask != null &&
-        mask.satisfies(_backend.helpers.jsIndexableClass, closedWorld) &&
+        mask.satisfies(_backend.helpers.jsIndexableClass, _closedWorld) &&
         // String is indexable but not iterable.
-        !mask.satisfies(_backend.helpers.jsStringClass, closedWorld);
+        !mask.satisfies(_backend.helpers.jsStringClass, _closedWorld);
   }
 
   bool isFixedLength(TypeMask mask) {
-    ClosedWorld closedWorld = _compiler.closedWorld;
     JavaScriptBackend backend = _compiler.backend;
     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(backend.helpers.jsFixedArrayClass) ||
-        mask.containsOnly(backend.helpers.jsUnmodifiableArrayClass) ||
-        mask.containsOnlyString(closedWorld) ||
+    if (mask.containsOnly(
+            _closedWorld.backendClasses.fixedListImplementation) ||
+        mask.containsOnly(
+            _closedWorld.backendClasses.constListImplementation) ||
+        mask.containsOnlyString(_closedWorld) ||
         backend.isTypedArray(mask)) {
       return true;
     }
     return false;
   }
 
   TypeMask inferredIndexType(ir.ForInStatement forInStatement) {
     return TypeMaskFactory.inferredTypeForSelector(
         new Selector.index(), typeOfIterator(forInStatement), _compiler);
   }
@@ skipping 566 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);
   }
 }