dart2js cps: Maintain parent pointers instead of recomputing them.

pkg/compiler/lib/src/cps_ir/cps_fragment.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 cps_ir.cps_fragment;
 
 import 'cps_ir_nodes.dart';
 import '../constants/values.dart';
 import '../universe/selector.dart' show Selector;
 import '../types/types.dart' show TypeMask;
 import '../io/source_information.dart';
 import '../elements/elements.dart';
+import 'parent_visitor.dart';
 
 /// Builds a CPS fragment that can be plugged into another CPS term.
 ///
 /// A CPS fragment contains a CPS term, possibly with a "hole" in it denoting
 /// where to insert new IR nodes. We say a fragment is "open" if it has such
 /// a hole. Otherwise, the fragment is "closed" and cannot be extended further.
 ///
 /// This class is designed for building non-trivial CPS terms in a readable and
 /// non-error prone manner. It is not designed to manipulate existing IR nodes,
 /// nor is it intended to shield the user from every complexity in the IR.
@@ skipping 53 matching lines @@
   ///
   /// Afterwards the fragment is closed and cannot be extended until a new
   /// [context] is set.
   void put(Expression node) {
     assert(root == null || context != null); // We must put the node somewhere.
     if (root == null) {
       root = node;
     }
     if (context != null) {
       context.body = node;
+      node.parent = context;
     }
     context = null;
   }
 
   /// Bind a primitive. Returns the same primitive for convenience.
   Primitive letPrim(Primitive prim) {
     assert(prim != null);
     LetPrim let = new LetPrim(prim);
     put(let);
     context = let;
@@ skipping 194 matching lines @@
   void setMutable(MutableVariable variable, Primitive value) {
     letPrim(new SetMutable(variable, value));
   }
 
   /// Declare a new mutable variable.
   void letMutable(MutableVariable variable, Primitive initialValue) {
     LetMutable let = new LetMutable(variable, initialValue);
     put(let);
     context = let;
   }
+
+  void insertBelow(InteriorNode node) {
+    assert(isOpen);
+    if (isEmpty) return;
+    Expression child = node.body;
+    node.body = root;
+    root.parent = node;
+    context.body = child;
+    child.parent = context;
+    root = context = null;
+  }
+
+  void insertAbove(InteriorExpression node) {
+    insertBelow(node.parent);
+  }
 }