- Move length getter and setter interceptors to the new interceptor scheme.

sdk/lib/_internal/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.
 
 part of ssa;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 18 matching lines @@
   R visitGreaterEqual(HGreaterEqual node);
   R visitIdentity(HIdentity node);
   R visitIf(HIf node);
   R visitIndex(HIndex node);
   R visitIndexAssign(HIndexAssign node);
   R visitIntegerCheck(HIntegerCheck node);
   R visitInvokeClosure(HInvokeClosure node);
   R visitInvokeDynamicGetter(HInvokeDynamicGetter node);
   R visitInvokeDynamicMethod(HInvokeDynamicMethod node);
   R visitInvokeDynamicSetter(HInvokeDynamicSetter node);
-  R visitInvokeInterceptor(HInvokeInterceptor node);
   R visitInvokeStatic(HInvokeStatic node);
   R visitInvokeSuper(HInvokeSuper node);
   R visitIs(HIs node);
   R visitLazyStatic(HLazyStatic node);
   R visitLess(HLess node);
   R visitLessEqual(HLessEqual node);
   R visitLiteralList(HLiteralList node);
   R visitLocalGet(HLocalGet node);
   R visitLocalSet(HLocalSet node);
   R visitLocalValue(HLocalValue node);
@@ skipping 243 matching lines @@
   visitIndexAssign(HIndexAssign node) => visitInvokeStatic(node);
   visitIntegerCheck(HIntegerCheck node) => visitCheck(node);
   visitInvokeClosure(HInvokeClosure node)
       => visitInvokeDynamic(node);
   visitInvokeDynamicMethod(HInvokeDynamicMethod node)
       => visitInvokeDynamic(node);
   visitInvokeDynamicGetter(HInvokeDynamicGetter node)
       => visitInvokeDynamicField(node);
   visitInvokeDynamicSetter(HInvokeDynamicSetter node)
       => visitInvokeDynamicField(node);
-  visitInvokeInterceptor(HInvokeInterceptor node)
-      => visitInvokeStatic(node);
   visitInvokeStatic(HInvokeStatic node) => visitInvoke(node);
   visitInvokeSuper(HInvokeSuper node) => visitInvoke(node);
   visitJump(HJump node) => visitControlFlow(node);
   visitLazyStatic(HLazyStatic node) => visitStatic(node);
   visitLess(HLess node) => visitRelational(node);
   visitLessEqual(HLessEqual node) => visitRelational(node);
   visitLiteralList(HLiteralList node) => visitInstruction(node);
   visitLocalGet(HLocalGet node) => visitFieldGet(node);
   visitLocalSet(HLocalSet node) => visitFieldSet(node);
   visitLocalValue(HLocalValue node) => visitInstruction(node);
@@ skipping 999 matching lines @@
 
 abstract class HInvokeDynamic extends HInvoke {
   final Selector selector;
   Element element;
 
   HInvokeDynamic(this.selector, this.element, List<HInstruction> inputs)
     : super(inputs);
   toString() => 'invoke dynamic: $selector';
   HInstruction get receiver => inputs[0];
 
-  // TODO(floitsch): make class abstract instead of adding an abstract method.
   accept(HVisitor visitor);

[ahe, 2012/11/23 06:51:23]

Remove this method?  I believe it was only there to make this class implicitly
abstract (it is already defined in HInstruction).

[ngeoffray, 2012/11/23 12:01:17]

Done.

+
+  bool get isInterceptorCall {
+    // 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 inputs.length - 2 == selector.argumentCount;
+  }
 }
 
 class HInvokeClosure extends HInvokeDynamic {
   HInvokeClosure(Selector selector, List<HInstruction> inputs)
     : super(selector, null, inputs);
   accept(HVisitor visitor) => visitor.visitInvokeClosure(this);
 }
 
 class HInvokeDynamicMethod extends HInvokeDynamic {
   HInvokeDynamicMethod(Selector selector, List<HInstruction> inputs)
     : super(selector, null, inputs);
   toString() => 'invoke dynamic method: $selector';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicMethod(this);
 }
 
 abstract class HInvokeDynamicField extends HInvokeDynamic {
   final bool isSideEffectFree;
   HInvokeDynamicField(
       Selector selector, Element element, List<HInstruction> inputs,
       this.isSideEffectFree)
       : super(selector, element, inputs);
   toString() => 'invoke dynamic field: $selector';
 
-  // TODO(floitsch): make class abstract instead of adding an abstract method.
   accept(HVisitor visitor);

[ahe, 2012/11/23 06:51:23]

Remove this method?

[ngeoffray, 2012/11/23 12:01:17]

Done.

 }
 
 class HInvokeDynamicGetter extends HInvokeDynamicField {
   HInvokeDynamicGetter(
       selector, element, receiver, isSideEffectFree)
     : super(selector, element, [receiver], isSideEffectFree);
   toString() => 'invoke dynamic getter: $selector';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicGetter(this);
 
   void prepareGvn(HTypeMap types) {
@@ skipping 21 matching lines @@
     clearAllSideEffects();
     if (isSideEffectFree) {
       setChangesInstanceProperty();
     } else {
       setAllSideEffects();
     }
   }
 }
 
 class HInvokeStatic extends HInvoke {
+  bool isSideEffectFree = false;
   /** The first input must be the target. */
   HInvokeStatic(inputs, [HType knownType = HType.UNKNOWN]) : super(inputs) {
     guaranteedType = knownType;
   }
 
   toString() => 'invoke static: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeStatic(this);
   int typeCode() => HInstruction.INVOKE_STATIC_TYPECODE;
   Element get element => target.element;
   HStatic get target => inputs[0];
 
   HType computeDesiredTypeForInput(HInstruction input,
                                    HTypeMap types,
                                    Compiler compiler) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     return computeDesiredTypeForNonTargetInput(input, types, compiler);
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types,
                                             Compiler compiler) {
     return HType.UNKNOWN;
   }
