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

pkg/compiler/lib/src/tree_ir/optimization/variable_merger.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.variable_merger;
 
 import 'optimization.dart' show Pass;
 import '../tree_ir_nodes.dart';
 
 /// Merges variables based on liveness and source variable information.
 ///
 /// This phase cleans up artifacts introduced by the translation through CPS,
 /// where each source variable is translated into several copies. The copies
 /// are merged again when they are not live simultaneously.
 class VariableMerger extends RecursiveVisitor implements Pass {
   String get passName => 'Variable merger';
 
-  void rewrite(RootNode node) {
+  void rewrite(FunctionDefinition node) {
     rewriteFunction(node);
-    node.forEachBody(visitStatement);
+    visitStatement(node.body);
   }
 
   @override
   void visitInnerFunction(FunctionDefinition node) {
     rewriteFunction(node);
   }
 
   /// Rewrites the given function.
   /// This is called for the outermost function and inner functions.
-  void rewriteFunction(RootNode node) {
-    node.forEachBody((Statement body) {
-      BlockGraphBuilder builder = new BlockGraphBuilder();
-      builder.build(node.parameters, body);
-      _computeLiveness(builder.blocks);
-      Map<Variable, Variable> subst =
-          _computeRegisterAllocation(builder.blocks, node.parameters);
-      new SubstituteVariables(subst).apply(node);
-    });
+  void rewriteFunction(FunctionDefinition node) {
+    BlockGraphBuilder builder = new BlockGraphBuilder();
+    builder.build(node);
+    _computeLiveness(builder.blocks);
+    Map<Variable, Variable> subst =
+        _computeRegisterAllocation(builder.blocks, node.parameters);
+    new SubstituteVariables(subst).apply(node);
   }
 }
 
 /// A read or write access to a variable.
 class VariableAccess {
   Variable variable;
   bool isRead;
   bool get isWrite => !isRead;
 
   VariableAccess.read(this.variable) : isRead = true;
@@ skipping 52 matching lines @@
   Map<Label, Block> _jumpTarget = <Label, Block>{};
   Block _currentBlock;
   List<Block> blocks = <Block>[];
 
   /// Variables with an assignment that should be treated as final.
   ///
   /// Such variables cannot be merged with any other variables, so we exclude
   /// them from the control-flow graph entirely.
   Set<Variable> _ignoredVariables = new Set<Variable>();
 
-  void build(List<Variable> parameters, Statement body) {
+  void build(FunctionDefinition node) {
     _currentBlock = newBlock();
-    parameters.forEach(write);
-    visitStatement(body);
+    node.parameters.forEach(write);
+    visitStatement(node.body);
   }
 
   @override
   void visitInnerFunction(FunctionDefinition node) {
     // Do nothing. Inner functions are traversed in VariableMerger.
   }
 
   /// Creates a new block with the current exception handler or [catchBlock]
   /// if provided.
   Block newBlock({Block catchBlock}) {
@@ skipping 32 matching lines @@
   /// be excluded from the control-flow graph.
   /// Subsequent calls to [read] and [write] will ignore it.
   void ignoreVariable(Variable variable) {
     _ignoredVariables.add(variable);
   }
 
   visitVariableUse(VariableUse node) {
     read(node.variable);
   }
 
-  visitVariableDeclaration(VariableDeclaration node) {
-    assert(node.variable.isCaptured);
-    visitStatement(node.next);
-  }
-
   visitAssign(Assign node) {
     visitExpression(node.value);
     write(node.variable);
   }
 
   visitIf(If node) {
     visitExpression(node.condition);
     Block afterCondition = _currentBlock;
     branchFrom(afterCondition);
     visitStatement(node.thenStatement);
@@ skipping 54 matching lines @@
     branchFrom(afterCondition);
     visitExpression(node.elseExpression);
   }
 
   visitLogicalOperator(LogicalOperator node) {
     visitExpression(node.left);
     Block afterCondition = _currentBlock;
     branchFrom(afterCondition);
     visitExpression(node.right);
   }
-
-  visitFunctionDeclaration(FunctionDeclaration node) {
-    // The function variable is final, hence cannot be merged.
-    ignoreVariable(node.variable);
-    visitStatement(node.next);
-  }
 }
 
 /// Computes liveness information of the given control-flow graph.
 ///
 /// The results are stored in [Block.liveIn] and [Block.liveOut].
 void _computeLiveness(List<Block> blocks) {
   // We use a LIFO queue as worklist. Blocks are given in AST order, so by
   // inserting them in this order, we initially visit them backwards, which
   // is a good ordering.
   // The choice of LIFO for re-inserted blocks is currently arbitrary,
@@ skipping 223 matching lines @@
   }
 
   Variable replaceWrite(Variable variable) {
     Variable w = mapping[variable];
     if (w == null) return variable; // Skip ignored variables.
     w.writeCount++;
     variable.writeCount--;
     return w;
   }
 
-  void apply(RootNode node) {
+  void apply(FunctionDefinition node) {
     for (int i = 0; i < node.parameters.length; ++i) {
       node.parameters[i] = replaceWrite(node.parameters[i]);
     }
-    node.replaceEachBody(visitStatement);
+    node.body = visitStatement(node.body);
   }
 
   @override
   void visitInnerFunction(FunctionDefinition node) {
     // Do nothing. Inner functions are traversed in VariableMerger.
   }
 
   Expression visitVariableUse(VariableUse node) {
     node.variable = replaceRead(node.variable);
     return node;
@@ skipping 18 matching lines @@
   Statement visitExpressionStatement(ExpressionStatement node) {
     node.expression = visitExpression(node.expression);
     node.next = visitStatement(node.next);
     if (node.expression is VariableUse) {
       VariableUse use = node.expression;
       --use.variable.readCount;
       return node.next;
     }
     return node;
   }
-
-  Statement visitVariableDeclaration(VariableDeclaration node) {
-    // VariableDeclaration is only used for captured variables, which are never
-    // merged, so this is not strictly necessary. But it's nicer if this class
-    // works for arbitrary substitution maps.
-    node.variable = replaceWrite(node.variable);
-    node.value = visitExpression(node.value);
-    node.next = visitStatement(node.next);
-    return node;
-  }
-
 }