dart2js cps: Add helpers for common IR manipulation.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

 // Copyright (c) 2013, 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.ir_nodes;
 
 import 'dart:collection';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 58 matching lines @@
   void set body(Expression body);
 }
 
 /// An expression that creates new bindings and continues evaluation in
 /// a subexpression.
 ///
 /// The interior expressions are [LetPrim], [LetCont], [LetHandler], and
 /// [LetMutable].
 abstract class InteriorExpression extends Expression implements InteriorNode {
   Expression get next => body;
+
+  /// Removes this expression from its current position in the IR.
+  ///
+  /// The node can be re-inserted elsewhere or remain orphaned.
+  ///
+  /// If orphaned, the caller is responsible for unlinking all references in
+  /// the orphaned node. Use [Reference.unlink] or [Primitive.destroy] for this.
+  void remove() {
+    assert(parent != null);
+    assert(parent.body == this);
+    assert(body.parent == this);
+    parent.body = body;
+    body.parent = parent;
+    parent = null;
+    body = null;
+  }
+
+  /// Inserts this above [node].
+  ///
+  /// This node must be orphaned first.
+  void insertAbove(Expression node) {
+    insertBelow(node.parent);
+  }
+
+  /// Inserts this below [node].
+  ///
+  /// This node must be orphaned first.
+  void insertBelow(InteriorNode newParent) {
+    assert(parent == null);
+    assert(body == null);
+    Expression child = newParent.body;
+    newParent.body = this;
+    this.body = child;
+    child.parent = this;
+    this.parent = newParent;
+  }
 }
 
 /// An expression that passes a continuation to a call.
 abstract class CallExpression extends Expression {
   Reference<Continuation> get continuation;
   Expression get next => continuation.definition.body;
 }
 
 /// An expression without a continuation or a subexpression body.
 ///
@@ skipping 121 matching lines @@
   EffectiveUseIterable get effectiveUses => new EffectiveUseIterable(this);
 
   bool get hasMultipleEffectiveUses {
     Iterator it = effectiveUses.iterator;
     return it.moveNext() && it.moveNext();
   }
 
   bool get hasNoEffectiveUses {
     return effectiveUses.isEmpty;
   }
+
+  /// Unlinks all references contained in this node.
+  void destroy() {
+    assert(hasNoUses);
+    RemovalVisitor.remove(this);
+  }
 }
 
 /// Operands to invocations and primitives are always variables.  They point to
 /// their definition and are doubly-linked into a list of occurrences.
 class Reference<T extends Definition<T>> {
   T definition;
   Reference<T> previous;
   Reference<T> next;
 
   /// A pointer to the parent node. Is null until set by optimization passes.
@@ skipping 1545 matching lines @@
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends RecursiveVisitor {
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (new RemovalVisitor()).visit(node);
   }
 }