Fix bug 9239 by always evaluating the receiver before the value in an instance SendSet.

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 2422 matching lines @@
       instruction.inputs.add(value);
       addWithPosition(instruction, send);
     } else {
       addWithPosition(
           new HInvokeDynamicSetter(selector, null, receiver, value, !hasSetter),
           send);
     }
     stack.add(value);
   }
 
-  void generateSetter(SendSet send, Element element, HInstruction value) {
+  void generateNonInstanceSetter(SendSet send,
+                                 Element element,
+                                 HInstruction value) {
+    assert(!Elements.isInstanceSend(send, elements));
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.isSetter()) {
         HStatic target = new HStatic(element);
         add(target);
         addWithPosition(
             new HInvokeStatic(<HInstruction>[target, value], HType.UNKNOWN),
             send);
       } else {
         value = potentiallyCheckType(value, element.computeType(compiler));
         addWithPosition(new HStaticStore(element, value), send);
       }
       stack.add(value);
-    } else if (element == null || Elements.isInstanceField(element)) {
-      HInstruction receiver = generateInstanceSendReceiver(send);
-      generateInstanceSetterWithCompiledReceiver(send, receiver, value);
     } else if (Elements.isErroneousElement(element)) {
       // An erroneous element indicates an unresolved static setter.
       generateThrowNoSuchMethod(send,
                                 getTargetName(element, 'set'),
                                 argumentNodes: send.arguments);
     } else {
       stack.add(value);
       // If the value does not already have a name, give it here.
       if (value.sourceElement == null) {
         value.sourceElement = element;
@@ skipping 1239 matching lines @@
 
         if (node.isPostfix) {
           stack.add(getterInstruction);
         } else {
           stack.add(value);
         }
       }
     } else if (const SourceString("=") == op.source) {
       Link<Node> link = node.arguments;
       assert(!link.isEmpty && link.tail.isEmpty);
-      visit(link.head);
-      HInstruction value = pop();
-      generateSetter(node, element, value);
+      if (Elements.isInstanceSend(node, elements)) {
+        HInstruction receiver = generateInstanceSendReceiver(node);
+        visit(link.head);
+        generateInstanceSetterWithCompiledReceiver(node, receiver, pop());
+      } else {
+        visit(link.head);
+        generateNonInstanceSetter(node, element, pop());
+      }
     } else if (identical(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("="));
 
       // [receiver] is only used if the node is an instance send.
       HInstruction receiver = null;
       if (Elements.isInstanceSend(node, elements)) {
         receiver = generateInstanceSendReceiver(node);
         generateInstanceGetterWithCompiledReceiver(
             node, elements.getGetterSelectorInComplexSendSet(node), receiver);
       } else {
         generateGetter(node, elements[node.selector]);
       }
       HInstruction getterInstruction = pop();
       handleComplexOperatorSend(node, getterInstruction, node.arguments);
       HInstruction value = pop();
       assert(value != null);
       if (Elements.isInstanceSend(node, elements)) {
         assert(receiver != null);
         generateInstanceSetterWithCompiledReceiver(node, receiver, value);
       } else {
         assert(receiver == null);
-        generateSetter(node, element, value);
+        generateNonInstanceSetter(node, element, value);
       }
       if (node.isPostfix) {
         pop();
         stack.add(getterInstruction);
       }
     }
   }
 
   void visitLiteralInt(LiteralInt node) {
     stack.add(graph.addConstantInt(node.value, constantSystem));
@@ skipping 1340 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;
   }
 }