Move the handling of operator[] into the new interceptors.

sdk/lib/_internal/compiler/implementation/ssa/builder.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;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 2684 matching lines @@
 
   visitOperatorSend(node) {
     assert(node.selector is Operator);
     if (!methodInterceptionEnabled) {
       visitDynamicSend(node);
       return;
     }
 
     Operator op = node.selector;
     if (const SourceString("[]") == op.source) {
-      HStatic target = new HStatic(interceptors.getIndexInterceptor());
-      add(target);
-      visit(node.receiver);
-      HInstruction receiver = pop();
-      visit(node.argumentsNode);
-      HInstruction index = pop();
-      push(new HIndex(target, receiver, index));
+      visitDynamicSend(node);
     } else if (const SourceString("&&") == op.source ||
                const SourceString("||") == op.source) {
       visitLogicalAndOr(node, op);
     } else if (const SourceString("!") == op.source) {
       visitLogicalNot(node);
     } else if (node.argumentsNode is Prefix) {
       visitUnary(node, op);
     } else if (const SourceString("is") == op.source) {
       visit(node.receiver);
       HInstruction expression = pop();
@@ skipping 863 matching lines @@
         String reasons = fetchReasonsFromMalformedType(type);
         // TODO(johnniwinther): Change to resemble type errors from bounds check
         // on type arguments.
         generateRuntimeError(node, '$type is malformed: $reasons');
       } else {
         visitNewSend(node.send, type);
       }
     }
   }
 
+  HInvokeDynamicMethod buildInvokeDynamicWithOneArgument(
+      Node node, Selector selector, HInstruction receiver, HInstruction arg0) {
+    Set<ClassElement> interceptedClasses =
+        getInterceptedClassesOn(node, selector);
+    List<HInstruction> inputs = <HInstruction>[];
+    if (interceptedClasses != null) {
+      inputs.add(invokeInterceptor(interceptedClasses, receiver, node));
+    }
+    inputs.add(receiver);
+    inputs.add(arg0);
+    return new HInvokeDynamicMethod(selector, inputs);
+  }
+
   visitSendSet(SendSet node) {
     Element element = elements[node];
     if (!Elements.isUnresolved(element) && element.impliesType()) {
       Identifier selector = node.selector;
       generateThrowNoSuchMethod(node, selector.source.slowToString(),
                                 argumentNodes: node.arguments);
       return;
     }
     Operator op = node.assignmentOperator;
     if (node.isSuperCall) {
@@ skipping 31 matching lines @@
           // Compound assignments are considered as being prefix.
           bool isPrefix = !node.isPostfix;
           Element getter = elements[node.selector];
           if (isCompoundAssignment) {
             value = pop();
             index = pop();
           } else {
             index = pop();
             value = graph.addConstantInt(1, constantSystem);
           }
-          HStatic indexMethod = new HStatic(interceptors.getIndexInterceptor());
-          add(indexMethod);
-          HInstruction left = new HIndex(indexMethod, receiver, index);
+
+          HInvokeDynamicMethod left = buildInvokeDynamicWithOneArgument(
+              node, new Selector.index(), receiver, index);
           add(left);
           Element opElement = elements[op];
           visitBinary(left, op, value);
           value = pop();
           HInstruction assign = new HIndexAssign(
               target, receiver, index, value);
           add(assign);
           if (isPrefix) {
             stack.add(value);
           } else {
@@ skipping 1373 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }