dart2js cps: Add helpers for common IR manipulation.

pkg/compiler/lib/src/cps_ir/mutable_ssa.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.mutable_ssa;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 
 /// Determines which mutable variables should be rewritten to phi assignments
@@ skipping 96 matching lines @@
 
   bool shouldRewrite(MutableVariable variable) {
     return !analysis.hasAssignmentInTry.contains(variable);
   }
 
   bool isJoinContinuation(Continuation cont) {
     return !cont.hasExactlyOneUse ||
            cont.firstRef.parent is InvokeContinuation;
   }
 
-  void removeNode(InteriorNode node) {
-    InteriorNode parent = node.parent;
-    parent.body = node.body;
-    node.body.parent = parent;
-  }
-
   /// If some useful source information is attached to exactly one of the
   /// two definitions, the information is copied onto the other.
   void mergeHints(MutableVariable variable, Primitive value) {
     if (variable.hint == null) {
       variable.hint = value.hint;
     } else if (value.hint == null) {
       value.hint = variable.hint;
     }
   }
 
   /// Processes a basic block, replacing mutable variable uses with direct
   /// references to their values.
   ///
   /// [environment] is the current value of each mutable variable. The map
   /// will be mutated during the processing.
   ///
   /// Continuations to be processed are put on the stack for later processing.
   void processBlock(Expression node,
                     Map<MutableVariable, Primitive> environment) {
-    for (; node is! TailExpression; node = node.next) {
+    Expression next = node.next;
+    for (; node is! TailExpression; node = next, next = node.next) {
       if (node is LetMutable && shouldRewrite(node.variable)) {
         // Put the new mutable variable on the stack while processing the body,
         // and pop it off again when done with the body.
         mutableVariables.add(node.variable);
         stack.add(new VariableItem());
 
         // Put the initial value into the environment.
         Primitive value = node.value.definition;
         environment[node.variable] = value;
 
         // Preserve variable names.
         mergeHints(node.variable, value);
 
         // Remove the mutable variable binding.
         node.value.unlink();
-        removeNode(node);
+        node.remove();
       } else if (node is LetPrim && node.primitive is SetMutable) {
         SetMutable setter = node.primitive;
         MutableVariable variable = setter.variable.definition;
         if (shouldRewrite(variable)) {
           // As above, update the environment, preserve variables and remove
           // the mutable variable assignment.
           environment[variable] = setter.value.definition;
           mergeHints(variable, setter.value.definition);
           setter.value.unlink();
-          removeNode(node);
+          node.remove();
         }
       } else if (node is LetPrim && node.primitive is GetMutable) {
         GetMutable getter = node.primitive;
         MutableVariable variable = getter.variable.definition;
         if (shouldRewrite(variable)) {
           // Replace with the reaching definition from the environment.
           Primitive value = environment[variable];
           value.substituteFor(getter);
           mergeHints(variable, value);
-          removeNode(node);
+          node.remove();
         }
       } else if (node is LetCont) {
         // Create phi parameters for each join continuation bound here, and put
         // them on the stack for later processing.
         // Note that non-join continuations are handled at the use-site.
         for (Continuation cont in node.continuations) {
           if (!isJoinContinuation(cont)) continue;
           // Create a phi parameter for every mutable variable in scope.
           // At the same time, build the environment to use for processing
           // the continuation (mapping mutables to phi parameters).
@@ skipping 58 matching lines @@
 class VariableItem extends StackItem {}
 
 /// Represents a yet unprocessed continuation together with the
 /// environment in which to process it.
 class ContinuationItem extends StackItem {
   final Continuation continuation;
   final Map<MutableVariable, Primitive> environment;
 
   ContinuationItem(this.continuation, this.environment);
 }