dartfmt pkg/compiler

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 TrampolineRecursiveVisitor
-      implements Pass {
+    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 69 matching lines @@
         ++falseHits;
         falseCall = invoke;
       }
     }
 
     // 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)) {
+        falseHits == 1 && !falseCall.isEscapingTry)) {
       return;
     }
 
     // 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
     // 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.argumentRefs.add(
-                  new Reference<Primitive>(param)..parent = use);
+              use.argumentRefs
+                  .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 98 matching lines @@
     });
   }
 
   processReference(Reference ref) {
     Parameter target = renaming[ref.definition];
     if (target != null) {
       ref.changeTo(target);
     }
   }
 }