Re-apply "Move the handling of operator[] into the new interceptors."

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 162 matching lines @@
     return new HBoundedType.exact(objectConstant.type);
   }
 
   HConstant addConstant(Constant constant) {
     HConstant result = constants[constant];
     if (result == null) {
       HType type = mapConstantTypeToSsaType(constant);
       result = new HConstant.internal(constant, type);
       entry.addAtExit(result);
       constants[constant] = result;
+    } else if (result.block == null) {

[ngeoffray, 2012/12/12 16:14:14]

This was the bug: we were adding a constant back into a usedBy list, but without
putting it in a block.

[kasperl, 2012/12/13 08:49:24]

So we would have a constant in the constant map that got unused -- and then we
would decide to reuse it? Makes sense.

+      // The constant was not used anymore.
+      entry.addAtExit(result);
     }
     return result;
   }
 
   HConstant addConstantInt(int i, ConstantSystem constantSystem) {
     return addConstant(constantSystem.createInt(i));
   }
 
   HConstant addConstantDouble(double d, ConstantSystem constantSystem) {
     return addConstant(constantSystem.createDouble(d));
@@ skipping 89 matching lines @@
   visitExitTry(HExitTry node) => visitControlFlow(node);
   visitFieldGet(HFieldGet node) => visitFieldAccess(node);
   visitFieldSet(HFieldSet node) => visitFieldAccess(node);
   visitForeign(HForeign node) => visitInstruction(node);
   visitForeignNew(HForeignNew node) => visitForeign(node);
   visitGoto(HGoto node) => visitControlFlow(node);
   visitGreater(HGreater node) => visitRelational(node);
   visitGreaterEqual(HGreaterEqual node) => visitRelational(node);
   visitIdentity(HIdentity node) => visitRelational(node);
   visitIf(HIf node) => visitConditionalBranch(node);
-  visitIndex(HIndex node) => visitInvokeStatic(node);
+  visitIndex(HIndex node) => visitInstruction(node);
   visitIndexAssign(HIndexAssign node) => visitInvokeStatic(node);
   visitIntegerCheck(HIntegerCheck node) => visitCheck(node);
   visitInterceptor(HInterceptor node) => visitInstruction(node);
   visitInvokeClosure(HInvokeClosure node)
       => visitInvokeDynamic(node);
   visitInvokeDynamicMethod(HInvokeDynamicMethod node)
       => visitInvokeDynamic(node);
   visitInvokeDynamicGetter(HInvokeDynamicGetter node)
       => visitInvokeDynamicField(node);
   visitInvokeDynamicSetter(HInvokeDynamicSetter node)
@@ skipping 1010 matching lines @@
 
 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';
+  String toString() => 'invoke dynamic method: $selector';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicMethod(this);
+
+  bool isIndexOperatorOnIndexablePrimitive(HTypeMap types) {
+    return isInterceptorCall
+        && selector.kind == SelectorKind.INDEX
+        && inputs[1].isIndexablePrimitive(types);
+  }
+
+  HType computeDesiredTypeForInput(HInstruction input,
+                                   HTypeMap types,
+                                   Compiler compiler) {
+    // TODO(ngeoffray): Move this logic into a different class that
+    // will know what type it wants for a given selector.
+    if (selector.kind != SelectorKind.INDEX) return HType.UNKNOWN;
+    if (!isInterceptorCall) return HType.UNKNOWN;
+
+    HInstruction index = inputs[2];
+    if (input == inputs[1] &&
+        (index.isTypeUnknown(types) || index.isNumber(types))) {
+      return HType.INDEXABLE_PRIMITIVE;
+    }
+    // The index should be an int when the receiver is a string or array.
+    // However it turns out that inserting an integer check in the optimized
+    // version is cheaper than having another bailout case. This is true,
+    // because the integer check will simply throw if it fails.
+    return HType.UNKNOWN;
+  }
 }
 
 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';
 }
@@ skipping 1097 matching lines @@
   toString() => 'literal list';
   accept(HVisitor visitor) => visitor.visitLiteralList(this);
 
   HType get guaranteedType => HType.EXTENDABLE_ARRAY;
 
   void prepareGvn(HTypeMap types) {
     assert(!hasSideEffects(types));
   }
 }
 
-class HIndex extends HInvokeStatic {
-  HIndex(HStatic target, HInstruction receiver, HInstruction index)
-      : super(<HInstruction>[target, receiver, index]);
-  toString() => 'index operator';
+class HIndex extends HInstruction {
+  HIndex(HInstruction receiver, HInstruction index)
+      : super(<HInstruction>[receiver, index]);
+  String toString() => 'index operator';
   accept(HVisitor visitor) => visitor.visitIndex(this);
 
   void prepareGvn(HTypeMap types) {
     clearAllSideEffects();
-    if (isBuiltin(types)) {
-      setDependsOnIndexStore();
-      setUseGvn();
-    } else {
-      setAllSideEffects();
-    }
+    setDependsOnIndexStore();
+    setUseGvn();
   }
 
-  HInstruction get receiver => inputs[1];
-  HInstruction get index => inputs[2];
-
-  HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types,
-                                            Compiler compiler) {
-    if (input == receiver &&
-        (index.isTypeUnknown(types) || index.isNumber(types))) {
-      return HType.INDEXABLE_PRIMITIVE;
-    }
-    // The index should be an int when the receiver is a string or array.
-    // However it turns out that inserting an integer check in the optimized
-    // version is cheaper than having another bailout case. This is true,
-    // because the integer check will simply throw if it fails.
-    return HType.UNKNOWN;
-  }
-
-  bool isBuiltin(HTypeMap types)
-      => receiver.isIndexablePrimitive(types) && index.isInteger(types);
+  HInstruction get receiver => inputs[0];
+  HInstruction get index => inputs[1];
 
   int typeCode() => HInstruction.INDEX_TYPECODE;
   bool typeEquals(HInstruction other) => other is HIndex;
   bool dataEquals(HIndex other) => true;
 }
 
 class HIndexAssign extends HInvokeStatic {
   HIndexAssign(HStatic target,
                HInstruction receiver,
                HInstruction index,
@@ skipping 455 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);
 }