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

pkg/compiler/lib/src/tree_ir/optimization/statement_rewriter.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.
 
-part of tree_ir.optimization;
+library tree_ir.optimization.statement_rewriter;
+
+import 'optimization.dart' show Pass;
+import '../tree_ir_nodes.dart';
 
 /**
  * Performs the following transformations on the tree:
  * - Assignment inlining
  * - Assignment expression propagation
  * - If-to-conditional conversion
  * - Flatten nested ifs
  * - Break inlining
  * - Redirect breaks
  *
@@ skipping 86 matching lines @@
  *     ==>
  *   {... jump L1 ...}
  *
  * This may trigger a flattening of nested ifs in case the eliminated label
  * separated two ifs.
  */
 class StatementRewriter extends Transformer implements Pass {
   String get passName => 'Statement rewriter';
 
   @override
-  void rewrite(RootNode node) {
-    node.replaceEachBody(visitStatement);
+  void rewrite(FunctionDefinition node) {
+    node.body = visitStatement(node.body);
   }
 
   /// True if targeting Dart.
   final bool isDartMode;
 
   /// The most recently evaluated impure expressions, with the most recent
   /// expression being last.
   ///
   /// Most importantly, this contains [Assign] expressions that we attempt to
   /// inline at their use site. It also contains other impure expressions that
@@ skipping 138 matching lines @@
   }
 
   /// Returns true if [exp] has no side effects and has a constant value within
   /// any given activation of the enclosing method.
   bool isEffectivelyConstant(Expression exp) {
     // TODO(asgerf): Can be made more aggressive e.g. by checking conditional
     // expressions recursively. Determine if that is a valuable optimization
     // and/or if it is better handled at the CPS level.
     return exp is Constant ||
            exp is This ||
-           exp is ReifyTypeVar ||
            exp is CreateInvocationMirror ||
            exp is InvokeStatic && exp.isEffectivelyConstant ||
            exp is VariableUse && constantEnvironment.containsKey(exp.variable);
   }
 
   /// True if [node] is an assignment that can be propagated as a constant.
   bool isEffectivelyConstantAssignment(Expression node) {
     return node is Assign &&
            node.variable.writeCount == 1 &&
            isEffectivelyConstant(node.value);
@@ skipping 41 matching lines @@
     //
     //     { x = foo(); bar(x) } ==> bar(x = foo()) ==> bar(foo())
     //
     if (node.variable.readCount == 0) {
       --node.variable.writeCount;
       return node.value;
     }
     return node;
   }
 
-  Statement visitVariableDeclaration(VariableDeclaration node) {
-    if (isEffectivelyConstant(node.value)) {
-      node.next = visitStatement(node.next);
-    } else {
-      inEmptyEnvironment(() {
-        node.next = visitStatement(node.next);
-      });
-    }
-    node.value = visitExpression(node.value);
-    return node;
-  }
-
   /// Process nodes right-to-left, the opposite of evaluation order in the case
   /// of argument lists..
   void _rewriteList(List<Node> nodes) {
     for (int i = nodes.length - 1; i >= 0; --i) {
       nodes[i] = visitExpression(nodes[i]);
     }
   }
 
   Expression visitInvokeStatic(InvokeStatic node) {
     _rewriteList(node.arguments);
@@ skipping 59 matching lines @@
   Expression visitNot(Not node) {
     node.operand = visitExpression(node.operand);
     return node;
   }
 
   Expression visitFunctionExpression(FunctionExpression node) {
     new StatementRewriter.nested(this).rewrite(node.definition);
     return node;
   }
 
-  Statement visitFunctionDeclaration(FunctionDeclaration node) {
-    new StatementRewriter.nested(this).rewrite(node.definition);
-    node.next = visitStatement(node.next);
-    return node;
-  }
-
   Statement visitReturn(Return node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
   Statement visitThrow(Throw node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
@@ skipping 105 matching lines @@
   }
 
   Expression visitConstant(Constant node) {
     return node;
   }
 
   Expression visitThis(This node) {
     return node;
   }
 
-  Expression visitReifyTypeVar(ReifyTypeVar node) {
-    return node;
-  }
-
   Expression visitLiteralList(LiteralList node) {
     _rewriteList(node.values);
     return node;
   }
 
   Expression visitLiteralMap(LiteralMap node) {
     // Process arguments right-to-left, the opposite of evaluation order.
     for (LiteralMapEntry entry in node.entries.reversed) {
       entry.value = visitExpression(entry.value);
       entry.key = visitExpression(entry.key);
@@ skipping 353 matching lines @@
 }
 
 /// Result of combining two expressions that do not affect reference counting.
 class GenericCombinedExpressions implements CombinedExpressions {
   Expression combined;
 
   GenericCombinedExpressions(this.combined);
 
   void uncombine() {}
 }