Extend the {+,-,/,*}= support by allowing non-constants on the right side.

lib/compiler/implementation/ssa/codegen.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 SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 483 matching lines @@
 
     // Check that the operation is one of +, *, - or /. Record whether
     // or not the operation is commutative.
     var isCommutative = false;
     if (instruction is HAdd || instruction is HMultiply) {
       isCommutative = true;
     } else if (instruction is !HSubtract && instruction is !HDivide) {
       return false;
     }
 
-    // Is it a builtin operation involving constant numbers?
+    // Is it a builtin operation involving +, -, /, or *?
     if (instruction.builtin && instruction.inputs.length == 3) {
       var left = instruction.inputs[1];
       var right = instruction.inputs[2];
-      if (left.isConstantNumber() && isCommutative) {
+      if (isCommutative && variableNames.getName(right) == name) {
         var tmp = right;
         right = left;
         left = tmp;
-      } else if (!right.isConstantNumber()) {
-        return false;
       }
-      // Right is constant number.
-      var value = right.constant.value;
+
       // Check that left has the same name as the definition and emit
       // the short update definition if it is.
       if (variableNames.getName(left) == name) {
-        if (instruction is HAdd && right.constant.value == 1) {
+        // Check if the right operand is constant one.
+        bool rightIsOne = false;
+        if (right.isConstantNumber()) {
+          HConstant rightConstant = right;
+          rightIsOne = (rightConstant.constant.value == 1);
+        }
+        if (instruction is HAdd && rightIsOne) {
+          beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
           buffer.add('++');
           declareVariable(name);
-        } else if (instruction is HSubtract && right.constant.value == 1) {
+          endExpression(JSPrecedence.PREFIX_PRECEDENCE);
+        } else if (instruction is HSubtract && rightIsOne) {
+          beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
           buffer.add('--');
           declareVariable(name);
+          endExpression(JSPrecedence.PREFIX_PRECEDENCE);
         } else {
           var operation = instruction.operation.name;
+          beginExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
           declareVariable(name);
-          buffer.add(' ${operation}= ${value}');
+          buffer.add(' ${operation}= ');
+          use(right, JSPrecedence.ASSIGNMENT_PRECEDENCE);
+          endExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
         }
         return true;
       }
     }
     return false;
   }
 
   // For simple type checks like i = intTypeCheck(i), we don't have to
   // emit an assignment, because the intTypeCheck just returns its
   // argument.
@@ skipping 2359 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }