Reduce use of Compiler.closedWorld

pkg/compiler/lib/src/ssa/codegen.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:math' as math;
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
@@ skipping 161 matching lines @@
         parameters = <js.Parameter>[],
         expressionStack = <js.Expression>[],
         oldContainerStack = <js.Block>[],
         generateAtUseSite = new Set<HInstruction>(),
         controlFlowOperators = new Set<HInstruction>(),
         breakAction = new Map<Entity, EntityAction>(),
         continueAction = new Map<Entity, EntityAction>();
 
   Compiler get compiler => backend.compiler;
 
+  ClosedWorld get closedWorld => compiler.closedWorld;
+
   NativeEmitter get nativeEmitter => backend.emitter.nativeEmitter;
 
   CodegenRegistry get registry => work.registry;
 
   BackendHelpers get helpers => backend.helpers;
 
   native.NativeEnqueuer get nativeEnqueuer {
     return compiler.enqueuer.codegen.nativeEnqueuer;
   }
 
@@ skipping 62 matching lines @@
       return math.max(leftWidth - shiftCount, 0);
     }
     if (instruction is HAdd) {
       return math.min(
           1 + math.max(bitWidth(instruction.left), bitWidth(instruction.right)),
           MAX);
     }
     return MAX;
   }
 
-  bool requiresUintConversion(instruction) {
-    if (instruction.isUInt31(compiler)) return false;
+  bool requiresUintConversion(HInstruction instruction) {
+    if (instruction.isUInt31(closedWorld)) return false;
     if (bitWidth(instruction) <= 31) return false;
     // If the result of a bit-operation is only used by other bit
     // operations, we do not have to convert to an unsigned integer.
     return hasNonBitOpUser(instruction, new Set<HPhi>());
   }
 
   /**
    * If the [instruction] is not `null` it will be used to attach the position
    * to the [statement].
    */
@@ skipping 1098 matching lines @@
   visitMultiply(HMultiply node) => visitInvokeBinary(node, '*');
   visitSubtract(HSubtract node) => visitInvokeBinary(node, '-');
   visitBitAnd(HBitAnd node) => visitBitInvokeBinary(node, '&');
   visitBitNot(HBitNot node) => visitBitInvokeUnary(node, '~');
   visitBitOr(HBitOr node) => visitBitInvokeBinary(node, '|');
   visitBitXor(HBitXor node) => visitBitInvokeBinary(node, '^');
   visitShiftLeft(HShiftLeft node) => visitBitInvokeBinary(node, '<<');
   visitShiftRight(HShiftRight node) => visitBitInvokeBinary(node, '>>>');
 
   visitTruncatingDivide(HTruncatingDivide node) {
-    assert(node.isUInt31(compiler));
+    assert(node.isUInt31(closedWorld));
     // TODO(karlklose): Enable this assertion again when type propagation is
     // fixed. Issue 23555.
 //    assert(node.left.isUInt32(compiler));
-    assert(node.right.isPositiveInteger(compiler));
+    assert(node.right.isPositiveInteger(closedWorld));
     use(node.left);
     js.Expression jsLeft = pop();
     use(node.right);
     push(new js.Binary('/', jsLeft, pop())
         .withSourceInformation(node.sourceInformation));
     push(new js.Binary('|', pop(), new js.LiteralNumber("0"))
         .withSourceInformation(node.sourceInformation));
   }
 
   visitNegate(HNegate node) => visitInvokeUnary(node, '-');
@@ skipping 303 matching lines @@
   }
 
   TypeMask getOptimizedSelectorFor(
       HInvokeDynamic node, Selector selector, TypeMask mask) {
     if (node.element != null) {
       // Create an artificial type mask to make sure only
       // [node.element] will be enqueued. We're not using the receiver
       // type because our optimizations might end up in a state where the
       // invoke dynamic knows more than the receiver.
       ClassElement enclosing = node.element.enclosingClass;
-      if (compiler.closedWorld.isInstantiated(enclosing)) {
-        return new TypeMask.nonNullExact(
-            enclosing.declaration, compiler.closedWorld);
+      if (closedWorld.isInstantiated(enclosing)) {
+        return new TypeMask.nonNullExact(enclosing.declaration, closedWorld);
       } else {
         // The element is mixed in so a non-null subtype mask is the most
         // precise we have.
-        assert(invariant(node, compiler.closedWorld.isUsedAsMixin(enclosing),
+        assert(invariant(node, closedWorld.isUsedAsMixin(enclosing),
             message: "Element ${node.element} from $enclosing expected "
                 "to be mixed in."));
-        return new TypeMask.nonNullSubtype(
-            enclosing.declaration, compiler.closedWorld);
+        return new TypeMask.nonNullSubtype(enclosing.declaration, closedWorld);
       }
     }
     // If [JSInvocationMirror._invokeOn] is enabled, and this call
     // might hit a `noSuchMethod`, we register an untyped selector.
-    return compiler.closedWorld.extendMaskIfReachesAll(selector, mask);
+    return closedWorld.extendMaskIfReachesAll(selector, mask);
   }
 
   void registerMethodInvoke(HInvokeDynamic node) {
     Selector selector = node.selector;
 
     // If we don't know what we're calling or if we are calling a getter,
     // we need to register that fact that we may be calling a closure
     // with the same arguments.
     MemberElement target = node.element;
     if (target == null || target.isGetter) {
@@ skipping 353 matching lines @@
   }
 
   void generateNot(HInstruction input, SourceInformation sourceInformation) {
     bool canGenerateOptimizedComparison(HInstruction instruction) {
       if (instruction is! HRelational) return false;
 
       HRelational relational = instruction;
 
       HInstruction left = relational.left;
       HInstruction right = relational.right;
-      if (left.isStringOrNull(compiler) && right.isStringOrNull(compiler)) {
+      if (left.isStringOrNull(closedWorld) &&
+          right.isStringOrNull(closedWorld)) {
         return true;
       }
 
       // This optimization doesn't work for NaN, so we only do it if the
       // type is known to be an integer.
-      return left.isInteger(compiler) && right.isInteger(compiler);
+      return left.isInteger(closedWorld) && right.isInteger(closedWorld);
     }
 
     bool handledBySpecialCase = false;
     if (isGenerateAtUseSite(input)) {
       handledBySpecialCase = true;
       if (input is HIs) {
         emitIs(input, '!==', sourceInformation);
       } else if (input is HIsViaInterceptor) {
         emitIsViaInterceptor(input, sourceInformation, negative: true);
       } else if (input is HNot) {
@@ skipping 115 matching lines @@
     // e.g., the zero checks can be shared if possible.
 
     // If the checks always succeeds, we would have removed the bounds check
     // completely.
     assert(node.staticChecks != HBoundsCheck.ALWAYS_TRUE);
     if (node.staticChecks != HBoundsCheck.ALWAYS_FALSE) {
       js.Expression under;
       js.Expression over;
       if (node.staticChecks != HBoundsCheck.ALWAYS_ABOVE_ZERO) {
         use(node.index);
-        if (node.index.isInteger(compiler)) {
+        if (node.index.isInteger(closedWorld)) {
           under = js.js("# < 0", pop());
         } else {
           js.Expression jsIndex = pop();
           under = js.js("# >>> 0 !== #", [jsIndex, jsIndex]);
         }
-      } else if (!node.index.isInteger(compiler)) {
+      } else if (!node.index.isInteger(closedWorld)) {
         checkInt(node.index, '!==');
         under = pop();
       }
       if (node.staticChecks != HBoundsCheck.ALWAYS_BELOW_LENGTH) {
         var index = node.index;
         use(index);
         js.Expression jsIndex = pop();
         use(node.length);
         over = new js.Binary(">=", jsIndex, pop());
       }
@@ skipping 109 matching lines @@
   void visitStringConcat(HStringConcat node) {
     use(node.left);
     js.Expression jsLeft = pop();
     use(node.right);
     push(new js.Binary('+', jsLeft, pop())
         .withSourceInformation(node.sourceInformation));
   }
 
   void visitStringify(HStringify node) {
     HInstruction input = node.inputs.first;
-    if (input.isString(compiler)) {
+    if (input.isString(closedWorld)) {
       use(input);
-    } else if (input.isInteger(compiler) || input.isBoolean(compiler)) {
+    } else if (input.isInteger(closedWorld) || input.isBoolean(closedWorld)) {
       // JavaScript's + operator with a string for the left operand will convert
       // the right operand to a string, and the conversion result is correct.
       use(input);
       if (node.usedBy.length == 1 &&
           node.usedBy[0] is HStringConcat &&
           node.usedBy[0].inputs[1] == node) {
         // The context is already <string> + value.
       } else {
         // Force an empty string for the first operand.
         push(new js.Binary('+', js.string(""), pop())
@@ skipping 362 matching lines @@
       } else if (Elements.isStringOnlySupertype(element, compiler)) {
         handleStringSupertypeCheck(input, interceptor, type, sourceInformation,
             negative: negative);
       } else if (identical(element, coreClasses.listClass) ||
           Elements.isListSupertype(element, compiler)) {
         handleListOrSupertypeCheck(input, interceptor, type, sourceInformation,
             negative: negative);
       } else if (type.isFunctionType) {
         checkType(input, interceptor, type, sourceInformation,
             negative: negative);
-      } else if ((input.canBePrimitive(compiler) &&
-              !input.canBePrimitiveArray(compiler)) ||
+      } else if ((input.canBePrimitive(closedWorld) &&
+              !input.canBePrimitiveArray(closedWorld)) ||
           input.canBeNull()) {
         checkObject(input, relation, node.sourceInformation);
         js.Expression objectTest = pop();
         checkType(input, interceptor, type, sourceInformation,
             negative: negative);
         push(new js.Binary(negative ? '||' : '&&', objectTest, pop())
             .withSourceInformation(sourceInformation));
       } else {
         checkType(input, interceptor, type, sourceInformation,
             negative: negative);
       }
     }
   }
 
   void emitIsViaInterceptor(
       HIsViaInterceptor node, SourceInformation sourceInformation,
       {bool negative: false}) {
     checkTypeViaProperty(
         node.interceptor, node.typeExpression, sourceInformation,
         negative: negative);
   }
 
   js.Expression generateReceiverOrArgumentTypeTest(
       HInstruction input, TypeMask checkedType) {
-    ClosedWorld closedWorld = compiler.closedWorld;
     TypeMask inputType = input.instructionType;
     // Figure out if it is beneficial to turn this into a null check.
     // V8 generally prefers 'typeof' checks, but for integers and
     // indexable primitives we cannot compile this test into a single
     // typeof check so the null check is cheaper.
     bool isIntCheck = checkedType.containsOnlyInt(closedWorld);
-    bool turnIntoNumCheck = isIntCheck && input.isIntegerOrNull(compiler);
+    bool turnIntoNumCheck = isIntCheck && input.isIntegerOrNull(closedWorld);
     bool turnIntoNullCheck = !turnIntoNumCheck &&
         (checkedType.nullable() == inputType) &&
         (isIntCheck ||
             checkedType.satisfies(helpers.jsIndexableClass, closedWorld));
 
     if (turnIntoNullCheck) {
       use(input);
       return new js.Binary("==", pop(), new js.LiteralNull())
           .withSourceInformation(input.sourceInformation);
     } else if (isIntCheck && !turnIntoNumCheck) {
@@ skipping 12 matching lines @@
       // input is !string
       checkString(input, '!==', input.sourceInformation);
       return pop();
     }
     reporter.internalError(input, 'Unexpected check: $checkedType.');
     return null;
   }
 
   void visitTypeConversion(HTypeConversion node) {
     if (node.isArgumentTypeCheck || node.isReceiverTypeCheck) {
-      ClosedWorld closedWorld = compiler.closedWorld;
       // An int check if the input is not int or null, is not
       // sufficient for doing an argument or receiver check.
       assert(compiler.options.trustTypeAnnotations ||
           !node.checkedType.containsOnlyInt(closedWorld) ||
-          node.checkedInput.isIntegerOrNull(compiler));
+          node.checkedInput.isIntegerOrNull(closedWorld));
       js.Expression test = generateReceiverOrArgumentTypeTest(
           node.checkedInput, node.checkedType);
       js.Block oldContainer = currentContainer;
       js.Statement body = new js.Block.empty();
       currentContainer = body;
       if (node.isArgumentTypeCheck) {
         generateThrowWithHelper(
             helpers.throwIllegalArgumentException, node.checkedInput,
             sourceInformation: node.sourceInformation);
       } else if (node.isReceiverTypeCheck) {
@@ skipping 157 matching lines @@
             node.dartType == (node.dartType.element as ClassElement).thisType);
         registry.registerInstantiatedClass(coreClasses.listClass);
         push(new js.ArrayInitializer(arguments)
             .withSourceInformation(node.sourceInformation));
     }
   }
 
   bool typeVariableAccessNeedsSubstitution(
       TypeVariableElement element, TypeMask receiverMask) {
     ClassElement cls = element.enclosingClass;
-    ClosedWorld closedWorld = compiler.closedWorld;
 
     // See if the receiver type narrows the set of classes to ones that can be
     // indexed.
     // TODO(sra): Currently the only convenient query is [singleClass]. We
     // should iterate over all the concrete classes in [receiverMask].
     ClassElement receiverClass = receiverMask.singleClass(closedWorld);
     if (receiverClass != null) {
       if (backend.rti.isTrivialSubstitution(receiverClass, cls)) {
         return false;
       }
@@ skipping 72 matching lines @@
     registry.registerStaticUse(new StaticUse.staticInvoke(
         helper, new CallStructure.unnamed(argumentCount)));
     return backend.emitter.staticFunctionAccess(helper);
   }
 
   @override
   void visitRef(HRef node) {
     visit(node.value);
   }
 }