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

pkg/compiler/lib/src/js_backend/codegen/unsugar.dart

 library dart2js.unsugar_cps;
 
 import '../../cps_ir/cps_ir_nodes.dart';
 
-// TODO(karlklose): share the [ParentVisitor].
-import '../../cps_ir/optimizers.dart';
+import '../../cps_ir/optimizers.dart' show ParentVisitor;
 import '../../constants/expressions.dart';
 import '../../constants/values.dart';
 import '../../elements/elements.dart' show
     ClassElement,
     FieldElement,
     FunctionElement,
     Local,
     ExecutableElement;
 import '../../js_backend/codegen/glue.dart';
 import '../../dart2jslib.dart' show Selector, World;
@@ skipping 100 matching lines @@
     //     body;
     //
     // with
     //
     //     if (identical(arg, null))
     //       return false;
     //     else
     //       body;
     //
     Continuation originalBody = new Continuation(<Parameter>[]);
-    originalBody.body = function.body.body;
+    originalBody.body = function.body;
 
     Continuation returnFalse = new Continuation(<Parameter>[]);
     Primitive falsePrimitive = falseConstant;
     returnFalse.body =
         new LetPrim(falsePrimitive,
             new InvokeContinuation(
-                function.body.returnContinuation, <Primitive>[falsePrimitive]));
+                function.returnContinuation, <Primitive>[falsePrimitive]));
 
     Primitive nullPrimitive = nullConstant;
     Primitive test = new Identical(function.parameters.single, nullPrimitive);
 
     Expression newBody =
         new LetCont.many(<Continuation>[returnFalse, originalBody],
             new LetPrim(nullPrimitive,
                 new LetPrim(test,
                     new Branch(
                         new IsTrue(test),
                         returnFalse,
                         originalBody))));
-    function.body.body = newBody;
+    function.body = newBody;
   }
 
   /// Insert a static call to [function] at the point of [node] with result
   /// [result].
   ///
   /// Rewrite [node] to
   ///
   /// let cont continuation(result) = node
   /// in invoke function arguments continuation
   void insertStaticCall(FunctionElement function, List<Primitive> arguments,
@@ skipping 92 matching lines @@
       // TODO(sra): Move the computation of interceptedClasses to a much later
       // phase and take into account the remaining uses of the interceptor.
       Set<ClassElement> interceptedClasses =
         _glue.getInterceptedClassesOn(selector);
       _glue.registerSpecializedGetInterceptor(interceptedClasses);
       newReceiver = new Interceptor(receiver, interceptedClasses);
       insertLetPrim(newReceiver, node);
     }
 
     node.arguments.insert(0, node.receiver);
-    node.callingConvention = CallingConvention.JS_INTERCEPTED;
-    assert(node.isValid);
     node.receiver = new Reference<Primitive>(newReceiver);
   }
 
   processInvokeMethodDirectly(InvokeMethodDirectly node) {
     if (_glue.isInterceptedMethod(node.target)) {
       Primitive nullPrim = nullConstant;
       insertLetPrim(nullPrim, node);
       node.arguments.insert(0, node.receiver);
       // TODO(sra): `null` is not adequate.  Interceptors project the class
       // hierarchy onto an interceptor hierarchy.  A super call that does a
@@ skipping 18 matching lines @@
     condition.value.unlink();
     node.trueContinuation.unlink();
     node.falseContinuation.unlink();
     parent.body = newNode;
   }
 
   processInterceptor(Interceptor node) {
     _glue.registerSpecializedGetInterceptor(node.interceptedClasses);
   }
 }