Revert "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(InteriorExpression 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);
   }
 }