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

pkg/compiler/lib/src/cps_ir/cps_ir_integrity.dart

 library dart2js.cps_ir_integrity;
 
 import 'cps_ir_nodes.dart';
 import 'cps_ir_nodes_sexpr.dart';
 import '../tracer.dart' as tracer;
 
 /// Dump S-expressions on error if the tracer is enabled.
 ///
 /// Technically this has nothing to do with the tracer, but if you want one
 /// enabled, you typically want the other as well, so we use the same flag.
 const bool ENABLE_DUMP = tracer.TRACE_FILTER_PATTERN != null;
 
 /// Performs integrity checks on the CPS IR.
 ///
 /// To be run for debugging purposes, not for use in production.
 ///
 /// The following integrity checks are performed:
 ///
 /// - References are in scope of their definitions.
 /// - Recursive Continuations and InvokeContinuations are marked as recursive.
 /// - InvokeContinuations have the same arity as their target.
 /// - Reference chains are valid doubly-linked lists.
 /// - Reference chains contain exactly the references that are in the IR.
 /// - Each definition object occurs only once in the IR (no redeclaring).
 /// - Each reference object occurs only once in the IR (no sharing).
 ///
 class CheckCpsIntegrity extends RecursiveVisitor {
 
-  RootNode topLevelNode;
+  FunctionDefinition topLevelNode;
 
   Set<Definition> seenDefinitions = new Set<Definition>();
   Map<Definition, Set<Reference>> seenReferences =
       <Definition, Set<Reference>>{};
 
   Map<Definition, Node> bindings = <Definition, Node>{};
   Set<Continuation> insideContinuations = new Set<Continuation>();
 
   doInScope(Iterable<Definition> defs, Node binding, action()) {
     for (Definition def in defs) {
@@ skipping 31 matching lines @@
     if (node.isReturnContinuation) {
       error('Non-return continuation missing body', node);
     }
     node.parameters.forEach(markAsSeen);
     insideContinuations.add(node);
     doInScope(node.parameters, node, () => visit(node.body));
     insideContinuations.remove(node);
   }
 
   @override
-  visitBody(Body node) {
-    markAsSeen(node.returnContinuation);
-    if (!node.returnContinuation.isReturnContinuation) {
-      error('Return continuation with a body', node);
-    }
-    doInScope([node.returnContinuation], node, () => visit(node.body));
-  }
-
-  @override
   visitLetPrim(LetPrim node) {
     markAsSeen(node.primitive);
     visit(node.primitive);
     doInScope([node.primitive], node, () => visit(node.body));
   }
 
   @override
   visitLetMutable(LetMutable node) {
     markAsSeen(node.variable);
     processReference(node.value);
     doInScope([node.variable], node, () => visit(node.body));
   }
 
   @override
   visitFunctionDefinition(FunctionDefinition node) {
     if (node.thisParameter != null) {
       markAsSeen(node.thisParameter);
     }
     node.parameters.forEach(markAsSeen);
-    if (node.body != null) {
-      doInOptionalScope(node.thisParameter, node,
-          () => doInScope(node.parameters, node, () => visit(node.body)));
+    markAsSeen(node.returnContinuation);
+    if (!node.returnContinuation.isReturnContinuation) {
+      error('Return continuation with a body', node);
     }
-  }
-
-  @override
-  visitConstructorDefinition(ConstructorDefinition node) {
-    if (node.thisParameter != null) {
-      markAsSeen(node.thisParameter);
-    }
-    node.parameters.forEach(markAsSeen);
-    doInScope(node.parameters, node, () {
-      if (node.initializers != null) node.initializers.forEach(visit);
-      if (node.body != null) {
-        doInOptionalScope(node.thisParameter, node, () => visit(node.body));
-      }
-    });
+    doInOptionalScope(node.thisParameter, node,
+        () => doInScope(node.parameters, node,
+            () => doInScope([node.returnContinuation], node,
+                () => visit(node.body))));
   }
 
   doInOptionalScope(Parameter parameter, Node node, action) {
     return (parameter == null)
         ? action()
         : doInScope([parameter], node, action);
   }
 
   @override
-  visitDeclareFunction(DeclareFunction node) {
-    markAsSeen(node.variable);
-    doInScope([node.variable], node, () {
-      visit(node.definition);
-      visit(node.body);
-    });
-  }
-
-  @override
   processReference(Reference reference) {
     if (!bindings.containsKey(reference.definition)) {
       error('Referenced out of scope: ${reference.definition}', reference);
     }
     if (!seenReferences[reference.definition].add(reference)) {
       error('Duplicate use of Reference to ${reference.definition}', reference);
     }
   }
 
   @override
@@ skipping 47 matching lines @@
       }
     } else {
       sexpr = '(Set DUMP_IR flag to enable)';
     }
     throw 'CPS integrity violation in ${topLevelNode.element}:\n'
           '$message\n\n'
           'SExpr dump (offending node marked with **):\n\n'
           '$sexpr\n';
   }
 
-  void check(RootNode node) {
+  void check(FunctionDefinition node) {
     topLevelNode = node;
     visit(node);
 
     // Check this last, so out-of-scope references are not classified as
     // a broken reference chain.
     seenDefinitions.forEach(checkReferenceChain);
   }
 
 }