Even less reliance on Compiler.closedWorld

pkg/compiler/lib/src/ssa/nodes.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 '../closure.dart';
 import '../common.dart';
 import '../common/backend_api.dart' show BackendClasses;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 1103 matching lines @@
         isBooleanOrNull(closedWorld) ||
         isNull();
   }
 
   /**
    * Type of the instruction.
    */
   TypeMask instructionType;
 
   Selector get selector => null;
-  HInstruction getDartReceiver(Compiler compiler) => null;
+  HInstruction getDartReceiver(ClosedWorld closedWorld) => null;
   bool onlyThrowsNSM() => false;
 
   bool isInBasicBlock() => block != null;
 
   bool gvnEquals(HInstruction other) {
     assert(useGvn() && other.useGvn());
     // Check that the type and the sideEffects match.
     bool hasSameType = typeEquals(other);
     assert(hasSameType == (typeCode() == other.typeCode()));
     if (!hasSameType) return false;
@@ skipping 162 matching lines @@
   bool isConstantBoolean() => false;
   bool isConstantNull() => false;
   bool isConstantNumber() => false;
   bool isConstantInteger() => false;
   bool isConstantString() => false;
   bool isConstantList() => false;
   bool isConstantMap() => false;
   bool isConstantFalse() => false;
   bool isConstantTrue() => false;
 
-  bool isInterceptor(Compiler compiler) => false;
+  bool isInterceptor(ClosedWorld closedWorld) => false;
 
   bool isValid() {
     HValidator validator = new HValidator();
     validator.currentBlock = block;
     validator.visitInstruction(this);
     return validator.isValid;
   }
 
   bool isCodeMotionInvariant() => false;
 
@@ skipping 219 matching lines @@
   HInvokeDynamic(Selector selector, this.mask, this.element,
       List<HInstruction> inputs, TypeMask type,
       [bool isIntercepted = false])
       : super(inputs, type),
         this.selector = selector,
         specializer = isIntercepted
             ? InvokeDynamicSpecializer.lookupSpecializer(selector)
             : const InvokeDynamicSpecializer();
   toString() => 'invoke dynamic: selector=$selector, mask=$mask';
   HInstruction get receiver => inputs[0];
-  HInstruction getDartReceiver(Compiler compiler) {
-    return isCallOnInterceptor(compiler) ? inputs[1] : inputs[0];
+  HInstruction getDartReceiver(ClosedWorld closedWorld) {
+    return isCallOnInterceptor(closedWorld) ? inputs[1] : inputs[0];
   }
 
   /**
    * Returns whether this call is on an interceptor object.
    */
-  bool isCallOnInterceptor(Compiler compiler) {
-    return isInterceptedCall && receiver.isInterceptor(compiler);
+  bool isCallOnInterceptor(ClosedWorld closedWorld) {
+    return isInterceptedCall && receiver.isInterceptor(closedWorld);
   }
 
   int typeCode() => HInstruction.INVOKE_DYNAMIC_TYPECODE;
   bool typeEquals(other) => other is HInvokeDynamic;
   bool dataEquals(HInvokeDynamic other) {
     // Use the name and the kind instead of [Selector.operator==]
     // because we don't need to check the arity (already checked in
     // [gvnEquals]), and the receiver types may not be in sync.
     return selector.name == other.selector.name &&
         selector.kind == other.selector.kind;
@@ skipping 76 matching lines @@
   final Selector selector;
 
   HInvokeSuper(MemberEntity element, this.caller, this.selector, inputs, type,
       SourceInformation sourceInformation,
       {this.isSetter})
       : super(element, inputs, type) {
     this.sourceInformation = sourceInformation;
   }
 
   HInstruction get receiver => inputs[0];
-  HInstruction getDartReceiver(Compiler compiler) {
-    return isCallOnInterceptor(compiler) ? inputs[1] : inputs[0];
+  HInstruction getDartReceiver(ClosedWorld closedWorld) {
+    return isCallOnInterceptor(closedWorld) ? inputs[1] : inputs[0];
   }
 
   /**
    * Returns whether this call is on an interceptor object.
    */
-  bool isCallOnInterceptor(Compiler compiler) {
-    return isInterceptedCall && receiver.isInterceptor(compiler);
+  bool isCallOnInterceptor(ClosedWorld closedWorld) {
+    return isInterceptedCall && receiver.isInterceptor(closedWorld);
   }
 
   toString() => 'invoke super: $element';
   accept(HVisitor visitor) => visitor.visitInvokeSuper(this);
 
   HInstruction get value {
     assert(isSetter);
     // The 'inputs' are [receiver, value] or [interceptor, receiver, value].
     return inputs.last;
   }
@@ skipping 29 matching lines @@
             (isAssignable != null) ? isAssignable : element.isAssignable,
         super(element, <HInstruction>[receiver], type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     setUseGvn();
     if (this.isAssignable) {
       sideEffects.setDependsOnInstancePropertyStore();
     }
   }
 
-  bool isInterceptor(Compiler compiler) {
+  bool isInterceptor(ClosedWorld closedWorld) {
     if (sourceElement == null) return false;
     // In case of a closure inside an interceptor class, [:this:] is
     // stored in the generated closure class, and accessed through a
     // [HFieldGet].
-    JavaScriptBackend backend = compiler.backend;
     if (sourceElement is ThisLocal) {
       ThisLocal thisLocal = sourceElement;
-      return backend.isInterceptorClass(thisLocal.enclosingClass);
+      return closedWorld.backendClasses
+          .isInterceptorClass(thisLocal.enclosingClass);
     }
     return false;
   }
 
   bool canThrow() => receiver.canBeNull();
 
-  HInstruction getDartReceiver(Compiler compiler) => receiver;
+  HInstruction getDartReceiver(ClosedWorld closedWorld) => receiver;
   bool onlyThrowsNSM() => true;
   bool get isNullCheck => element == null;
 
   accept(HVisitor visitor) => visitor.visitFieldGet(this);
 
   int typeCode() => HInstruction.FIELD_GET_TYPECODE;
   bool typeEquals(other) => other is HFieldGet;
   bool dataEquals(HFieldGet other) => element == other.element;
   String toString() => "FieldGet $element";
 }
 
 class HFieldSet extends HFieldAccess {
   HFieldSet(MemberEntity element, HInstruction receiver, HInstruction value)
       : super(element, <HInstruction>[receiver, value],
             const TypeMask.nonNullEmpty()) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     sideEffects.setChangesInstanceProperty();
   }
 
   bool canThrow() => receiver.canBeNull();
 
-  HInstruction getDartReceiver(Compiler compiler) => receiver;
+  HInstruction getDartReceiver(ClosedWorld closedWorld) => receiver;
   bool onlyThrowsNSM() => true;
 
   HInstruction get value => inputs[1];
   accept(HVisitor visitor) => visitor.visitFieldSet(this);
 
   bool isJsStatement() => true;
   String toString() => "FieldSet $element";
 }
 
 /**
@@ skipping 31 matching lines @@
       : this._(element, jsOp, POST_OP, <HInstruction>[receiver], type);
 
   HInstruction get receiver => inputs[0];
 
   bool get isPreOp => opKind == PRE_OP;
   bool get isPostOp => opKind == POST_OP;
   bool get isAssignOp => opKind == ASSIGN_OP;
 
   bool canThrow() => receiver.canBeNull();
 
-  HInstruction getDartReceiver(Compiler compiler) => receiver;
+  HInstruction getDartReceiver(ClosedWorld closedWorld) => receiver;
   bool onlyThrowsNSM() => true;
 
   HInstruction get value => inputs[1];
   accept(HVisitor visitor) => visitor.visitReadModifyWrite(this);
 
   bool isJsStatement() => isAssignOp;
   String toString() => "ReadModifyWrite $jsOp $opKind $element";
 }
 
 abstract class HLocalAccess extends HInstruction {
@@ skipping 436 matching lines @@
   bool isConstantBoolean() => constant.isBool;
   bool isConstantNull() => constant.isNull;
   bool isConstantNumber() => constant.isNum;
   bool isConstantInteger() => constant.isInt;
   bool isConstantString() => constant.isString;
   bool isConstantList() => constant.isList;
   bool isConstantMap() => constant.isMap;
   bool isConstantFalse() => constant.isFalse;
   bool isConstantTrue() => constant.isTrue;
 
-  bool isInterceptor(Compiler compiler) => constant.isInterceptor;
+  bool isInterceptor(ClosedWorld closedWorld) => constant.isInterceptor;
 
   // Maybe avoid this if the literal is big?
   bool isCodeMotionInvariant() => true;
 
   set instructionType(type) {
     // Only lists can be specialized. The SSA builder uses the
     // inferrer for finding the type of a constant list. We should
     // have the constant know its type instead.
     if (!isConstantList()) return;
     super.instructionType = type;
@@ skipping 45 matching lines @@
 
 class HThis extends HParameterValue {
   HThis(ThisLocal element, TypeMask type) : super(element, type);
 
   ThisLocal get sourceElement => super.sourceElement;
 
   accept(HVisitor visitor) => visitor.visitThis(this);
 
   bool isCodeMotionInvariant() => true;
 
-  bool isInterceptor(Compiler compiler) {
-    JavaScriptBackend backend = compiler.backend;
-    return backend.isInterceptorClass(sourceElement.enclosingClass);
+  bool isInterceptor(ClosedWorld closedWorld) {
+    return closedWorld.backendClasses
+        .isInterceptorClass(sourceElement.enclosingClass);
   }
 
   String toString() => 'this';
 }
 
 class HPhi extends HInstruction {
   static const IS_NOT_LOGICAL_OPERATOR = 0;
   static const IS_AND = 1;
   static const IS_OR = 2;
 
@@ skipping 185 matching lines @@
   accept(HVisitor visitor) => visitor.visitInterceptor(this);
   HInstruction get receiver => inputs[0];
 
   bool get isConditionalConstantInterceptor => inputs.length == 2;
   HInstruction get conditionalConstantInterceptor => inputs[1];
   void set conditionalConstantInterceptor(HConstant constant) {
     assert(!isConditionalConstantInterceptor);
     inputs.add(constant);
   }
 
-  bool isInterceptor(Compiler compiler) => true;
+  bool isInterceptor(ClosedWorld closedWorld) => true;
 
   int typeCode() => HInstruction.INTERCEPTOR_TYPECODE;
   bool typeEquals(other) => other is HInterceptor;
   bool dataEquals(HInterceptor other) {
     return interceptedClasses == other.interceptedClasses ||
         (interceptedClasses.length == other.interceptedClasses.length &&
             interceptedClasses.containsAll(other.interceptedClasses));
   }
 }
 
 /**
  * A "one-shot" interceptor is a call to a synthetized method that
  * will fetch the interceptor of its first parameter, and make a call
  * on a given selector with the remaining parameters.
  *
  * In order to share the same optimizations with regular interceptor
  * calls, this class extends [HInvokeDynamic] and also has the null
  * constant as the first input.
  */
 class HOneShotInterceptor extends HInvokeDynamic {
   Set<ClassEntity> interceptedClasses;
   HOneShotInterceptor(Selector selector, TypeMask mask,
       List<HInstruction> inputs, TypeMask type, this.interceptedClasses)
       : super(selector, mask, null, inputs, type, true) {
     assert(inputs[0] is HConstant);
     assert(inputs[0].isNull());
   }
-  bool isCallOnInterceptor(Compiler compiler) => true;
+  bool isCallOnInterceptor(ClosedWorld closedWorld) => true;
 
   String toString() => 'one shot interceptor: selector=$selector, mask=$mask';
   accept(HVisitor visitor) => visitor.visitOneShotInterceptor(this);
 }
 
 /** An [HLazyStatic] is a static that is initialized lazily at first read. */
 class HLazyStatic extends HInstruction {
   final FieldEntity element;
   HLazyStatic(this.element, type) : super(<HInstruction>[], type) {
     // TODO(4931): The first access has side-effects, but we afterwards we
@@ skipping 54 matching lines @@
   String toString() => 'index operator';
   accept(HVisitor visitor) => visitor.visitIndex(this);
 
   HInstruction get receiver => inputs[0];
   HInstruction get index => inputs[1];
 
   // Implicit dependency on HBoundsCheck or constraints on index.
   // TODO(27272): Make HIndex dependent on bounds checking.
   bool get isMovable => false;
 
-  HInstruction getDartReceiver(Compiler compiler) => receiver;
+  HInstruction getDartReceiver(ClosedWorld closedWorld) => receiver;
   bool onlyThrowsNSM() => true;
   bool canThrow() => receiver.canBeNull();
 
   int typeCode() => HInstruction.INDEX_TYPECODE;
   bool typeEquals(HInstruction other) => other is HIndex;
   bool dataEquals(HIndex other) => true;
 }
 
 /**
  * The primitive array assignment operation. Note that this instruction
@@ skipping 13 matching lines @@
   accept(HVisitor visitor) => visitor.visitIndexAssign(this);
 
   HInstruction get receiver => inputs[0];
   HInstruction get index => inputs[1];
   HInstruction get value => inputs[2];
 
   // Implicit dependency on HBoundsCheck or constraints on index.
   // TODO(27272): Make HIndex dependent on bounds checking.
   bool get isMovable => false;
 
-  HInstruction getDartReceiver(Compiler compiler) => receiver;
+  HInstruction getDartReceiver(ClosedWorld closedWorld) => receiver;
   bool onlyThrowsNSM() => true;
   bool canThrow() => receiver.canBeNull();
 }
 
 class HIs extends HInstruction {
   /// A check against a raw type: 'o is int', 'o is A'.
   static const int RAW_CHECK = 0;
 
   /// A check against a type with type arguments: 'o is List<int>', 'o is C<T>'.
   static const int COMPOUND_CHECK = 1;
@@ skipping 768 matching lines @@
 class HDynamicType extends HRuntimeType {
   HDynamicType(DynamicType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitDynamicType(this);
 
   int typeCode() => HInstruction.DYNAMIC_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HDynamicType;
 }