dart2dart: Introduce compound assignment and prefix increment in dart_codegen.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_printer.dart

Index: sdk/lib/_internal/compiler/implementation/dart_backend/dart_printer.dart
diff --git a/sdk/lib/_internal/compiler/implementation/dart_backend/dart_printer.dart b/sdk/lib/_internal/compiler/implementation/dart_backend/dart_printer.dart
index 50ba9b2dbbd73114785b61e67428d2de0883d557..c69bbd4d3fa30624cbc0eee98df3058caec139ff 100644
--- a/sdk/lib/_internal/compiler/implementation/dart_backend/dart_printer.dart
+++ b/sdk/lib/_internal/compiler/implementation/dart_backend/dart_printer.dart
@@ -474,34 +474,34 @@ class UnaryOperator extends Expression {
 /// This node also represents application of the logical operators && and ||.
 class BinaryOperator extends Expression {
   final Receiver left;
-  final String operatorName;
+  final String operator;
   final Expression right;
 
-  BinaryOperator(this.left, this.operatorName, this.right) {
-    assert(isBinaryOperator(operatorName));
+  BinaryOperator(this.left, this.operator, this.right) {
+    assert(isBinaryOperator(operator));
   }
 }
 
 /// Expression of form `e is T` or `e is! T` or `e as T`.
 class TypeOperator extends Expression {
   final Expression expression;
-  final String operatorName;
+  final String operator;
   final TypeAnnotation type;
 
-  TypeOperator(this.expression, this.operatorName, this.type) {
-    assert(operatorName == 'is'
-        || operatorName == 'as'
-        || operatorName == 'is!');
+  TypeOperator(this.expression, this.operator, this.type) {
+    assert(operator == 'is'
+        || operator == 'as'
+        || operator == 'is!');
   }
 }
 
 class Increment extends Expression {
   final Expression expression;
-  final String operatorName;
+  final String operator;
   final bool isPrefix;
 
-  Increment(this.expression, this.operatorName, this.isPrefix) {
-    assert(operatorName == '++' || operatorName == '--');
+  Increment(this.expression, this.operator, this.isPrefix) {
+    assert(operator == '++' || operator == '--');
     assert(expression.assignable);
   }
 
@@ -518,11 +518,11 @@ class Assignment extends Expression {
                     '+=', '-=', '*=', '/=', '%=', '~/=']);
 
   final Expression left;
-  final String operatorName;
+  final String operator;
   final Expression right;
 
-  Assignment(this.left, this.operatorName, this.right) {
-    assert(_operators.contains(operatorName));
+  Assignment(this.left, this.operator, this.right) {
+    assert(_operators.contains(operator));
     assert(left.assignable);
   }
 }
@@ -548,6 +548,20 @@ bool isUnaryOperator(String op) {
 bool isBinaryOperator(String op) {
   return BINARY_PRECEDENCE.containsKey(op);
 }
+/// True if the given operator can be converted to a compound assignment.
+bool isCompoundableOperator(String op) {
+  switch (BINARY_PRECEDENCE[op]) {
+    case BITWISE_OR:
+    case BITWISE_XOR:
+    case BITWISE_AND:
+    case SHIFT:
+    case ADDITIVE:
+    case MULTIPLICATIVE:
+      return true;
+    default:
+      return false;
+  }
+}
 
 
 // Precedence levels
@@ -838,7 +852,7 @@ class Unparser {
       Receiver operand = e.operand;
       // !(x == y) ==> x != y.
       if (e.operatorName == '!' &&
-          operand is BinaryOperator && operand.operatorName == '==') {
+          operand is BinaryOperator && operand.operator == '==') {
         withPrecedence(EQUALITY, () {
           writeExp(operand.left, RELATIONAL);
           writeOperator('!=');
@@ -847,7 +861,7 @@ class Unparser {
       }
       // !(x is T) ==> x is!T
       else if (e.operatorName == '!' &&
-          operand is TypeOperator && operand.operatorName == 'is') {
+          operand is TypeOperator && operand.operator == 'is') {
         withPrecedence(RELATIONAL, () {
           writeExp(operand.expression, BITWISE_OR, beginStmt: beginStmt);
           write(' is!'); // TODO(asgerf): Minimize use of whitespace.
@@ -861,28 +875,28 @@ class Unparser {
         });
       }
     } else if (e is BinaryOperator) {
-      int precedence = BINARY_PRECEDENCE[e.operatorName];
+      int precedence = BINARY_PRECEDENCE[e.operator];
       withPrecedence(precedence, () {
         // All binary operators are left-associative or non-associative.
         // For each operand, we use either the same precedence level as
         // the current operator, or one higher.
         int deltaLeft = isAssociativeBinaryOperator(precedence) ? 0 : 1;
         writeExp(e.left, precedence + deltaLeft, beginStmt: beginStmt);
-        writeOperator(e.operatorName);
+        writeOperator(e.operator);
         writeExp(e.right, precedence + 1);
       });
     } else if (e is TypeOperator) {
       withPrecedence(RELATIONAL, () {
         writeExp(e.expression, BITWISE_OR, beginStmt: beginStmt);
         write(' ');
-        write(e.operatorName);
+        write(e.operator);
         write(' ');
         writeType(e.type);
       });
     } else if (e is Assignment) {
       withPrecedence(EXPRESSION, () {
         writeExp(e.left, PRIMARY, beginStmt: beginStmt);
-        writeOperator(e.operatorName);
+        writeOperator(e.operator);
         writeExp(e.right, EXPRESSION);
       });
     } else if (e is FieldExpression) {
@@ -940,11 +954,11 @@ class Unparser {
       int precedence = e.isPrefix ? UNARY : POSTFIX_INCREMENT;
       withPrecedence(precedence, () {
         if (e.isPrefix) {
-          write(e.operatorName);
+          write(e.operator);
           writeExp(e.expression, PRIMARY);
         } else {
           writeExp(e.expression, PRIMARY, beginStmt: beginStmt);
-          write(e.operatorName);
+          write(e.operator);
         }
       });
     } else if (e is Throw) {