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 23 matching lines @@
 ///   Continuation loop = cps.beginLoop();
 ///   var result = cps.invokeMethod(receiver, selector, ...);
 ///   cps.ifFalsy(result).invokeContinuation(exit, []);
 ///   cps.continueLoop(loop);
 ///
 class CpsFragment {
   /// The root of the IR built using this fragment.
   Expression root;
 
   /// Node whose body is the hole in this CPS fragment. May be null.
   InteriorNode context;

[Kevin Millikin (Google), 2015/10/05 12:04:37]

It's probably not worth changing, but this name is a bit off.  'Context' is
usually just a term with a hole somewhere.  'Frame' is sometimes used for a term
which has a hole as an immediate subterm (so a context can be represented as a
stack of frames).  Of course, frame is overloaded but so is context.  I used
'current' in the IR builder.

[asgerf, 2015/10/12 13:18:31]

I can't find a name I really like. I also considered 'head' and 'tail'.

 
   /// Source information to attach to every IR node created in the fragment.
   SourceInformation sourceInformation;
 
   CpsFragment([this.sourceInformation, this.context]);
 
   bool get isOpen => root == null || context != null;
   bool get isClosed => !isOpen;
   bool get isEmpty => root == null;
 
   /// Asserts that the fragment is non-empty and closed and returns the IR that
   /// was built.
   Expression get result {
     assert(!isEmpty);
     assert(isClosed);
     return root;
   }
 
   /// Put the given expression into the fragment's hole.
   ///
   /// 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);
+  }
 }