dart2js cps: Remove dart2dart from cps pipeline and clean up.

pkg/compiler/lib/src/dart_backend/backend_ast_nodes.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 backend_ast_nodes;
 
 import '../constants/values.dart' as values;
 import '../dart_types.dart' as types;
 import '../elements/elements.dart' as elements;
 import '../tree/tree.dart' as tree;
@@ skipping 729 matching lines @@
       if (first) {
         first = false;
       } else {
         write(separator);
       }
       callback(x);
     }
   }
 
   void writeOperator(String operator) {
-    write(" "); // TODO(sigurdm,kmillikin): Minimize use of whitespace.
+    write(" ");
     write(operator);
     write(" ");
   }
 
   /// Unfolds singleton blocks and returns the inner statement.
   /// If an empty block is found, the [EmptyStatement] is returned instead.
   Statement unfoldBlocks(Statement stmt) {
     while (stmt is Block && stmt.statements.length == 1) {
       Statement inner = (stmt as Block).statements[0];
       if (definesVariable(inner)) {
@@ skipping 19 matching lines @@
   /// Prints the expression [e].
   void writeExpression(Expression e) {
     writeExp(e, EXPRESSION);
   }
 
   /// Prints [e] as an expression with precedence of at least [minPrecedence],
   /// using parentheses if necessary to raise the precedence level.
   /// Abusing terminology slightly, the function accepts a [Receiver] which
   /// may also be the [SuperReceiver] object.
   void writeExp(Receiver e, int minPrecedence, {beginStmt:false}) {
-    // TODO(kmillikin,sigurdm): it might be faster to use a Visitor.
     void withPrecedence(int actual, void action()) {
       if (actual < minPrecedence) {
         write("(");
         beginStmt = false;
         action();
         write(")");
       } else {
         action();
       }
     }
@@ skipping 12 matching lines @@
           write('(');
         }
         if (e.returnType != null) {
           writeType(e.returnType);
           write(' ');
         }
         if (e.name != null) {
           write(e.name);
         }
         writeParameters(e.parameters);
-        // TODO(sigurdm,kmillikin): Print {} for "return null;"
         if (stmt is Return) {
           write('=> ');
           writeExp(stmt.expression, EXPRESSION);
         } else {
           writeBlock(stmt);
         }
         if (needParen) {
           write(')');
         }
       });
@@ skipping 22 matching lines @@
             write('-1/0.0');
           });
         } else if (v.isNaN) {
           withPrecedence(MULTIPLICATIVE, () {
             write('0/0.0');
           });
         } else {
           write(v.toString());
         }
       } else {
-        // TODO(sigurdm): Use [ConstExp] to generate valid code for any
-        // constant.
         write(e.value.unparse());
       }
     } else if (e is LiteralList) {
       if (e.isConst) {
         write(' const ');
       }
       if (e.typeArgument != null) {
         write('<');
         writeType(e.typeArgument);
         write('>');
@@ skipping 425 matching lines @@
     if (type.typeArguments != null && type.typeArguments.length > 0) {
       write('<');
       writeEach(',', type.typeArguments, writeType);
       write('>');
     }
   }
 
   /// A list of string quotings that the printer may use to quote strings.
   // Ignore multiline quotings for now. Would need to make sure that no
   // newline (potentially prefixed by whitespace) follows the quoting.
-  // TODO(sigurdm,kmillikin): Include multiline quotation schemes.
   static const _QUOTINGS = const <tree.StringQuoting>[
       const tree.StringQuoting(characters.$DQ, raw: false, leftQuoteLength: 1),
       const tree.StringQuoting(characters.$DQ, raw: true, leftQuoteLength: 1),
       const tree.StringQuoting(characters.$SQ, raw: false, leftQuoteLength: 1),
       const tree.StringQuoting(characters.$SQ, raw: true, leftQuoteLength: 1),
   ];
 
   static StringLiteralOutput analyzeStringLiteral(Expression node) {
-    // TODO(sigurdm,kmillikin): This might be a bit too expensive. Benchmark.
     // Flatten the StringConcat tree.
     List parts = []; // Expression or int (char node)
     void collectParts(Expression e) {
       if (e is StringConcat) {
         e.expressions.forEach(collectParts);
       } else if (e is Literal && e.value.isString) {
         for (int char in e.value.primitiveValue) {
           parts.add(char);
         }
       } else {
@@ skipping 236 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);
   }
 }