dart2dart: Introduce compound assignment and prefix increment in dart_codegen.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_codegen.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 dart_codegen;
 
 import 'dart_tree.dart' as tree;
 import 'dart_printer.dart';
 import 'dart_tree_printer.dart' show TreePrinter;
 import '../tree/tree.dart' as frontend;
@@ skipping 90 matching lines @@
     ParameterElement element = param.element;
     TypeAnnotation type = emitOptionalType(element.type);
     return new Parameter(element.name, type:type)
                ..element = element;
   }
 
   Parameters emitParameters(List<tree.Variable> params) {
     return new Parameters(params.map(emitParameter).toList(growable:false));
   }
 
+  /// True if the two expressions are a reference to the same variable.
+  bool isSameVariable(Expression e1, Expression e2) {
+    // TODO(asgerf): Using the annotated element isn't the best way to do this
+    // since elements are supposed to go away from codegen when we discard the
+    // old backend.
+    return e1 is Identifier &&
+           e2 is Identifier &&
+           e1.element is VariableElement &&
+           e1.element == e2.element;
+  }
+
+  Expression makeAssignment(Expression target, Expression value) {
+    // Try to print as compound assignment or increment
+    if (value is BinaryOperator && isCompoundableOperator(value.operator)) {
+      Expression leftOperand = value.left;
+      Expression rightOperand = value.right;
+      bool valid = false;
+      if (isSameVariable(target, leftOperand)) {
+        valid = true;
+      } else if (target is FieldExpression &&
+                 leftOperand is FieldExpression &&
+                 isSameVariable(target.object, leftOperand.object) &&
+                 target.fieldName == leftOperand.fieldName) {
+        valid = true;
+      } else if (target is IndexExpression &&
+                 leftOperand is IndexExpression &&
+                 isSameVariable(target.object, leftOperand.object) &&
+                 isSameVariable(target.index, leftOperand.index)) {
+        valid = true;
+      }
+      if (valid) {
+        if (rightOperand is Literal && rightOperand.value.isOne) {

[Kevin Millikin (Google), 2014/05/21 13:20:58]

And operator is '+' or '-'.

[asgerf, 2014/05/21 13:25:07]

Thanks

+          return new Increment.prefix(target, value.operator + value.operator);
+        } else {
+          return new Assignment(target, value.operator + '=', rightOperand);
+        }
+      }
+    }
+    // Fall back to regular assignment
+    return new Assignment(target, '=', value);
+  }
+
   void visitExpressionStatement(tree.ExpressionStatement stmt) {
     Expression e = visitExpression(stmt.expression);
     statementBuffer.add(new ExpressionStatement(e));
     visitStatement(stmt.next);
   }
 
   void visitLabeledStatement(tree.LabeledStatement stmt) {
     List<Statement> savedBuffer = statementBuffer;
     tree.Statement savedFallthrough = fallthrough;
     statementBuffer = <Statement>[];
@@ skipping 17 matching lines @@
           stmt.variable.name,
           ElementKind.VARIABLE,
           functionElement,
           variableList,
           null);
     }
     if (seenVariables.add(stmt.variable)) {
       variables.add(new VariableDeclaration(stmt.variable.name)
                             ..element = stmt.variable.element);
     }
-    Expression def = visitExpression(stmt.definition);
-    statementBuffer.add(new ExpressionStatement(new Assignment(
+    statementBuffer.add(new ExpressionStatement(makeAssignment(
         visitVariable(stmt.variable),
-        '=',
-        def)));
+        visitExpression(stmt.definition))));
     visitStatement(stmt.next);
   }
 
   void visitReturn(tree.Return stmt) {
     Expression inner = visitExpression(stmt.value);
     statementBuffer.add(new Return(inner));
   }
 
   void visitBreak(tree.Break stmt) {
     tree.Statement fall = fallthrough;
@@ skipping 71 matching lines @@
             name = '-';
           }
           return new UnaryOperator(name, receiver);
         }
         return new BinaryOperator(receiver, exp.selector.name, args[0]);
 
       case SelectorKind.GETTER:
         return new FieldExpression(receiver, exp.selector.name);
 
       case SelectorKind.SETTER:
-        return new Assignment(
+        return makeAssignment(
             new FieldExpression(receiver, exp.selector.name),
-            '=',
             args[0]);
 
       case SelectorKind.INDEX:
         Expression e = new IndexExpression(receiver, args[0]);
         if (args.length == 2) {
-          e = new Assignment(e, '=', args[1]);
+          e = makeAssignment(e, args[1]);
         }
         return e;
 
       default:
         throw "Unexpected selector in InvokeMethod: ${exp.selector.kind}";
     }
   }
 
   Expression visitInvokeConstructor(tree.InvokeConstructor exp) {
     List args = emitArguments(exp);
@@ skipping 70 matching lines @@
             emitConstant(constant.keys.entries[i]),
             emitConstant(constant.values[i])));
       }
       return new LiteralMap(entries, isConst: true);
     } else {
       throw "Unsupported constant: $constant";
     }
   }
 }