Refactor the try statement analysis results.

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 '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 398 matching lines @@
   toString() => 'ThisParameterLocal($executableContext)';
 }
 
 /// A factory for building the cps IR.
 ///
 /// [DartIrBuilder] and [JsIrBuilder] implement nested functions and captured
 /// variables in different ways.
 abstract class IrBuilder {
   IrBuilder _makeInstance();
 
-  // TODO(johnniwinther): Remove this from the [IrBuilder].
-  /// A map from TryStatements in the AST to their analysis information.
-  ///
-  /// This includes which variables should be copied into [ir.MutableVariable]s
-  /// on entry to the try and copied out on exit.
-  Map<ast.TryStatement, TryStatementInfo> get tryStatements;
-
-  /// The set of local variables that will spend their lifetime as
-  /// [ir.MutableVariable]s due to being captured by a nested function.
-  Set<Local> get mutableCapturedVariables;
-
   /// True if [local] should currently be accessed from a [ir.MutableVariable].
   bool isInMutableVariable(Local local);
 
   /// Creates a [ir.MutableVariable] for the given local.
   void makeMutableVariable(Local local);
 
   /// Remove an [ir.MutableVariable] for a local.
   ///
   /// Subsequent access to the local will be direct rather than through the
   /// mutable variable.  This is used for variables that do not spend their
@@ skipping 1146 matching lines @@
     // variables are unboxed in the catch block and at the join point.
     JumpCollector join = new ForwardJumpCollector(environment);
     IrBuilder tryCatchBuilder = makeDelimitedBuilder();
 
     // Variables that are boxed due to being captured in a closure are boxed
     // for their entire lifetime, and so they do not need to be boxed on
     // entry to any try block.  They are not filtered out before this because
     // we can not identify all of them in the same pass where we identify the
     // variables assigned in the try (they may be captured by a closure after
     // the try statement).
-    Iterable<LocalVariableElement> boxedOnEntry =
-        tryStatementInfo.boxedOnEntry.where((LocalVariableElement variable) {
-      return !tryCatchBuilder.mutableCapturedVariables.contains(variable);
-    });
-    for (LocalVariableElement variable in boxedOnEntry) {
+    for (LocalVariableElement variable in tryStatementInfo.boxedOnEntry) {
       assert(!tryCatchBuilder.isInMutableVariable(variable));
       ir.Primitive value = tryCatchBuilder.buildLocalGet(variable);
       tryCatchBuilder.makeMutableVariable(variable);
       tryCatchBuilder.declareLocalVariable(variable, initialValue: value);
     }
 
     IrBuilder tryBuilder = tryCatchBuilder.makeDelimitedBuilder();
 
     void interceptJumps(JumpCollector collector) {
-      collector.enterTry(boxedOnEntry);
+      collector.enterTry(tryStatementInfo.boxedOnEntry);
     }
     void restoreJumps(JumpCollector collector) {
       collector.leaveTry();
     }
     tryBuilder.state.breakCollectors.forEach(interceptJumps);
     tryBuilder.state.continueCollectors.forEach(interceptJumps);
     buildTryBlock(tryBuilder);
     if (tryBuilder.isOpen) {
       interceptJumps(join);
       tryBuilder.jumpTo(join);
       restoreJumps(join);
     }
     tryBuilder.state.breakCollectors.forEach(restoreJumps);
     tryBuilder.state.continueCollectors.forEach(restoreJumps);
 
     IrBuilder catchBuilder = tryCatchBuilder.makeDelimitedBuilder();
-    for (LocalVariableElement variable in boxedOnEntry) {
+    for (LocalVariableElement variable in tryStatementInfo.boxedOnEntry) {
       assert(catchBuilder.isInMutableVariable(variable));
       ir.Primitive value = catchBuilder.buildLocalGet(variable);
       // Note that we remove the variable from the set of mutable variables
       // here (and not above for the try body).  This is because the set of
       // mutable variables is global for the whole function and not local to
       // a delimited builder.
       catchBuilder.removeMutableVariable(variable);
       catchBuilder.environment.update(variable, value);
     }
 
@@ skipping 257 matching lines @@
     return join.continuation.parameters.last;
   }
 }
 
 /// Shared state between DartIrBuilders within the same method.
 class DartIrBuilderSharedState {
   /// Maps local variables to their corresponding [MutableVariable] object.
   final Map<Local, ir.MutableVariable> local2mutable =
       <Local, ir.MutableVariable>{};
 
-  // Move this to the IrBuilderVisitor.
-  final DartCapturedVariables capturedVariables;
-
   /// Creates a [MutableVariable] for the given local.
   void makeMutableVariable(Local local) {
     ir.MutableVariable variable =
         new ir.MutableVariable(local.executableContext, local);
     local2mutable[local] = variable;
   }
 
   /// [MutableVariable]s that should temporarily be treated as registers.
   final Set<Local> registerizedMutableVariables = new Set<Local>();
 
-  DartIrBuilderSharedState(this.capturedVariables) {
-    capturedVariables.capturedVariables.forEach(makeMutableVariable);
+  DartIrBuilderSharedState(Set<Local> capturedVariables) {
+    capturedVariables.forEach(makeMutableVariable);
   }
 }
 
 /// Dart-specific subclass of [IrBuilder].
 ///
 /// Inner functions are represented by a [FunctionDefinition] with the
 /// IR for the inner function nested inside.
 ///
 /// Captured variables are translated to ref cells (see [MutableVariable])
 /// using [GetMutableVariable] and [SetMutableVariable].
 class DartIrBuilder extends IrBuilder {
   final DartIrBuilderSharedState dartState;
 
   IrBuilder _makeInstance() => new DartIrBuilder._blank(dartState);
   DartIrBuilder._blank(this.dartState);
 
   DartIrBuilder(ConstantSystem constantSystem,
                 ExecutableElement currentElement,
-                DartCapturedVariables capturedVariables)
+                Set<Local> capturedVariables)
       : dartState = new DartIrBuilderSharedState(capturedVariables) {
     _init(constantSystem, currentElement);
   }
 
-  Map<ast.TryStatement, TryStatementInfo> get tryStatements {
-    return dartState.capturedVariables.tryStatements;
-  }
-
-  Set<Local> get mutableCapturedVariables {
-    return dartState.capturedVariables.capturedVariables;
-  }
-
   bool isInMutableVariable(Local local) {
     return dartState.local2mutable.containsKey(local) &&
            !dartState.registerizedMutableVariables.contains(local);
   }
 
   void makeMutableVariable(Local local) {
     dartState.makeMutableVariable(local);
   }
 
   void removeMutableVariable(Local local) {
@@ skipping 575 matching lines @@
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }