Add name and library to selectors.

lib/compiler/implementation/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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
@@ skipping 1143 matching lines @@
   bool isControlFlow() => true;
   final bool isStatement = true;
 }
 
 class HInvoke extends HInstruction {
   /**
     * The first argument must be the target: either an [HStatic] node, or
     * the receiver of a method-call. The remaining inputs are the arguments
     * to the invocation.
     */
-  final Selector selector;
-  HInvoke(Selector this.selector, List<HInstruction> inputs) : super(inputs);
+  HInvoke(List<HInstruction> inputs) : super(inputs);
   static final int ARGUMENTS_OFFSET = 1;
 
   // TODO(floitsch): make class abstract instead of adding an abstract method.
   abstract accept(HVisitor visitor);
 }
 
 class HInvokeDynamic extends HInvoke {
+  final Selector selector;
   Element element;
   SourceString name;
-  HInvokeDynamic(
-      Selector selector, this.element, this.name, List<HInstruction> inputs)
-    : super(selector, inputs);
+
+  HInvokeDynamic(this.selector, this.element, this.name,
+                 List<HInstruction> inputs) : super(inputs);
   toString() => 'invoke dynamic: $name';
   HInstruction get receiver() => inputs[0];
 
   // TODO(floitsch): make class abstract instead of adding an abstract method.
   abstract accept(HVisitor visitor);
 }
 
 class HInvokeClosure extends HInvokeDynamic {
   HInvokeClosure(Selector selector, List<HInstruction> inputs)
     : super(selector, null, const SourceString('call'), inputs);
@@ skipping 30 matching lines @@
 
 class HInvokeDynamicSetter extends HInvokeDynamicField {
   HInvokeDynamicSetter(selector, element, name, receiver, value)
     : super(selector, element, name, [receiver, value]);
   toString() => 'invoke dynamic setter: $name';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicSetter(this);
 }
 
 class HInvokeStatic extends HInvoke {
   /** The first input must be the target. */
-  HInvokeStatic(selector, inputs, [HType knownType = HType.UNKNOWN])
-      : super(selector, inputs) {
+  HInvokeStatic(inputs, [HType knownType = HType.UNKNOWN]) : super(inputs) {
     guaranteedType = knownType;
   }
 
   toString() => 'invoke static: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeStatic(this);
   Element get element() => target.element;
   HStatic get target() => inputs[0];
 
   HType computeDesiredTypeForInput(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     return computeDesiredTypeForNonTargetInput(input);
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     return HType.UNKNOWN;
   }
 }
 
 class HInvokeSuper extends HInvokeStatic {
-  HInvokeSuper(selector, inputs) : super(selector, inputs);
+  HInvokeSuper(inputs) : super(inputs);
   toString() => 'invoke super: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeSuper(this);
 }
 
 class HInvokeInterceptor extends HInvokeStatic {
+  final Selector selector;
   final SourceString name;
   final bool getter;
   final bool setter;
 
-  HInvokeInterceptor(Selector selector,
-                     SourceString this.name,
+  HInvokeInterceptor(this.selector,
+                     this.name,
                      List<HInstruction> inputs,
                      [HType knownType = HType.UNKNOWN,
-                      bool this.getter = false,
-                      bool this.setter = false])
-      : super(selector, inputs, knownType);
+                      this.getter = false,
+                      this.setter = false])
+      : super(inputs, knownType);
 
   toString() => 'invoke interceptor: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeInterceptor(this);
 
   bool isLengthGetter() {
     return getter && name == const SourceString('length');
   }
 
   bool isLengthGetterOnStringOrArray() {
     return isLengthGetter() && inputs[1].isIndexablePrimitive();
@@ skipping 168 matching lines @@
 class HForeignNew extends HForeign {
   ClassElement element;
   HForeignNew(this.element, List<HInstruction> inputs)
       : super(const LiteralDartString("new"),
               const LiteralDartString("Object"), inputs);
   accept(HVisitor visitor) => visitor.visitForeignNew(this);
 }
 
 class HInvokeBinary extends HInvokeStatic {
   HInvokeBinary(HStatic target, HInstruction left, HInstruction right)
-      : super(Selector.BINARY_OPERATOR, <HInstruction>[target, left, right]);
+      : super(<HInstruction>[target, left, right]);
 
   HInstruction get left() => inputs[1];
   HInstruction get right() => inputs[2];
 
   abstract BinaryOperation get operation();
   abstract get builtin();
 }
 
 class HBinaryArithmetic extends HInvokeBinary {
   HBinaryArithmetic(HStatic target, HInstruction left, HInstruction right)
@@ skipping 249 matching lines @@
   accept(HVisitor visitor) => visitor.visitBitXor(this);
 
   BitXorOperation get operation() => const BitXorOperation();
   int typeCode() => 15;
   bool typeEquals(other) => other is HBitXor;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HInvokeUnary extends HInvokeStatic {
   HInvokeUnary(HStatic target, HInstruction input)
-      : super(Selector.UNARY_OPERATOR, <HInstruction>[target, input]);
+      : super(<HInstruction>[target, input]);
 
   HInstruction get operand() => inputs[1];
 
   void prepareGvn() {
     // A unary arithmetic expression can take part in global value
     // numbering and does not have any side-effects if its input is a
     // number.
     if (builtin) {
       clearAllSideEffects();
       setUseGvn();
@@ skipping 514 matching lines @@
 
   HType get guaranteedType() => HType.MUTABLE_ARRAY;
 
   void prepareGvn() {
     assert(!hasSideEffects());
   }
 }
 
 class HIndex extends HInvokeStatic {
   HIndex(HStatic target, HInstruction receiver, HInstruction index)
-      : super(Selector.INDEX, <HInstruction>[target, receiver, index]);
+      : super(<HInstruction>[target, receiver, index]);
   toString() => 'index operator';
   accept(HVisitor visitor) => visitor.visitIndex(this);
 
   void prepareGvn() {
     if (builtin) {
       clearAllSideEffects();
     } else {
       setAllSideEffects();
     }
   }
@@ skipping 13 matching lines @@
   }
 
   bool get builtin() => receiver.isIndexablePrimitive() && index.isInteger();
 }
 
 class HIndexAssign extends HInvokeStatic {
   HIndexAssign(HStatic target,
                HInstruction receiver,
                HInstruction index,
                HInstruction value)
-      : super(Selector.INDEX_SET,
-              <HInstruction>[target, receiver, index, value]);
+      : super(<HInstruction>[target, receiver, index, value]);
   toString() => 'index assign operator';
   accept(HVisitor visitor) => visitor.visitIndexAssign(this);
 
   HInstruction get receiver() => inputs[1];
   HInstruction get index() => inputs[2];
   HInstruction get value() => inputs[3];
 
   // Note, that we don't have a computeTypeFromInputTypes, since [HIndexAssign]
   // is never used as input.
 
@@ skipping 410 matching lines @@
   HBasicBlock get start() => expression.start;
   HBasicBlock get end() {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty());
     return statements.last().end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }