Simplify HInvokeInterceptor.

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 1277 matching lines @@
 
   HInstruction get value {
     assert(isSetter);
     // Index 0: the element, index 1: 'this'.
     return inputs[2];
   }
 }
 
 class HInvokeInterceptor extends HInvokeStatic {
   final Selector selector;
-  final SourceString name;
-  final bool getter;
-  final bool setter;
 
   HInvokeInterceptor(this.selector,
-                     this.name,
                      List<HInstruction> inputs,
-                     [HType knownType = HType.UNKNOWN,
-                      this.getter = false,
-                      this.setter = false])
+                     [HType knownType = HType.UNKNOWN])
       : super(inputs, knownType);
 
   toString() => 'invoke interceptor: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeInterceptor(this);
 
   bool isLengthGetter() {
-    return getter && name == const SourceString('length');
+    return selector.isGetter() &&
+        selector.name == const SourceString('length');
   }
 
   bool isLengthGetterOnStringOrArray(HTypeMap types) {
     return isLengthGetter() && inputs[1].isIndexablePrimitive(types);
   }
 
   HType computeLikelyType(HTypeMap types) {
     // In general a length getter or method returns an int.
-    if (name == const SourceString('length')) return HType.INTEGER;
+    if (isLengthGetter()) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeTypeFromInputTypes(HTypeMap types) {
     if (isLengthGetterOnStringOrArray(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types) {
     // If the first argument is a string or an array and we invoke methods
     // on it that mutate it, then we want to restrict the incoming type to be
     // a mutable array.
     if (input == inputs[1] && input.isIndexablePrimitive(types)) {
-      if (name == const SourceString('add')
-          || name == const SourceString('removeLast')) {
+      // TODO(kasperl): Should we check that the selector is a call selector?

[ngeoffray, 2012/08/22 13:58:54]

I think not checking is ok. If it's a getter, you still want the input to be a
mutable array, because the getter turns the add method into a closure that may
be called later on.

+      if (selector.name == const SourceString('add')
+          || selector.name == const SourceString('removeLast')) {
         return HType.MUTABLE_ARRAY;
       }
     }
     return HType.UNKNOWN;
   }
 
   void prepareGvn(HTypeMap types) {
     if (isLengthGetterOnStringOrArray(types)) {
       setUseGvn();
       clearAllSideEffects();
       setDependsOnSomething();
     } else {
       setAllSideEffects();
     }
   }
 
   int typeCode() => 4;
   bool typeEquals(other) => other is HInvokeInterceptor;
-  bool dataEquals(HInvokeInterceptor other) {
-    return getter == other.getter && name == other.name;
-  }
+  bool dataEquals(HInvokeInterceptor other) => selector == other.selector;
 }
 
 abstract class HFieldAccess extends HInstruction {
   final Element element;
   final SourceString fieldName;
   final LibraryElement library;
 
   HFieldAccess(this.fieldName, this.library, List<HInstruction> inputs)
       : element = null, super(inputs);
 
@@ skipping 1415 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);
 }