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

pkg/compiler/lib/src/cps_ir/share_interceptors.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.share_interceptors;
 
 import 'optimizers.dart';
 import 'cps_ir_nodes.dart';
 import 'loop_hierarchy.dart';
 import '../constants/values.dart';
@@ skipping 76 matching lines @@
     Interceptor interceptor = node.primitive;
     Primitive input = interceptor.input.definition;
 
     // Try to reuse an existing interceptor for the same input.
     Primitive existing = interceptorFor[input];
     if (existing != null) {
       if (existing is Interceptor) {
         existing.interceptedClasses.addAll(interceptor.interceptedClasses);
       }
       existing.substituteFor(interceptor);
-      interceptor.destroy();
-      node.remove();
+      InteriorNode parent = node.parent;
+      parent.body = node.body;
+      node.body.parent = parent;
+      interceptor.input.unlink();
       return next;
     }
 
     // There is no interceptor obtained from this particular input, but
     // there might one obtained from another input that is known to
     // have the same result, so try to reuse that.
     InterceptorConstantValue constant = interceptor.constantValue;
     if (constant != null) {
       existing = sharedConstantFor[constant];
       if (existing != null) {
         existing.substituteFor(interceptor);
-        interceptor.destroy();
-        node.remove();
+        InteriorNode parent = node.parent;
+        parent.body = node.body;
+        node.body.parent = parent;
+        interceptor.input.unlink();
         return next;
       }
 
       // The interceptor could not be shared. Replace it with a constant.
       Constant constantPrim = new Constant(constant);
       node.primitive = constantPrim;
       constantPrim.hint = interceptor.hint;
       constantPrim.type = interceptor.type;
       constantPrim.substituteFor(interceptor);
-      interceptor.destroy();
+      interceptor.input.unlink();
       sharedConstantFor[constant] = constantPrim;
     } else {
       interceptorFor[input] = interceptor;
     }
 
     // Determine the outermost loop where the input to the interceptor call
     // is available.  Constant interceptors take no input and can thus be
     // hoisted all way to the top-level.
     Continuation referencedLoop = constant != null
         ? null
         : lowestCommonAncestor(loopHeaderFor[input], currentLoopHeader);
     if (referencedLoop != currentLoopHeader) {
       // [referencedLoop] contains the binding for [input], so we cannot hoist
       // the interceptor outside that loop.  Find the loop nested one level
       // inside referencedLoop, and hoist the interceptor just outside that one.
       Continuation loop = currentLoopHeader;
       Continuation enclosing = loopHierarchy.getEnclosingLoop(loop);
       while (enclosing != referencedLoop) {
         assert(loop != null);
         loop = enclosing;
         enclosing = loopHierarchy.getEnclosingLoop(loop);
       }
       assert(loop != null);
 
-      // Move the LetPrim above the loop binding.
+      // Remove LetPrim from its current position.
+      InteriorNode parent = node.parent;
+      parent.body = node.body;
+      node.body.parent = parent;
+
+      // Insert the LetPrim immediately before the loop.
       LetCont loopBinding = loop.parent;
-      node.remove();
-      node.insertAbove(loopBinding);
+      InteriorNode newParent = loopBinding.parent;
+      newParent.body = node;
+      node.body = loopBinding;
+      loopBinding.parent = node;
+      node.parent = newParent;
 
       // A different loop now contains the interceptor.
       loopHeaderFor[node.primitive] = enclosing;
 
       // Register the interceptor as hoisted to that loop, so it will be
       // removed from the environment when it falls out of scope.
       loopHoistedInterceptors
           .putIfAbsent(loop, () => <Primitive>[])
           .add(node.primitive);
     } else if (constant != null) {
@@ skipping 26 matching lines @@
       }
     }
     return c1;
   }
 
   int getDepth(Continuation loop) {
     if (loop == null) return -1;
     return loopHierarchy.loopDepth[loop];
   }
 }