dart2js cps: Debugging utility and fix idempotency in shrinking reducer.

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 
+/// one continuation. The reference chains for parameters are therefore
 /// meaningless during this pass, until repaired by [AlphaRenamer] at
 /// the end.
 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);
 
@@ skipping 76 matching lines @@
 
     // The optimization is now known to be safe, but it only pays off if
     // one of the callers can inline its target, since otherwise we end up
     // replacing a boolean variable with a labeled break.
     // TODO(asgerf): The labeled break might be better? Evaluate.
     if (!(trueHits == 1 && !trueCall.isEscapingTry ||
           falseHits == 1 && !falseCall.isEscapingTry)) {
       return;
     }
 
-    // Lift any continuations bound inside branchCont so they are in scope at 
+    // Lift any continuations bound inside branchCont so they are in scope at
     // the call sites. When lifting, the parameters of branchCont fall out of
     // scope, so they are added as parameters on each lifted continuation.
     // Schematically:
-    // 
+    //
     //   (LetCont (branchCont (x1, x2, x3) =
     //        (LetCont (innerCont (y) = ...) in
     //        [... innerCont(y') ...]))
     //
     //     =>
     //
     //   (LetCont (innerCont (y, x1, x2, x3) = ...) in
     //   (LetCont (branchCont (x1, x2, x3) =
     //        [... innerCont(y', x1, x2, x3) ...])
-    // 
-    // Parameter objects become shared between branchCont and the lifted 
+    //
+    // Parameter objects become shared between branchCont and the lifted
     // 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) {
@@ skipping 53 matching lines @@
     Expression body = getEffectiveBody(cont);
     if (body is Branch) {
       workSet.add(body);
     }
   }
 }
 
 /// Ensures parameter objects are not shared between different continuations,
 /// akin to alpha-renaming variables so every variable is named uniquely.
 /// For example:
-/// 
+///
 ///   LetCont (k1 x = (return x)) in
 ///   LetCont (k2 x = (InvokeContinuation k3 x)) in ...
-///     => 
+///     =>
 ///   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 TrampolineRecursiveVisitor {
   Map<Parameter, Parameter> renaming = <Parameter, Parameter>{};
 
   processContinuation(Continuation cont) {
@@ skipping 29 matching lines @@
     });
   }
 
   processReference(Reference ref) {
     Parameter target = renaming[ref.definition];
     if (target != null) {
       ref.changeTo(target);
     }
   }
 }