Rerun formatter

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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.ir_builder;
 
 import '../closure.dart' as closure;
 import '../common.dart';
 import '../common/names.dart' show Selectors;
 import '../compile_time_constants.dart' show BackendConstantEnvironment;
@@ skipping 1724 matching lines @@
     // scope of the handler.  The mutable bindings are dereferenced at the end
     // of the try block and at the beginning of the catch block, so the
     // variables are unboxed in the catch block and at the join point.
 
     void enterTry(IrBuilder builder) {
       // On entry to try of try/catch, update the builder's state to reflect the
       // variables that have been boxed.
       void interceptJump(JumpCollector collector) {
         collector.enterTry(variables.boxedOnEntry);
       }
+
       builder.state.breakCollectors.forEach(interceptJump);
       builder.state.continueCollectors.forEach(interceptJump);
       interceptJump(builder.state.returnCollector);
     }
 
     void leaveTry(IrBuilder builder) {
       // On exit from try of try/catch, update the builder's state to reflect
       // the variables that are no longer boxed.
       void restoreJump(JumpCollector collector) {
         collector.leaveTry();
       }
+
       builder.state.breakCollectors.forEach(restoreJump);
       builder.state.continueCollectors.forEach(restoreJump);
       restoreJump(builder.state.returnCollector);
     }
 
     List<ir.Parameter> buildCatch(IrBuilder builder, JumpCollector join) {
       // Translate the catch clauses.  Multiple clauses are translated as if
       // they were explicitly cascaded if/else type tests.
 
       // Handlers are always translated as having both exception and stack trace
@@ skipping 100 matching lines @@
       // On entry to the try of try/finally, update the builder's state to
       // relfect the variables that have been boxed.  Then intercept all break,
       // continue, and return jumps out of the try so that they can go to
       // continuations that include the finally code.
       JumpCollector interceptJump(JumpCollector collector) {
         JumpCollector result =
             new ForwardJumpCollector(environment, target: collector.target);
         result.enterTry(variables.boxedOnEntry);
         return result;
       }
+
       savedBreaks = builder.state.breakCollectors;
       savedContinues = builder.state.continueCollectors;
       savedReturn = builder.state.returnCollector;
 
       builder.state.breakCollectors =
           newBreaks = savedBreaks.map(interceptJump).toList();
       builder.state.continueCollectors =
           newContinues = savedContinues.map(interceptJump).toList();
       builder.state.returnCollector = newReturn =
           new ForwardJumpCollector(environment, hasExtraArgument: true)
             ..enterTry(variables.boxedOnEntry);
     }
 
     void leaveTry(IrBuilder builder) {
       // On exit from the try of try/finally, update the builder's state to
       // reflect the variables that are no longer boxed and restore the
       // original, unintercepted break, continue, and return targets.
       void restoreJump(JumpCollector collector) {
         collector.leaveTry();
       }
+
       newBreaks.forEach(restoreJump);
       newContinues.forEach(restoreJump);
       newReturn.leaveTry();
       builder.state.breakCollectors = savedBreaks;
       builder.state.continueCollectors = savedContinues;
       builder.state.returnCollector = savedReturn;
     }
 
     List<ir.Parameter> buildCatch(IrBuilder builder, JumpCollector join) {
       // The catch block of the try/catch used for try/finally is the finally
@@ skipping 13 matching lines @@
       List<ir.Continuation> exits = <ir.Continuation>[join.continuation];
       void addJump(
           JumpCollector newCollector, JumpCollector originalCollector) {
         if (newCollector.isEmpty) return;
         IrBuilder builder = makeDelimitedBuilder(newCollector.environment);
         buildFinallyBlock(builder);
         if (builder.isOpen) builder.jumpTo(originalCollector);
         newCollector.continuation.body = builder.root;
         exits.add(newCollector.continuation);
       }
+
       for (int i = 0; i < newBreaks.length; ++i) {
         addJump(newBreaks[i], savedBreaks[i]);
       }
       for (int i = 0; i < newContinues.length; ++i) {
         addJump(newContinues[i], savedContinues[i]);
       }
       if (!newReturn.isEmpty) {
         IrBuilder builder = makeDelimitedBuilder(newReturn.environment);
         ir.Primitive value = builder.environment.discard(1);
         buildFinallyBlock(builder);
@@ skipping 979 matching lines @@
       this.sourceInformation});
 }
 
 class SwitchCaseInfo {
   final SubbuildFunction buildCondition;
   final SubbuildFunction buildBody;
   final SourceInformation sourceInformation;
 
   SwitchCaseInfo(this.buildCondition, this.buildBody, this.sourceInformation);
 }