dart2js cps: Maintain parent pointers instead of recomputing them.

pkg/compiler/lib/src/cps_ir/insert_refinements.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.optimization.insert_refinements;
 
 import 'optimizers.dart' show Pass;
-import 'shrinking_reductions.dart' show ParentVisitor;
 import 'cps_ir_nodes.dart';
 import '../types/constants.dart';
 import '../constants/values.dart';
 import '../common/names.dart';
 import '../universe/universe.dart';
 import '../elements/elements.dart';
 import '../types/types.dart' show TypeMask;
 import 'type_mask_system.dart';
 
 /// Inserts [Refinement] nodes in the IR to allow for sparse path-sensitive
 /// type analysis in the [TypePropagator] pass.
 ///
 /// Refinement nodes are inserted at the arms of a [Branch] node with a
 /// condition of form `x is T` or `x == null`.
 ///
 /// Refinement nodes are inserted after a method invocation to refine the
 /// receiver to the types that can respond to the given selector.
-class InsertRefinements extends RecursiveVisitor implements Pass {
+class InsertRefinements extends TrampolineRecursiveVisitor implements Pass {
   String get passName => 'Insert refinement nodes';
 
   final TypeMaskSystem types;
 
   /// Maps unrefined primitives to its refinement currently in scope (if any).
   final Map<Primitive, Refinement> refinementFor = <Primitive, Refinement>{};
 
   InsertRefinements(this.types);
 
   void rewrite(FunctionDefinition node) {
-    new ParentVisitor().visit(node);
     visit(node.body);
   }
 
   /// Updates references to refer to the refinement currently in scope.
   void processReference(Reference node) {
     Refinement refined = refinementFor[node.definition];
     if (refined != null) {
       node.changeTo(refined);
     }
   }
@@ skipping 25 matching lines @@
     let.insertAbove(use);
   }
 
   Primitive unfoldInterceptor(Primitive prim) {
     return prim is Interceptor ? prim.input.definition : prim;
   }
 
   /// Enqueues [cont] for processing in a context where [refined] is the
   /// current refinement for its value.
   void pushRefinement(Continuation cont, Refinement refined) {
+    refined.value.parent = refined;

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

Is this necessary here?  It looks like the constructor for Refinement sets
value.parent appropriately and pushRefinement is always passed a newly
constructed Refinement.

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

You're right, done.

     Primitive value = refined.effectiveDefinition;
     Primitive currentRefinement = refinementFor[value];
     pushAction(() {
       refinementFor[value] = currentRefinement;
       if (refined.hasNoUses) {
         // Clean up refinements that are not used.
         refined.destroy();
       } else {
         LetPrim let = new LetPrim(refined);
         refined.parent = let;
@@ skipping 21 matching lines @@
     // here is also in scope inside the continuations.
     sinkContinuationToUse(cont, node);
 
     if (node.selector.isClosureCall) {
       // Do not try to refine the receiver of closure calls; the class world
       // does not know about closure classes.
       push(cont);
     } else {
       // Filter away receivers that throw on this selector.
       TypeMask type = types.receiverTypeFor(node.selector, node.mask);
-      pushRefinement(cont, new Refinement(receiver, type));
+      Refinement refinement = new Refinement(receiver, type);
+      pushRefinement(cont, refinement);
     }
   }
 
   CallExpression getCallWithResult(Primitive prim) {
     if (prim is Parameter && prim.parent is Continuation) {
       Continuation cont = prim.parent;
       if (cont.hasExactlyOneUse && cont.firstRef.parent is CallExpression) {
         return cont.firstRef.parent;
       }
     }
@@ skipping 80 matching lines @@
            cont.firstRef.parent is Branch)) {
         // Do not push the continuation here.
         // visitInvokeMethod and visitBranch will do that.
       } else {
         push(cont);
       }
     }
     return node.body;
   }
 }