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

pkg/compiler/lib/src/tree_ir/tree_ir_tracer.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 tree_ir_tracer;
 
 import 'dart:async' show EventSink;
 import '../tracer.dart';
 import 'tree_ir_nodes.dart';
 
@@ skipping 43 matching lines @@
   void _addGotoStatement(Block target) {
     blocks.last.statements.add(target);
   }
 
   void _addBlock(Block block) {
     block.index = blocks.length;
     block.catcher = catcher;
     blocks.add(block);
   }
 
-  void collect(RootNode node) {
-    node.forEachBody((Statement body) {
-      _addBlock(new Block()..isEntryPoint = true);
-      visitStatement(body);
-    });
+  void collect(FunctionDefinition node) {
+    _addBlock(new Block()..isEntryPoint = true);
+    visitStatement(node.body);
   }
 
   visitLabeledStatement(LabeledStatement node) {
     Block target = new Block(node.label);
     breakTargets[node.label] = target;
     visitStatement(node.body);
     _addBlock(target);
     visitStatement(node.next);
   }
 
@@ skipping 84 matching lines @@
     visitStatement(node.catchBody);
 
     substatements[node.tryBody] = tryBlock;
     substatements[node.catchBody] = catchBlock;
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     _addStatement(node);
     visitStatement(node.next);
   }
-
-  visitFunctionDeclaration(FunctionDeclaration node) {
-    _addStatement(node);
-    visitStatement(node.next);
-  }
-
-  visitVariableDeclaration(VariableDeclaration node) {
-    _addStatement(node);
-    visitStatement(node.next);
-  }
 }
 
 class TreeTracer extends TracerUtil with StatementVisitor {
   String get passName => null;
 
   final EventSink<String> output;
 
   TreeTracer(this.output);
 
   List<Variable> parameters;
   Names names;
   BlockCollector collector;
   int statementCounter;
 
-  void traceGraph(String name, RootNode node) {
-    if (node.isEmpty) return;
+  void traceGraph(String name, FunctionDefinition node) {
     parameters = node.parameters;
     tag("cfg", () {
       printProperty("name", name);
-      printRootNode(node);
+      names = new Names();
+      statementCounter = 0;
+      collector = new BlockCollector();
+      collector.collect(node);
       collector.blocks.forEach(printBlock);
     });
   }
 
-  void printRootNode(RootNode node) {
-    collector = new BlockCollector();
-    names = new Names();
-    statementCounter = 0;
-    collector = new BlockCollector();
-    collector.collect(node);
-    collector.blocks.forEach(printBlock);
-  }
-
   void printBlock(Block block) {
     tag("block", () {
       printProperty("name", block.name);
       printProperty("from_bci", -1);
       printProperty("to_bci", -1);
       printProperty("predecessors", block.predecessors.map((b) => b.name));
       printProperty("successors", block.successors.map((b) => b.name));
       printEmptyProperty("xhandlers");
       printEmptyProperty("flags");
       tag("states", () {
@@ skipping 86 matching lines @@
     String tryTarget = collector.substatements[node.tryBody].name;
     String catchParams = node.catchParameters.map(names.varName).join(',');
     String catchTarget = collector.substatements[node.catchBody].name;
     printStatement(null, 'try $tryTarget catch($catchParams) $catchTarget');
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     printStatement(null, expr(node.expression));
   }
 
-  visitFunctionDeclaration(FunctionDeclaration node) {
-    printStatement(null, 'function ${node.definition.element.name}');
-  }
-
-  visitVariableDeclaration(VariableDeclaration node) {
-    String variable = names.varName(node.variable);
-    String value = expr(node.value);
-    printStatement(null, 'declare $variable = $value');
-  }
-
   visitSetField(SetField node) {
     String object = expr(node.object);
     String field = node.field.name;
     String value = expr(node.value);
     if (SubexpressionVisitor.usesInfixNotation(node.object)) {
       object = '($object)';
     }
     printStatement(null, '$object.$field = $value');
   }
 
@@ skipping 76 matching lines @@
   }
 
   String visitConstant(Constant node) {
     return "${node.value.toStructuredString()}";
   }
 
   String visitThis(This node) {
     return "this";
   }
 
-  String visitReifyTypeVar(ReifyTypeVar node) {
-    return "typevar [${node.typeVariable.name}]";
-  }
-
   static bool usesInfixNotation(Expression node) {
     return node is Conditional ||
            node is LogicalOperator ||
            node is Assign ||
            node is SetField;
   }
 
   String visitConditional(Conditional node) {
     String condition = visitExpression(node.condition);
     String thenExpr = visitExpression(node.thenExpression);
@@ skipping 24 matching lines @@
     if (usesInfixNotation(node.operand)) {
       operand = '($operand)';
     }
     return '!$operand';
   }
 
   String visitFunctionExpression(FunctionExpression node) {
     return "function ${node.definition.element.name}";
   }
 
-  String visitFieldInitializer(FieldInitializer node) {
-    throw "$node should not be visited by $this";
-  }
-
-  String visitSuperInitializer(SuperInitializer node) {
-    throw "$node should not be visited by $this";
-  }
-
   String visitGetField(GetField node) {
     String object = visitExpression(node.object);
     String field = node.field.name;
     if (usesInfixNotation(node.object)) {
       object = '($object)';
     }
     return '$object.$field';
   }
 
   String visitSetField(SetField node) {
@@ skipping 68 matching lines @@
       String prefix = v.element == null ? 'v' : '${v.element.name}_';
       while (name == null || _usedNames.contains(name)) {
         name = "$prefix${_counter++}";
       }
       _names[v] = name;
       _usedNames.add(name);
     }
     return name;
   }
 }