dart2js cps: Maintain parent pointers instead of recomputing them.

pkg/compiler/lib/src/cps_ir/redundant_join.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 dart2js.cps_ir.redundant_join_elimination;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 
 /// Eliminates redundant join points.
 /// 
 /// A redundant join point is a continuation that immediately branches
 /// based on one of its parameters, and that parameter is a constant value
 /// at every invocation. Each invocation is redirected to jump directly
 /// to the branch target.
 /// 
 /// Internally in this pass, parameters are treated as names with lexical
 /// scoping, and a given parameter "name" may be declared by more than
 /// one continuation. The reference chains for parameters are therefore 
 /// meaningless during this pass, until repaired by [AlphaRenamer] at
 /// the end.
-class RedundantJoinEliminator extends RecursiveVisitor implements Pass {
+class RedundantJoinEliminator extends TrampolineRecursiveVisitor implements Pass {
   String get passName => 'Redundant join elimination';
 
   final Set<Branch> workSet = new Set<Branch>();
 
   void rewrite(FunctionDefinition node) {
     visit(node);
 
     while (workSet.isNotEmpty) {
       Branch branch = workSet.first;
       workSet.remove(branch);
@@ skipping 99 matching lines @@
     // continuations. [AlphaRenamer] will clean up at the end of this pass.
     LetCont outerLetCont = branchCont.parent;
     while (branchCont.body is LetCont) {
       LetCont innerLetCont = branchCont.body;
       for (Continuation innerCont in innerLetCont.continuations) {
         innerCont.parameters.addAll(branchCont.parameters);
         for (Reference ref = innerCont.firstRef; ref != null; ref = ref.next) {
           Expression use = ref.parent;
           if (use is InvokeContinuation) {
             for (Parameter param in branchCont.parameters) {
-              use.arguments.add(new Reference<Primitive>(param));
+              use.arguments.add(new Reference<Primitive>(param)..parent = use);
             }
           } else {
             // The branch will be eliminated, so don't worry about updating it.
             assert(use == branch);
           }
         }
       }
       innerLetCont.remove();
       innerLetCont.insertAbove(outerLetCont);
     }
@@ skipping 55 matching lines @@
 ///     => 
 ///   LetCont (k1 x = (return x)) in
 ///   LetCont (k2 x' = (InvokeContinuation k3 x')) in ...
 /// 
 /// After lifting LetConts in the main pass above, parameter objects can have
 /// multiple bindings. Each reference implicitly refers to the binding that
 /// is currently in scope.
 /// 
 /// This returns the IR to its normal form after redundant joins have been
 /// eliminated.
-class AlphaRenamer extends RecursiveVisitor {
+class AlphaRenamer extends TrampolineRecursiveVisitor {
   Map<Parameter, Parameter> renaming = <Parameter, Parameter>{};
 
   processContinuation(Continuation cont) {
     if (cont.isReturnContinuation) return;
 
     List<Parameter> shadowedKeys = <Parameter>[];
     List<Parameter> shadowedValues = <Parameter>[];
 
     // Create new parameters and update the environment.
     for (int i = 0; i < cont.parameters.length; ++i) {
@@ skipping 22 matching lines @@
     });
   }
 
   processReference(Reference ref) {
     Parameter target = renaming[ref.definition];
     if (target != null) {
       ref.changeTo(target);
     }
   }
 }