+
+  void prepareGvn(HTypeMap types) {
+    clearAllSideEffects();
+    if (!isSideEffectFree) {
+      setAllSideEffects();
+    }
+  }
 }
 
 class HInvokeSuper extends HInvokeStatic {
   final bool isSetter;
   HInvokeSuper(inputs, {this.isSetter: false}) : super(inputs);
   toString() => 'invoke super: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeSuper(this);
 
   HInstruction get value {
     assert(isSetter);
     // Index 0: the element, index 1: 'this'.
     return inputs[2];
   }
 }
 
-class HInvokeInterceptor extends HInvokeStatic {
-  final Selector selector;
-  final bool isSideEffectFree;
-
-  HInvokeInterceptor(this.selector,
-                     List<HInstruction> inputs,
-                     [bool this.isSideEffectFree = false])
-      : super(inputs);
-
-  toString() => 'invoke interceptor: ${element.name}';
-  accept(HVisitor visitor) => visitor.visitInvokeInterceptor(this);
-
-  bool isLengthGetter() {
-    return selector.isGetter() &&
-        selector.name == const SourceString('length');
-  }
-
-  bool isPopCall(HTypeMap types) {
-    return selector.isCall()
-        && inputs[1].isExtendableArray(types)
-        && selector.name == const SourceString('removeLast')
-        && selector.argumentCount == 0;
-  }
-
-  bool isLengthGetterOnStringOrArray(HTypeMap types) {
-    return isLengthGetter() && inputs[1].isIndexablePrimitive(types);
-  }
-
-  HType computeLikelyType(HTypeMap types, Compiler compiler) {
-    // In general a length getter or method returns an int.
-    if (isLengthGetter()) return HType.INTEGER;
-    return HType.UNKNOWN;
-  }
-
-  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
-    if (isLengthGetterOnStringOrArray(types)) return HType.INTEGER;
-    return HType.UNKNOWN;
-  }
-
-  HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types,
-                                            Compiler compiler) {
-    // 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)) {
-      // TODO(kasperl): Should we check that the selector is a call selector?
-      if (selector.name == const SourceString('add')
-          || selector.name == const SourceString('removeLast')) {
-        return HType.MUTABLE_ARRAY;
-      }
-    }
-    return HType.UNKNOWN;
-  }
-
-  void prepareGvn(HTypeMap types) {
-    clearAllSideEffects();
-    if (isLengthGetterOnStringOrArray(types)) {
-      setUseGvn();
-      // If the input is a string or a fixed length array, we know
-      // the length cannot change.
-      if (!inputs[1].isString(types) && !inputs[1].isFixedArray(types)) {
-        setDependsOnInstancePropertyStore();
-      }
-    } else if (isSideEffectFree) {
-      setUseGvn();
-      setDependsOnSomething();
-    } else {
-      setAllSideEffects();
-    }
-  }
-
-  int typeCode() => HInstruction.INVOKE_INTERCEPTOR_TYPECODE;
-  bool typeEquals(other) => other is HInvokeInterceptor;
-  bool dataEquals(HInvokeInterceptor other) => selector == other.selector;
-}
-
 abstract class HFieldAccess extends HInstruction {
   final Element element;
 
   HFieldAccess(Element element, List<HInstruction> inputs)
       : this.element = element,
         super(inputs);
 }
 
 class HFieldGet extends HFieldAccess {
   final bool isAssignable;
@@ skipping 1498 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);
 }