dart2js CPS: Fix a bug in commuting binary operations.

pkg/compiler/lib/src/tree_ir/optimization/statement_rewriter.dart

 // Copyright (c) 2014, 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.
 
 library tree_ir.optimization.statement_rewriter;
 
 import 'optimization.dart' show Pass;
 import '../tree_ir_nodes.dart';
 import '../../io/source_information.dart';
 
@@ skipping 369 matching lines @@
       node = node.next;
     }
     Statement result = visitStatement(node);
     for (Function fun in stack.reversed) {
       result = fun(result);
     }
     return result;
   }
 
   /// Attempts to propagate an assignment in an expression statement.
-  /// 
+  ///
   /// Returns a callback to be invoked after the sucessor statement has
   /// been processed.
   Function processExpressionStatement(ExpressionStatement stmt) {
     Variable leftHand = getLeftHand(stmt.expression);
     pushDominatingAssignment(leftHand);
     if (isEffectivelyConstantAssignment(stmt.expression) &&
         !usesRecentlyAssignedVariable(stmt.expression)) {
       Assign assign = stmt.expression;
       // Handle constant assignments specially.
       // They are always safe to propagate (though we should avoid duplication).
       // Moreover, they should not prevent other expressions from propagating.
       if (assign.variable.readCount == 1) {
         // A single-use constant should always be propagated to its use site.
         constantEnvironment[assign.variable] = assign.value;
         return (Statement next) {
           popDominatingAssignment(leftHand);
           if (assign.variable.readCount > 0) {
-            // The assignment could not be propagated into the successor, 
+            // The assignment could not be propagated into the successor,
             // either because it [hasUnsafeVariableUse] or because the
             // use is outside the current try block, and we do not currently
             // support constant propagation out of a try block.
             constantEnvironment.remove(assign.variable);
             assign.value = visitExpression(assign.value);
             stmt.next = next;
             return stmt;
           } else {
             --assign.variable.writeCount;
             return next;
@@ skipping 415 matching lines @@
     if (environment.isEmpty || getLeftHand(environment.last) == null) {
       // If there is no recent assignment that might propagate, so there is no
       // opportunity for optimization here.
       _rewriteList(node.arguments);
       return node;
     }
     Variable propagatableVariable = getLeftHand(environment.last);
     BuiltinOperator commuted = commuteBinaryOperator(node.operator);
     if (commuted != null) {
       assert(node.arguments.length == 2); // Only binary operators can commute.
-      VariableUse arg1 = node.arguments[0];
-      VariableUse arg2 = node.arguments[1];
-      if (propagatableVariable == arg1.variable &&
-          propagatableVariable != arg2.variable &&
-          !constantEnvironment.containsKey(arg2.variable)) {
-        // An assignment can be propagated if we commute the operator.
-        node.operator = commuted;
-        node.arguments[0] = arg2;
-        node.arguments[1] = arg1;
+      Expression left = node.arguments[0];
+      if (left is VariableUse && propagatableVariable == left.variable) {
+        Expression right = node.arguments[1];
+        if (right is This ||
+            (right is VariableUse &&
+             propagatableVariable != right.variable &&
+             !constantEnvironment.containsKey(right.variable))) {
+          // An assignment can be propagated if we commute the operator.
+          node.operator = commuted;
+          node.arguments[0] = right;
+          node.arguments[1] = left;
+        }
       }
     }
     _rewriteList(node.arguments);
     return node;
   }
 
   /// If [s] and [t] are similar statements we extract their subexpressions
   /// and returns a new statement of the same type using expressions combined
   /// with the [combine] callback. For example:
   ///
@@ skipping 354 matching lines @@
   VariableUseVisitor(this.callback);
 
   visitVariableUse(VariableUse use) => callback(use);
 
   visitInnerFunction(FunctionDefinition node) {}
 
   static void visit(Expression node, VariableUseCallback callback) {
     new VariableUseVisitor(callback).visitExpression(node);
   }
 }