Revert "dart2js cps: Add helpers for common IR manipulation."

pkg/compiler/lib/src/cps_ir/insert_refinements.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 cps_ir.optimization.insert_refinements;
 
 import 'optimizers.dart' show Pass;
 import 'shrinking_reductions.dart' show ParentVisitor;
 import 'cps_ir_nodes.dart';
 import '../types/constants.dart';
@@ skipping 50 matching lines @@
     assert(!cont.isRecursive);
     LetCont let = cont.parent;
     InteriorNode useParent = use.parent;
     if (useParent == let) return;
     if (let.continuations.length > 1) {
       // Create a new LetCont binding only this continuation.
       let.continuations.remove(cont);
       let = new LetCont(cont, null);
       cont.parent = let;
     } else {
-      let.remove(); // Reuse the existing LetCont.
+      // Remove LetCont from current position.
+      InteriorNode letParent = let.parent;
+      letParent.body = let.body;
+      let.body.parent = letParent;
     }
-    let.insertAbove(use);
+
+    // Insert LetCont before use.
+    useParent.body = let;
+    let.body = use;
+    use.parent = let;
+    let.parent = useParent;
   }
 
   Primitive unfoldInterceptor(Primitive prim) {
     return prim is Interceptor ? prim.input.definition : prim;
   }
 
   /// Enqueues [cont] for processing in a context where [refined] is the
   /// current refinement for its value.
   void pushRefinement(Continuation cont, Refinement refined) {
     Primitive value = refined.effectiveDefinition;
     Primitive currentRefinement = refinementFor[value];
     pushAction(() {
       refinementFor[value] = currentRefinement;
       if (refined.hasNoUses) {
         // Clean up refinements that are not used.
-        refined.destroy();
+        refined.value.unlink();
       } else {
-        LetPrim let = new LetPrim(refined);
-        refined.parent = let;
-        let.insertBelow(cont);
+        cont.body = new LetPrim(refined, cont.body);
+        refined.parent = cont.body;
+        refined.value.parent = refined;
       }
     });
     push(cont);
     pushAction(() {
       refinementFor[value] = refined;
     });
   }
 
   void visitInvokeMethod(InvokeMethod node) {
     Continuation cont = node.continuation.definition;
@@ skipping 111 matching lines @@
            cont.firstRef.parent is Branch)) {
         // Do not push the continuation here.
         // visitInvokeMethod and visitBranch will do that.
       } else {
         push(cont);
       }
     }
     return node.body;
   }
 }