Split TypedSelector into Selector and TypeMask.

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.
 
 part of ssa;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitAwait(HAwait node);
   R visitBitAnd(HBitAnd node);
@@ skipping 1375 matching lines @@
   static const int ARGUMENTS_OFFSET = 1;
   bool canThrow() => true;
 
   /**
    * Returns whether this call is on an intercepted method.
    */
   bool get isInterceptedCall {
     // We know it's a selector call if it follows the interceptor
     // calling convention, which adds the actual receiver as a
     // parameter to the call.
-    return (selector != null) && (inputs.length - 2 == selector.argumentCount);
+    return (selector != null) &&
+           (inputs.length - 2 == selector.argumentCount);
   }
 }
 
 abstract class HInvokeDynamic extends HInvoke {
   final InvokeDynamicSpecializer specializer;
   Selector selector;
+  TypeMask mask;
   Element element;
 
   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';
+  toString() => 'invoke dynamic: selector=$selector, mask=$mask';
   HInstruction get receiver => inputs[0];
   HInstruction getDartReceiver(Compiler compiler) {
     return isCallOnInterceptor(compiler) ? inputs[1] : inputs[0];
   }
 
   /**
    * Returns whether this call is on an interceptor object.
    */
   bool isCallOnInterceptor(Compiler compiler) {
     return isInterceptedCall && receiver.isInterceptor(compiler);
   }
 
   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;
   }
 }
 
 class HInvokeClosure extends HInvokeDynamic {
-  HInvokeClosure(Selector selector, List<HInstruction> inputs, TypeMask type)
-    : super(selector, null, inputs, type) {
+  HInvokeClosure(Selector selector,
+                 List<HInstruction> inputs,
+                 TypeMask type)
+      : super(selector, null, null, inputs, type) {
     assert(selector.isClosureCall);
   }
   accept(HVisitor visitor) => visitor.visitInvokeClosure(this);
 }
 
 class HInvokeDynamicMethod extends HInvokeDynamic {
   HInvokeDynamicMethod(Selector selector,
+                       TypeMask mask,
                        List<HInstruction> inputs,
                        TypeMask type,
                        [bool isIntercepted = false])
-    : super(selector, null, inputs, type, isIntercepted);
+    : super(selector, mask, null, inputs, type, isIntercepted);
 
-  String toString() => 'invoke dynamic method: $selector';
+  String toString() => 'invoke dynamic method: selector=$selector, mask=$mask';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicMethod(this);
 }
 
 abstract class HInvokeDynamicField extends HInvokeDynamic {
   HInvokeDynamicField(
-      Selector selector, Element element, List<HInstruction> inputs,
+      Selector selector, TypeMask mask,
+      Element element, List<HInstruction> inputs,
       TypeMask type)
-      : super(selector, element, inputs, type);
-  toString() => 'invoke dynamic field: $selector';
+      : super(selector, mask, element, inputs, type);
+  toString() => 'invoke dynamic field: selector=$selector, mask=$mask';
 }
 
 class HInvokeDynamicGetter extends HInvokeDynamicField {
-  HInvokeDynamicGetter(selector, element, inputs, type)
-    : super(selector, element, inputs, type);
-  toString() => 'invoke dynamic getter: $selector';
+  HInvokeDynamicGetter(Selector selector, TypeMask mask,
+      Element element, List<HInstruction> inputs, TypeMask type)
+    : super(selector, mask, element, inputs, type);
+  toString() => 'invoke dynamic getter: selector=$selector, mask=$mask';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicGetter(this);
 }
 
 class HInvokeDynamicSetter extends HInvokeDynamicField {
-  HInvokeDynamicSetter(selector, element, inputs, type)
-    : super(selector, element, inputs, type);
-  toString() => 'invoke dynamic setter: $selector';
+  HInvokeDynamicSetter(Selector selector, TypeMask mask,
+      Element element, List<HInstruction> inputs, TypeMask type)
+    : super(selector, mask, element, inputs, type);
+  toString() => 'invoke dynamic setter: selector=$selector, mask=$mask';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicSetter(this);
 }
 
 class HInvokeStatic extends HInvoke {
   final Element element;
 
   final bool targetCanThrow;
 
   bool canThrow() => targetCanThrow;
 
@@ skipping 298 matching lines @@
               [this.instantiatedTypes])
       : super(type, inputs);
 
   accept(HVisitor visitor) => visitor.visitForeignNew(this);
 
   bool get isAllocation => true;
 }
 
 abstract class HInvokeBinary extends HInstruction {
   final Selector selector;
-  HInvokeBinary(HInstruction left, HInstruction right, this.selector, type)
+  HInvokeBinary(
+      HInstruction left, HInstruction right, this.selector, TypeMask type)
       : super(<HInstruction>[left, right], type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     setUseGvn();
   }
 
   HInstruction get left => inputs[0];
   HInstruction get right => inputs[1];
 
   BinaryOperation operation(ConstantSystem constantSystem);
 }
 
 abstract class HBinaryArithmetic extends HInvokeBinary {
-  HBinaryArithmetic(left, right, selector, type)
+  HBinaryArithmetic(
+      HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   BinaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HAdd extends HBinaryArithmetic {
-  HAdd(left, right, selector, type) : super(left, right, selector, type);
+  HAdd(HInstruction left, HInstruction right, Selector selector, TypeMask type)
+      : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitAdd(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.add;
   int typeCode() => HInstruction.ADD_TYPECODE;
   bool typeEquals(other) => other is HAdd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HDivide extends HBinaryArithmetic {
-  HDivide(left, right, selector, type) : super(left, right, selector, type);
+  HDivide(
+      HInstruction left, HInstruction right, Selector selector, TypeMask type)
+      : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitDivide(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.divide;
   int typeCode() => HInstruction.DIVIDE_TYPECODE;
   bool typeEquals(other) => other is HDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HMultiply extends HBinaryArithmetic {
-  HMultiply(left, right, selector, type) : super(left, right, selector, type);
+  HMultiply(
+      HInstruction left, HInstruction right, Selector selector, TypeMask type)
+      : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitMultiply(this);
 
   BinaryOperation operation(ConstantSystem operations)
       => operations.multiply;
   int typeCode() => HInstruction.MULTIPLY_TYPECODE;
   bool typeEquals(other) => other is HMultiply;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HSubtract extends HBinaryArithmetic {
-  HSubtract(left, right, selector, type) : super(left, right, selector, type);
+  HSubtract(
+      HInstruction left, HInstruction right, Selector selector, TypeMask type)
+      : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitSubtract(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.subtract;
   int typeCode() => HInstruction.SUBTRACT_TYPECODE;
   bool typeEquals(other) => other is HSubtract;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HTruncatingDivide extends HBinaryArithmetic {
-  HTruncatingDivide(left, right, selector, type)
+  HTruncatingDivide(
+      HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitTruncatingDivide(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.truncatingDivide;
   int typeCode() => HInstruction.TRUNCATING_DIVIDE_TYPECODE;
   bool typeEquals(other) => other is HTruncatingDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
@@ skipping 14 matching lines @@
    * following join-block.
    */
   HBasicBlock get defaultTarget => block.successors.last;
 
   accept(HVisitor visitor) => visitor.visitSwitch(this);
 
   String toString() => "HSwitch cases = $inputs";
 }
 
 abstract class HBinaryBitOp extends HInvokeBinary {
-  HBinaryBitOp(left, right, selector, type)
+  HBinaryBitOp(
+      HInstruction left, HInstruction right, Selector selector, TypeMask type)
       : super(left, right, selector, type);
 }
 
 class HShiftLeft extends HBinaryBitOp {
-  HShiftLeft(left, right, selector, type) : super(left, right, selector, type);
+  HShiftLeft(
+      HInstruction left, HInstruction right, Selector selector, TypeMask type)
+      : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitShiftLeft(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.shiftLeft;
   int typeCode() => HInstruction.SHIFT_LEFT_TYPECODE;
   bool typeEquals(other) => other is HShiftLeft;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HShiftRight extends HBinaryBitOp {
-  HShiftRight(left, right, selector, type) : super(left, right, selector, type);
+  HShiftRight(
+      HInstruction left, HInstruction right, Selector selector, TypeMask type)
+      : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitShiftRight(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.shiftRight;
   int typeCode() => HInstruction.SHIFT_RIGHT_TYPECODE;
   bool typeEquals(other) => other is HShiftRight;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitOr extends HBinaryBitOp {
-  HBitOr(left, right, selector, type) : super(left, right, selector, type);
+  HBitOr(
+      HInstruction left, HInstruction right, Selector selector, TypeMask type)
+      : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitBitOr(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.bitOr;
   int typeCode() => HInstruction.BIT_OR_TYPECODE;
   bool typeEquals(other) => other is HBitOr;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitAnd extends HBinaryBitOp {
-  HBitAnd(left, right, selector, type) : super(left, right, selector, type);
+  HBitAnd(
+      HInstruction left, HInstruction right, Selector selector, TypeMask type)
+      : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitBitAnd(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.bitAnd;
   int typeCode() => HInstruction.BIT_AND_TYPECODE;
   bool typeEquals(other) => other is HBitAnd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitXor extends HBinaryBitOp {
-  HBitXor(left, right, selector, type) : super(left, right, selector, type);
+  HBitXor(
+      HInstruction left, HInstruction right, Selector selector, TypeMask type)
+      : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitBitXor(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.bitXor;
   int typeCode() => HInstruction.BIT_XOR_TYPECODE;
   bool typeEquals(other) => other is HBitXor;
   bool dataEquals(HInstruction other) => true;
 }
 
 abstract class HInvokeUnary extends HInstruction {
   final Selector selector;
   HInvokeUnary(HInstruction input, this.selector, type)
       : super(<HInstruction>[input], type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     setUseGvn();
   }
 
   HInstruction get operand => inputs[0];
 
   UnaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HNegate extends HInvokeUnary {
-  HNegate(input, selector, type) : super(input, selector, type);
+  HNegate(HInstruction input, Selector selector, TypeMask type)
+      : super(input, selector, type);
   accept(HVisitor visitor) => visitor.visitNegate(this);
 
   UnaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.negate;
   int typeCode() => HInstruction.NEGATE_TYPECODE;
   bool typeEquals(other) => other is HNegate;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitNot extends HInvokeUnary {
-  HBitNot(input, selector, type) : super(input, selector, type);
+  HBitNot(HInstruction input, Selector selector, TypeMask type)
+      : super(input, selector, type);
   accept(HVisitor visitor) => visitor.visitBitNot(this);
 
   UnaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.bitNot;
   int typeCode() => HInstruction.BIT_NOT_TYPECODE;
   bool typeEquals(other) => other is HBitNot;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HExit extends HControlFlow {
@@ skipping 382 matching lines @@
  * 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<ClassElement> interceptedClasses;
   HOneShotInterceptor(Selector selector,
+                      TypeMask mask,
                       List<HInstruction> inputs,
                       TypeMask type,
                       this.interceptedClasses)
-      : super(selector, null, inputs, type, true) {
+      : super(selector, mask, null, inputs, type, true) {
     assert(inputs[0] is HConstant);
     assert(inputs[0].isNull());
   }
   bool isCallOnInterceptor(Compiler compiler) => true;
 
-  String toString() => 'one shot interceptor on $selector';
+  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 Element element;
   HLazyStatic(this.element, type) : super(<HInstruction>[], type) {
     // TODO(4931): The first access has side-effects, but we afterwards we
     // should be able to GVN.
     sideEffects.setAllSideEffects();
@@ skipping 33 matching lines @@
 
   bool get isAllocation => true;
 }
 
 /**
  * The primitive array indexing operation. Note that this instruction
  * does not throw because we generate the checks explicitly.
  */
 class HIndex extends HInstruction {
   final Selector selector;
-  HIndex(HInstruction receiver, HInstruction index, this.selector, type)
+  HIndex(HInstruction receiver,
+         HInstruction index,
+         this.selector,
+         TypeMask type)
       : super(<HInstruction>[receiver, index], type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     sideEffects.setDependsOnIndexStore();
     setUseGvn();
   }
 
   String toString() => 'index operator';
   accept(HVisitor visitor) => visitor.visitIndex(this);
 
@@ skipping 725 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;
 }