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

pkg/compiler/lib/src/cps_ir/redundant_join.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 dart2js.cps_ir.redundant_join_elimination;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 
 /// Eliminates redundant join points.
@@ skipping 46 matching lines @@
     while (true) {
       Node parent = node.parent;
       if (parent is LetCont) {
         node = parent;
       } else {
         return parent;
       }
     }
   }
 
+  /// Removes [movedNode] from its current position and inserts it
+  /// before [target].
+  void moveToBefore(Expression target, LetCont movedNode) {
+    if (movedNode.parent != null) {
+      movedNode.parent.body = movedNode.body;
+      movedNode.body.parent = movedNode.parent;
+    }
+    InteriorNode parent = target.parent;
+    parent.body = movedNode;
+    movedNode.body = target;
+    target.parent = movedNode;
+    movedNode.parent = parent;
+  }
+
   void rewriteBranch(Branch branch) {
     InteriorNode parent = getEffectiveParent(branch);
     if (parent is! Continuation) return;
     Continuation branchCont = parent;
 
     // Other optimizations take care of single-use continuations.
     if (!branchCont.hasMultipleUses) return;
 
     // It might be beneficial to rewrite calls to recursive continuations,
     // but we currently do not support this.
@@ skipping 63 matching lines @@
           if (use is InvokeContinuation) {
             for (Parameter param in branchCont.parameters) {
               use.arguments.add(new Reference<Primitive>(param));
             }
           } else {
             // The branch will be eliminated, so don't worry about updating it.
             assert(use == branch);
           }
         }
       }
-      innerLetCont.remove();
-      innerLetCont.insertAbove(outerLetCont);
+      moveToBefore(outerLetCont, innerLetCont);
     }
 
     assert(branchCont.body == branch);
 
     Continuation trueCont = branch.trueContinuation.definition;
     Continuation falseCont = branch.falseContinuation.definition;
 
     assert(branchCont != trueCont);
     assert(branchCont != falseCont);
 
@@ skipping 14 matching lines @@
       }
       assert(branchCont.firstRef != reference);
     }
 
     // Remove the now-unused branchCont continuation.
     assert(branchCont.hasNoUses);
     branch.trueContinuation.unlink();
     branch.falseContinuation.unlink();
     outerLetCont.continuations.remove(branchCont);
     if (outerLetCont.continuations.isEmpty) {
-      outerLetCont.remove();
+      InteriorNode parent = outerLetCont.parent;
+      parent.body = outerLetCont.body;
+      outerLetCont.body.parent = parent;
     }
 
     // We may have created new redundant join points in the two branches.
     enqueueContinuation(trueCont);
     enqueueContinuation(falseCont);
   }
 
   void enqueueContinuation(Continuation cont) {
     Expression body = getEffectiveBody(cont);
     if (body is Branch) {
@@ skipping 54 matching lines @@
     });
   }
 
   processReference(Reference ref) {
     Parameter target = renaming[ref.definition];
     if (target != null) {
       ref.changeTo(target);
     }
   }
 }