dart2dart: Introduce compound assignment and prefix increment in dart_codegen.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_tree_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.
 
 library dart_tree_printer;
 
 import 'dart_printer.dart';
 import '../tree/tree.dart' as tree;
 import '../scanner/scannerlib.dart';
 import '../util/util.dart';
@@ skipping 250 matching lines @@
         selector = makeIdentifier(left.fieldName);
         arguments = singleton(makeExpression(exp.right));
       } else if (left is IndexExpression) {
         receiver = makeExp(left.object, PRIMARY, beginStmt: beginStmt);
         selector = new tree.Operator(indexToken);
         arguments = bracketList(',',
             [makeExpression(left.index), makeExpression(exp.right)]);
       } else {
         throw "Unexpected left-hand side of assignment: ${left}";
       }
-      tree.Operator op = new tree.Operator(assignmentToken(exp.operatorName));
+      tree.Operator op = new tree.Operator(assignmentToken(exp.operator));
       result = new tree.SendSet(receiver, selector, op, arguments);
       if (left is Identifier) {
         setElement(result, element, exp);
       }
       precedence = EXPRESSION;
     } else if (exp is BinaryOperator) {
-      precedence = BINARY_PRECEDENCE[exp.operatorName];
+      precedence = BINARY_PRECEDENCE[exp.operator];
       int deltaLeft = isAssociativeBinaryOperator(precedence) ? 0 : 1;
       result = new tree.Send(
           makeExp(exp.left, precedence + deltaLeft, beginStmt: beginStmt),
-          new tree.Operator(binopToken(exp.operatorName)),
+          new tree.Operator(binopToken(exp.operator)),
           singleton(makeExp(exp.right, precedence + 1)));
     } else if (exp is CallFunction) {
       precedence = CALLEE;
       tree.Node selector;
       Expression callee = exp.callee;
       if (callee is Identifier) {
         selector = makeIdentifier(callee.name);
       } else {
         selector = makeExp(callee, CALLEE, beginStmt: beginStmt);
       }
@@ skipping 79 matching lines @@
       } else if (lvalue is FieldExpression) {
         receiver = makeExp(lvalue.object, PRIMARY, beginStmt: innerBeginStmt);
         selector = makeIdentifier(lvalue.fieldName);
       } else if (lvalue is IndexExpression) {
         receiver = makeExp(lvalue.object, PRIMARY, beginStmt: innerBeginStmt);
         selector = new tree.Operator(indexToken);
         argument = makeExpression(lvalue.index);
       } else {
         throw "Unrecognized left-hand side: ${lvalue}";
       }
-      tree.Operator op = new tree.Operator(incrementToken(exp.operatorName));
+      tree.Operator op = new tree.Operator(incrementToken(exp.operator));
       if (exp.isPrefix) {
         precedence = UNARY;
         result = new tree.SendSet.prefix(receiver, selector, op, argument);
       } else {
         precedence = POSTFIX_INCREMENT;
         result = new tree.SendSet.postfix(receiver, selector, op, argument);
       }
     } else if (exp is IndexExpression) {
       precedence = CALLEE;
       result = new tree.Send(
@@ skipping 65 matching lines @@
     } else if (exp is Throw) {
       precedence = EXPRESSION; // ???
       result = new tree.Throw(
           makeExpression(exp.expression),
           throwToken,
           throwToken); // endToken not used by unparser
     } else if (exp is TypeOperator) {
       precedence = RELATIONAL;
       tree.Operator operator;
       tree.Node rightOperand = makeType(exp.type);
-      if (exp.operatorName == 'is!') {
+      if (exp.operator == 'is!') {
         operator = new tree.Operator(typeOpToken('is'));
         rightOperand = new tree.Send(
             rightOperand,
             new tree.Operator(bang),
             blankList());
       } else {
-        operator = new tree.Operator(typeOpToken(exp.operatorName));
+        operator = new tree.Operator(typeOpToken(exp.operator));
       }
       result = new tree.Send(
           makeExp(exp.expression, BITWISE_OR, beginStmt: beginStmt),
           operator,
           singleton(rightOperand));
     } else if (exp is UnaryOperator) {
       precedence = UNARY;
       result = new tree.Send.prefix(
           makeExp(exp.operand, UNARY),
           new tree.Operator(unopToken(exp.operatorName)));
@@ skipping 420 matching lines @@
             printStringChunk(chunk.previous),
             node);
       } else {
         return node;
       }
     }
     return printStringChunk(output.chunk);
   }
 
 }