Move indexSet and unary operators to the new interceptor mechanism.

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 2281 matching lines @@
       Element fieldCheck =
           parameterClosureData.parametersWithSentinel[element];
       stack.add(localsHandler.readLocal(fieldCheck));
       return;
     }
     assert(node.argumentsNode is Prefix);
     visit(node.receiver);
     assert(!identical(op.token.kind, PLUS_TOKEN));
     HInstruction operand = pop();
 
-    HInstruction target =
-        new HStatic(interceptors.getPrefixOperatorInterceptor(op));
-    add(target);
-    HInvokeUnary result;
-    String value = op.source.stringValue;
-    switch (value) {
-      case "-": result = new HNegate(target, operand); break;
-      case "~": result = new HBitNot(target, operand); break;
-      default:
-        compiler.internalError('Unexpected unary operator: $value.', node: op);
-        break;
-    }
     // See if we can constant-fold right away. This avoids rewrites later on.
     if (operand is HConstant) {
+      UnaryOperation operation = constantSystem.lookupUnary(op.source);
       HConstant constant = operand;
-      Constant folded =
-          result.operation(constantSystem).fold(constant.constant);
+      Constant folded = operation.fold(constant.constant);
       if (folded != null) {
         stack.add(graph.addConstant(folded));
         return;
       }
     }
+
+    HInvokeDynamicMethod result =
+        buildInvokeDynamic(node, elements.getSelector(node), operand, []);
     pushWithPosition(result, node);
   }
 
   void visitBinary(HInstruction left, Operator op, HInstruction right) {
     Element element = interceptors.getOperatorInterceptor(op);
     assert(element != null);
     HInstruction target = new HStatic(element);
     add(target);
     switch (op.source.stringValue) {
       case "+":
@@ skipping 1299 matching lines @@
         // on type arguments.
         generateRuntimeError(node, '$type is malformed: $reasons');
       } else {
         // TODO(karlklose): move this type registration to the codegen.
         compiler.codegenWorld.instantiatedTypes.add(type);
         visitNewSend(node.send, type);
       }
     }
   }
 
-  HInvokeDynamicMethod buildInvokeDynamicWithOneArgument(
-      Node node, Selector selector, HInstruction receiver, HInstruction arg0) {
+  HInvokeDynamicMethod buildInvokeDynamic(Node node,
+                                          Selector selector,
+                                          HInstruction receiver,
+                                          List<HInstruction> arguments) {
     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);
+    inputs.addAll(arguments);
     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) {
       if (element == null) return generateSuperNoSuchMethodSend(node);
       HInstruction target = new HStatic(element);
       HInstruction context = localsHandler.readThis();
       add(target);
       var inputs = <HInstruction>[target, context];
       addDynamicSendArgumentsToList(node, inputs);
       if (!identical(node.assignmentOperator.source.stringValue, '=')) {
         compiler.unimplemented('complex super assignment',
                                node: node.assignmentOperator);
       }
       push(new HInvokeSuper(inputs, isSetter: true));
     } else if (node.isIndex) {
       if (!methodInterceptionEnabled) {
         assert(identical(op.source.stringValue, '='));
         visitDynamicSend(node);
+      } else if (const SourceString("=") == op.source) {
+        visitDynamicSend(node);
+        HInvokeDynamicMethod method = pop();
+        // Push the value.
+        stack.add(method.inputs.last);
       } else {
-        HStatic target = new HStatic(
-            interceptors.getIndexAssignmentInterceptor());
-        add(target);
         visit(node.receiver);
         HInstruction receiver = pop();
         visit(node.argumentsNode);
-        if (const SourceString("=") == op.source) {
-          HInstruction value = pop();
-          HInstruction index = pop();
-          add(new HIndexAssign(target, receiver, index, value));
+        HInstruction value;
+        HInstruction index;
+        // Compound assignments are considered as being prefix.
+        bool isCompoundAssignment = op.source.stringValue.endsWith('=');
+        bool isPrefix = !node.isPostfix;
+        Element getter = elements[node.selector];
+        if (isCompoundAssignment) {
+          value = pop();
+          index = pop();
+        } else {
+          index = pop();
+          value = graph.addConstantInt(1, constantSystem);
+        }
+
+        HInvokeDynamicMethod left = buildInvokeDynamic(
+            node, new Selector.index(), receiver, [index]);
+        add(left);
+        visitBinary(left, op, value);
+        value = pop();
+        HInvokeDynamicMethod assign = buildInvokeDynamic(
+            node, new Selector.indexSet(), receiver, [index, value]);
+        add(assign);
+        if (isPrefix) {
           stack.add(value);
         } else {
-          HInstruction value;
-          HInstruction index;
-          bool isCompoundAssignment = op.source.stringValue.endsWith('=');
-          // 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);
-          }
-
-          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 {
-            stack.add(left);
-          }
+          stack.add(left);
         }
       }
     } else if (const SourceString("=") == op.source) {
       Element element = elements[node];
       Link<Node> link = node.arguments;
       assert(!link.isEmpty && link.tail.isEmpty);
       visit(link.head);
       HInstruction value = pop();
       generateSetter(node, element, value);
     } else if (identical(op.source.stringValue, "is")) {
@@ skipping 1369 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;
   }
 }