Use short-hand update syntax for simple updating definitions.

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 457 matching lines @@
           declaredVariables.add(variableName);
           buffer.add("var ");
           generationState = STATE_DECLARATION;
         } else {
           generationState = STATE_EXPRESSION;
         }
 
       } else if (!isVariableDeclared(variableName)) {
         if (!isGeneratingDeclaration()) {
           delayedVariableDeclarations.add(variableName);
-        } else {
-          declaredVariables.add(variableName);
         }
+        // No matter if we are declaring the variable now or if we are
+        // delaying the declaration we can treat the variable as
+        // being declared from this point on.
+        declaredVariables.add(variableName);
       }
     } else if (!isVariableDeclared(variableName)) {
       declaredVariables.add(variableName);
       buffer.add("var ");
     }
     buffer.add(variableName);
   }
 
   void declareInstruction(HInstruction instruction) {
     declareVariable(variableNames.getName(instruction));
   }
 
+  // For simple updates of the form 'i = i op constant' generate
+  // 'i op= constant' instead.
+  bool handleSimpleUpdateDefinition(HInstruction instruction, String name) {
+    // If the variable is not declared the short update syntax cannot
+    // be used since it is a declaration and not an update.
+    if (!isVariableDeclared(name)) return false;
+
+    // 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?
+    if (instruction.builtin && instruction.inputs.length == 3) {
+      var left = instruction.inputs[1];
+      var right = instruction.inputs[2];
+      if (left.isConstantNumber() && isCommutative) {
+        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) {
+          buffer.add('++');
+          declareInstruction(instruction);
+        } else if (instruction is HSubtract && right.constant.value == 1) {
+          buffer.add('--');
+          declareInstruction(instruction);
+        } else {
+          var operation = instruction.operation.name;
+          declareInstruction(instruction);
+          buffer.add(' ${operation}= ${value}');
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+
   void define(HInstruction instruction) {
     if (isGeneratingExpression()) {
       addExpressionSeparator();
     } else {
       addIndentation();
     }
     if (instruction is !HCheck && variableNames.hasName(instruction)) {
-      declareInstruction(instruction);
-      buffer.add(" = ");
-      visit(instruction, JSPrecedence.ASSIGNMENT_PRECEDENCE);
+      var name = variableNames.getName(instruction);
+      if (!handleSimpleUpdateDefinition(instruction, name)) {
+        declareInstruction(instruction);
+        buffer.add(" = ");
+        visit(instruction, JSPrecedence.ASSIGNMENT_PRECEDENCE);
+      }
     } else {
       visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
     }
     if (!isGeneratingExpression()) buffer.add(';\n');
   }
 
   void use(HInstruction argument, int expectedPrecedenceForArgument) {
     if (isGenerateAtUseSite(argument)) {
       visit(argument, expectedPrecedenceForArgument);
     } else if (argument is HCheck) {
@@ skipping 377 matching lines @@
     }
     // Flow based traversal.
     if (node.isLoopHeader() &&
         node.loopInformation.loopBlockInformation !== currentBlockInformation) {
       beginLoop(node);
     }
     iterateBasicBlock(node);
   }
 
   void emitAssignment(String destination, String source) {
-    if (isGeneratingExpression()) { 
+    if (isGeneratingExpression()) {
       addExpressionSeparator();
     } else {
       addIndentation();
     }
     declareVariable(destination);
     buffer.add(' = $source');
     if (!isGeneratingExpression()) {
       buffer.add(';\n');
     }
   }
@@ skipping 1610 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }