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

pkg/compiler/lib/src/tree_ir/optimization/pull_into_initializers.dart

 // Copyright (c) 2015, 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 tree_ir.optimization.pull_into_initializers;
+
 import 'optimization.dart' show Pass;
 import '../tree_ir_nodes.dart';
 
 /// Pulls assignment expressions to the top of the function body so they can be
 /// translated into declaration-site variable initializaters.
 ///
 /// This reverts the assignment expression propagation performed by
 /// [StatementRewriter] in cases where it not beneficial.
 ///
 /// EXAMPLE:
@@ skipping 24 matching lines @@
 ///     baz(x, y, y);
 ///
 ///     ==> [StatementRewriter]
 ///
 ///     var y;
 ///     baz(foo(), y = bar(), y);
 ///
 /// [PullIntoInitializers] cannot pull `y` into an initializer because
 /// the impure expressions `foo()` and `bar()` would then be swapped.
 ///
-class PullIntoInitializers implements Pass {
+class PullIntoInitializers extends ExpressionVisitor<Expression>
+                           implements Pass {
   String get passName => 'Pull into initializers';
 
-  void rewrite(RootNode node) {
-    node.replaceEachBody((Statement body) {
-      return new BodyRewriter().rewriteBody(node.parameters, body);
-    });
-  }
-}
-
-class BodyRewriter extends ExpressionVisitor<Expression> {
   Set<Variable> assignedVariables = new Set<Variable>();
 
   /// The fragment between [first] and [last] holds the statements
   /// we pulled into the initializer block.
   ///
   /// The *initializer block* is a sequence of [ExpressionStatement]s with
   /// [Assign]s that we create in the beginning of the body, with the intent
   /// that code generation will convert them to variable initializers.
   ///
   /// The block is empty when both are `null`.
@@ skipping 21 matching lines @@
   /// Pulls assignment expressions from [node] into the initializer block
   /// by calling [append].
   ///
   /// Returns a transformed expression where the pulled assignments are
   /// replaced by variable uses.
   Expression rewriteExpression(Expression node) {
     seenImpure = false;
     return visitExpression(node);
   }
 
-  Statement rewriteBody(List<Variable> parameters, Statement body) {
-    assignedVariables.addAll(parameters);
+  void rewrite(FunctionDefinition node) {
+    Statement body = node.body;
+    assignedVariables.addAll(node.parameters);
 
     // [body] represents the first statement after the initializer block.
     // Repeatedly pull assignment statements into the initializer block.
     while (body is ExpressionStatement) {
       ExpressionStatement stmt = body;
       stmt.expression = rewriteExpression(stmt.expression);
       if (stmt.expression is VariableUse) {
         // The entire expression was pulled into an initializer.
         // This can happen when the expression was an assignment that was
         // pulled into the initializer block and replaced by a variable use.
@@ skipping 14 matching lines @@
     // non-labeled statement and try to pull its initial subexpression.
     Statement entryNode = unfoldLabeledStatements(body);
     if (entryNode is If) {
       entryNode.condition = rewriteExpression(entryNode.condition);
     } else if (entryNode is Return) {
       entryNode.value = rewriteExpression(entryNode.value);
     }
 
     append(body);
     assert(first != null); // Because we just appended the body.
-    return first;
+
+    node.body = first;
   }
 
   void destroyVariableUse(VariableUse node) {
     --node.variable.readCount;
   }
 
   Statement unfoldLabeledStatements(Statement node) {
     while (node is LabeledStatement) {
       node = (node as LabeledStatement).body;
     }
@@ skipping 100 matching lines @@
 
   Expression visitTypeOperator(TypeOperator node) {
     node.value = visitExpression(node.value);
     if (seenImpure) return node;
     rewriteList(node.typeArguments);
     if (!node.isTypeTest) seenImpure = true; // Type cast can throw.
     return node;
   }
 
   void visitInnerFunction(FunctionDefinition node) {
-    node.body = new BodyRewriter().rewriteBody(node.parameters, node.body);
+    new PullIntoInitializers().rewrite(node);
   }
 
   Expression visitFunctionExpression(FunctionExpression node) {
     visitInnerFunction(node.definition);
     return node;
   }
 
   Expression visitGetField(GetField node) {
     node.object = visitExpression(node.object);
     seenImpure = true;
@@ skipping 39 matching lines @@
   }
 
   Expression visitConstant(Constant node) {
     return node;
   }
 
   Expression visitThis(This node) {
     return node;
   }
 
-  Expression visitReifyTypeVar(ReifyTypeVar node) {
-    return node;
-  }
-
   Expression visitNot(Not node) {
     node.operand = visitExpression(node.operand);
     return node;
   }
 
   Expression visitVariableUse(VariableUse node) {
     return node;
   }
 
   Expression visitCreateInvocationMirror(CreateInvocationMirror node) {
     rewriteList(node.arguments);
     return node;
   }
 }