dart2dart: Introduce compound assignment and prefix increment in dart_codegen.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_printer.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.
 
 // TODO(asgerf): Include metadata.
 // TODO(asgerf): Include cascade operator.
 library dart_printer;
 
 import '../dart2jslib.dart' as dart2js;
 import '../tree/tree.dart' as tree;
@@ skipping 456 matching lines @@
 
   UnaryOperator(this.operatorName, this.operand) {
     assert(isUnaryOperator(operatorName));
   }
 }
 
 /// Expression of form `e1 + e2`, `e1 - e2`, etc.
 /// 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);
   }
 
   Increment.prefix(Expression expression, String operator)
       : this(expression, operator, true);
 
   Increment.postfix(Expression expression, String operator)
       : this(expression, operator, false);
 }
 
 class Assignment extends Expression {
   static final _operators =
       new Set.from(['=', '|=', '^=', '&=', '<<=', '>>=',
                     '+=', '-=', '*=', '/=', '%=', '~/=']);
 
   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);
   }
 }
 
 class Throw extends Expression {
   final Expression expression;
 
   Throw(this.expression);
 }
 
 class This extends Expression {
   static final This _instance = new This._create();
 
   factory This() => _instance;
   This._create();
 }
 
 // UNPARSER
 
 bool isUnaryOperator(String op) {
   return op == '!' || op == '-' || 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
 const int EXPRESSION = 1;
 const int CONDITIONAL = 2;
 const int LOGICAL_OR = 3;
 const int LOGICAL_AND = 4;
 const int EQUALITY = 6;
 const int RELATIONAL = 7;
 const int BITWISE_OR = 8;
@@ skipping 270 matching lines @@
       }
     } else if (e is LiteralSymbol) {
       write('#');
       write(e.id); // TODO(asgerf): Do we need to escape something here?
     } else if (e is StringConcat) {
       writeStringLiteral(e);
     } else if (e is UnaryOperator) {
       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('!=');
           writeExp(operand.right, RELATIONAL);
         });
       }
       // !(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.
           writeType(operand.type);
         });
       }
       else {
         withPrecedence(UNARY, () {
           writeOperator(e.operatorName);
           writeExp(e.operand, UNARY);
         });
       }
     } 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) {
       withPrecedence(PRIMARY, () {
         writeExp(e.object, PRIMARY, beginStmt: beginStmt);
         write('.');
         write(e.fieldName);
       });
     } else if (e is IndexExpression) {
       withPrecedence(CALLEE, () {
@@ skipping 37 matching lines @@
         write('.');
         write(e.methodName);
         write('(');
         writeEach(',', e.arguments, writeArgument);
         write(')');
       });
     } else if (e is Increment) {
       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) {
       withPrecedence(EXPRESSION, () {
         write('throw ');
         writeExp(e.expression, EXPRESSION);
       });
     } else if (e is This) {
       write('this');
     } else {
@@ skipping 518 matching lines @@
   final StringChunk previous;
   final tree.StringQuoting quoting;
   num cost;
 
   OpenStringChunk(this.previous, this.quoting, this.cost);
 
   StringChunk end(int endIndex) {
     return new StringChunk(previous, quoting, endIndex);
   }
 }