Fix instance compound assignment.

lib/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1588 matching lines @@
         HEquals eq = new HEquals(target, left, right);
         add(eq);
         HBoolify bl = new HBoolify(eq);
         add(bl);
         push(new HNot(bl));
         break;
       default: compiler.unimplemented("SsaBuilder.visitBinary");
     }
   }
 
+  HInstruction generateInstanceSendReceiver(Send send) {
+    assert(Elements.isInstanceSend(send, elements));
+    if (send.receiver == null) {
+      return localsHandler.readThis();
+    }
+    visit(send.receiver);
+    return pop();
+  }
+
+  void generateInstanceGetterWithCompiledReceiver(Send send,
+                                                  HInstruction receiver) {
+    assert(Elements.isInstanceSend(send, elements));
+    SourceString getterName = send.selector.asIdentifier().source;
+    Selector selector = elements.getSelector(send);
+    Element staticInterceptor = null;
+    if (methodInterceptionEnabled) {
+      staticInterceptor = interceptors.getStaticGetInterceptor(getterName);
+    }
+    if (staticInterceptor != null) {
+      HStatic target = new HStatic(staticInterceptor);
+      add(target);
+      List<HInstruction> inputs = <HInstruction>[target, receiver];
+      push(new HInvokeInterceptor(selector, getterName, true, inputs));
+    } else {
+      push(new HInvokeDynamicGetter(selector, null, getterName, receiver));
+    }
+  }
+
   void generateGetter(Send send, Element element) {
-    Selector selector = elements.getSelector(send);
     if (Elements.isStaticOrTopLevelField(element)) {
+      Selector selector = elements.getSelector(send);
       push(new HStatic(element));
       if (element.kind == ElementKind.GETTER) {
         push(new HInvokeStatic(selector, <HInstruction>[pop()]));
       }
     } else if (Elements.isInstanceSend(send, elements)) {
-      HInstruction receiver;
-      if (send.receiver == null) {
-        receiver = localsHandler.readThis();
-      } else {
-        visit(send.receiver);
-        receiver = pop();
-      }
-      SourceString getterName = send.selector.asIdentifier().source;
-      Element staticInterceptor = null;
-      if (methodInterceptionEnabled) {
-        staticInterceptor = interceptors.getStaticGetInterceptor(getterName);
-      }
-      if (staticInterceptor != null) {
-        HStatic target = new HStatic(staticInterceptor);
-        add(target);
-        List<HInstruction> inputs = <HInstruction>[target, receiver];
-        push(new HInvokeInterceptor(selector, getterName, true, inputs));
-      } else {
-        push(new HInvokeDynamicGetter(selector, null, getterName, receiver));
-      }
+      HInstruction receiver = generateInstanceSendReceiver(send);
+      generateInstanceGetterWithCompiledReceiver(send, receiver);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       push(new HStatic(element));
       compiler.registerGetOfStaticFunction(element);
     } else {
       stack.add(localsHandler.readLocal(element));
     }
   }
 
+  void generateInstanceSetterWithCompiledReceiver(Send send,
+                                                  HInstruction receiver,
+                                                  HInstruction value) {
+    assert(Elements.isInstanceSend(send, elements));
+    SourceString dartSetterName = send.selector.asIdentifier().source;
+    Selector selector = elements.getSelector(send);
+    Element staticInterceptor = null;
+    if (methodInterceptionEnabled) {
+      staticInterceptor = interceptors.getStaticSetInterceptor(dartSetterName);
+    }
+    if (staticInterceptor != null) {
+      HStatic target = new HStatic(staticInterceptor);
+      add(target);
+      List<HInstruction> inputs = <HInstruction>[target, receiver, value];
+      add(new HInvokeInterceptor(selector, dartSetterName, false, inputs));
+    } else {
+      add(new HInvokeDynamicSetter(selector, null, dartSetterName,
+                                   receiver, value));
+    }
+    stack.add(value);
+  }
+
   void generateSetter(SendSet send, Element element, HInstruction value) {
-    Selector selector = elements.getSelector(send);
     if (Elements.isStaticOrTopLevelField(element)) {
+      Selector selector = elements.getSelector(send);
       if (element.kind == ElementKind.SETTER) {
         HStatic target = new HStatic(element);
         add(target);
         add(new HInvokeStatic(selector, <HInstruction>[target, value]));
       } else {
         add(new HStaticStore(element, value));
       }
       stack.add(value);
     } else if (element === null || Elements.isInstanceField(element)) {
-      SourceString dartSetterName = send.selector.asIdentifier().source;
-      HInstruction receiver;
-      if (send.receiver == null) {
-        receiver = localsHandler.readThis();
-      } else {
-        visit(send.receiver);
-        receiver = pop();
-      }
-      Element staticInterceptor = null;
-      if (methodInterceptionEnabled) {
-        staticInterceptor =
-          interceptors.getStaticSetInterceptor(dartSetterName);
-      }
-      if (staticInterceptor != null) {
-        HStatic target = new HStatic(staticInterceptor);
-        add(target);
-        List<HInstruction> inputs = <HInstruction>[target, receiver, value];
-        add(new HInvokeInterceptor(selector, dartSetterName, false, inputs));
-      } else {
-        add(new HInvokeDynamicSetter(selector, null, dartSetterName,
-                                     receiver, value));
-      }
-      stack.add(value);
+      HInstruction receiver = generateInstanceSendReceiver(send);
+      generateInstanceSetterWithCompiledReceiver(send, receiver, value);
     } else {
       localsHandler.updateLocal(element, value);
       stack.add(value);
     }
   }
 
   visitOperatorSend(node) {
     assert(node.selector is Operator);
     Operator op = node.selector;
     if (const SourceString("[]") == op.source) {
@@ skipping 504 matching lines @@
       generateSetter(node, element, value);
     } else if (op.source.stringValue === "is") {
       compiler.internalError("is-operator as SendSet", node: op);
     } else {
       assert(const SourceString("++") == op.source ||
              const SourceString("--") == op.source ||
              node.assignmentOperator.source.stringValue.endsWith("="));
       Element element = elements[node];
       bool isCompoundAssignment = !node.arguments.isEmpty();
       bool isPrefix = !node.isPostfix;  // Compound assignments are prefix.
-      generateGetter(node, elements[node.selector]);
+
+      // [receiver] is only used if the node is an instance send.
+      HInstruction receiver = null;
+      if (Elements.isInstanceSend(node, elements)) {
+        receiver = generateInstanceSendReceiver(node);
+        generateInstanceGetterWithCompiledReceiver(node, receiver);
+      } else {
+        generateGetter(node, elements[node.selector]);
+      }
       HInstruction left = pop();
       HInstruction right;
       if (isCompoundAssignment) {
         visit(node.argumentsNode);
         right = pop();
       } else {
         right = graph.addConstantInt(1);
       }
       visitBinary(left, op, right);
       HInstruction operation = pop();
       assert(operation !== null);
-      generateSetter(node, element, operation);
+      if (Elements.isInstanceSend(node, elements)) {
+        assert(receiver !== null);
+        generateInstanceSetterWithCompiledReceiver(node, receiver, operation);
+      } else {
+        assert(receiver === null);
+        generateSetter(node, element, operation);
+      }
       if (!isPrefix) {
         pop();
         stack.add(left);
       }
     }
   }
 
   void visitLiteralInt(LiteralInt node) {
     stack.add(graph.addConstantInt(node.value));
   }
@@ skipping 772 matching lines @@
                                         false,
                                         <HInstruction>[target, input]));
     return builder.pop();
   }
 
   HInstruction result() {
     flushLiterals();
     return prefix;
   }
 }