Refactor the try statement analysis results.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 124 matching lines @@
          BaseImplementationOfLocalsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfDynamicsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfConstantsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfSuperIncDecsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfNewMixin<ir.Primitive, dynamic>,
          ErrorBulkMixin<ir.Primitive, dynamic>
     implements SemanticSendVisitor<ir.Primitive, dynamic> {
   final Compiler compiler;
   final SourceInformationBuilder sourceInformationBuilder;
 
+  /// A map from try statements in the source to analysis information about
+  /// them.
+  ///
+  /// The analysis information includes the set of variables that must be
+  /// copied into [ir.MutableVariable]s on entry to the try and copied out on
+  /// exit.
+  Map<ast.TryStatement, TryStatementInfo> tryStatements = null;
+
   // In SSA terms, join-point continuation parameters are the phis and the
   // continuation invocation arguments are the corresponding phi inputs.  To
   // support name introduction and renaming for source level variables, we use
   // nested (delimited) visitors for constructing subparts of the IR that will
   // need renaming.  Each source variable is assigned an index.
   //
   // Each nested visitor maintains a list of free variable uses in the body.
   // These are implemented as a list of parameters, each with their own use
   // list of references.  When the delimited subexpression is plugged into the
   // surrounding context, the free occurrences can be captured or become free
@@ skipping 309 matching lines @@
   // Return without a subexpression is translated as if it were return null.
   ir.Primitive visitReturn(ast.Return node) {
     assert(irBuilder.isOpen);
     assert(invariant(node, node.beginToken.value != 'native'));
     irBuilder.buildReturn(build(node.expression));
     return null;
   }
 
   visitTryStatement(ast.TryStatement node) {
     // Try/catch is not yet implemented in the JS backend.
-    if (this.irBuilder.tryStatements == null) {
+    if (tryStatements == null) {
       return giveup(node, 'try/catch in the JS backend');
     }
     // Multiple catch blocks are not yet implemented.
     if (node.catchBlocks.isEmpty ||
         node.catchBlocks.nodes.tail == null) {
       return giveup(node, 'not exactly one catch block');
     }
     // 'on T' catch blocks are not yet implemented.
     if ((node.catchBlocks.nodes.head as ast.CatchBlock).onKeyword != null) {
       return giveup(node, '"on T" catch block');
@@ skipping 11 matching lines @@
       if (catchClause.trace != null) {
         stackTraceVariable = elements[catchClause.trace];
       }
       catchClauseInfos.add(new CatchClauseInfo(
           exceptionVariable: exceptionVariable,
           stackTraceVariable: stackTraceVariable,
           buildCatchBlock: subbuild(catchClause.block)));
     }
 
     irBuilder.buildTry(
-        tryStatementInfo: irBuilder.tryStatements[node],
+        tryStatementInfo: tryStatements[node],
         buildTryBlock: subbuild(node.tryBlock),
         catchClauseInfos: catchClauseInfos);
   }
 
   // ## Expressions ##
   ir.Primitive visitConditional(ast.Conditional node) {
     return irBuilder.buildConditional(
         build(node.condition),
         subbuild(node.thenExpression),
         subbuild(node.elseExpression));
@@ skipping 1293 matching lines @@
 
   giveup(ast.Node node, [String reason]) {
     bailoutMessage = '($node): $reason';
     throw ABORT_IRNODE_BUILDER;
   }
 
   void markAsCaptured(Local local) {
     capturedVariables.add(local);
   }
 
+  analyze(ast.Node node) {
+    visit(node);
+    // Variables that are captured by a closure are boxed for their entire
+    // lifetime, so they never need to be boxed on entry to a try block.
+    // They are not filtered out before this because we cannot identify all
+    // of them in the same pass (they may be captured by a closure after the
+    // try statement).
+    for (TryStatementInfo info in tryStatements.values) {
+      info.boxedOnEntry.removeAll(capturedVariables);
+    }
+  }
+
   visit(ast.Node node) => node.accept(this);
 
   visitNode(ast.Node node) {
     node.visitChildren(this);
   }
 
   visitFor(ast.For node) {
     if (node.initializer != null) visit(node.initializer);
     if (node.condition != null) visit(node.condition);
     if (node.update != null) visit(node.update);
@@ skipping 105 matching lines @@
 /// IR builder specific to the Dart backend, coupled to the [DartIrBuilder].
 class DartIrBuilderVisitor extends IrBuilderVisitor {
   /// Promote the type of [irBuilder] to [DartIrBuilder].
   DartIrBuilder get irBuilder => super.irBuilder;
 
   DartIrBuilderVisitor(TreeElements elements,
                        Compiler compiler,
                        SourceInformationBuilder sourceInformationBuilder)
       : super(elements, compiler, sourceInformationBuilder);
 
-  DartIrBuilder makeIRBuilder(ast.Node node, ExecutableElement element) {
-    DartCapturedVariables closures = new DartCapturedVariables(elements);
+  DartIrBuilder makeIRBuilder(ExecutableElement element,
+                              Set<Local> capturedVariables) {
+    return new DartIrBuilder(compiler.backend.constantSystem,
+                             element,
+                             capturedVariables);
+  }
+
+  DartCapturedVariables _analyzeCapturedVariables(ExecutableElement element,
+                                                  ast.Node node) {
+    DartCapturedVariables variables = new DartCapturedVariables(elements);
     if (!element.isSynthesized) {
       try {
-        closures.visit(node);
+        variables.analyze(node);
       } catch (e) {
-        bailoutMessage = closures.bailoutMessage;
+        bailoutMessage = variables.bailoutMessage;
         rethrow;
       }
     }
-    return new DartIrBuilder(compiler.backend.constantSystem,
-                             element,
-                             closures);
+    return variables;
   }
 
   /// Recursively builds the IR for the given nested function.
   ir.FunctionDefinition makeSubFunction(ast.FunctionExpression node) {
     FunctionElement element = elements[node];
     assert(invariant(element, element.isImplementation));
 
     IrBuilder builder = irBuilder.makeInnerFunctionBuilder(element);
 
     return withBuilder(builder, () => _makeFunctionBody(element, node));
@@ skipping 28 matching lines @@
   ir.FieldDefinition buildField(FieldElement element) {
     assert(invariant(element, element.isImplementation));
     ast.VariableDefinitions definitions = element.node;
     ast.Node fieldDefinition = definitions.definitions.nodes.first;
     if (definitions.modifiers.isConst) {
       // TODO(sigurdm): Just return const value.
     }
     assert(fieldDefinition != null);
     assert(elements[fieldDefinition] != null);
 
-    IrBuilder builder = makeIRBuilder(fieldDefinition, element);
+    DartCapturedVariables variables =
+        _analyzeCapturedVariables(element, fieldDefinition);
+    tryStatements = variables.tryStatements;
+    IrBuilder builder = makeIRBuilder(element, variables.capturedVariables);
 
     return withBuilder(builder, () {
       builder.buildFieldInitializerHeader(
           closureScope: getClosureScopeForNode(fieldDefinition));
       ir.Primitive initializer;
       if (fieldDefinition is ast.SendSet) {
         ast.SendSet sendSet = fieldDefinition;
         initializer = visit(sendSet.arguments.first);
       }
       return builder.makeFieldDefinition(initializer);
@@ skipping 10 matching lines @@
     if (!element.isSynthesized) {
       assert(node != null);
       assert(elements[node] != null);
     } else {
       SynthesizedConstructorElementX constructor = element;
       if (!constructor.isDefaultConstructor) {
         giveup(null, 'cannot handle synthetic forwarding constructors');
       }
     }
 
-    IrBuilder builder = makeIRBuilder(node, element);
+    DartCapturedVariables variables =
+        _analyzeCapturedVariables(element, node);
+    tryStatements = variables.tryStatements;
+    IrBuilder builder = makeIRBuilder(element, variables.capturedVariables);
 
     return withBuilder(builder, () => _makeFunctionBody(element, node));
   }
 
   List<ir.Primitive> normalizeStaticArguments(
       CallStructure callStructure,
       FunctionElement target,
       List<ir.Primitive> arguments) {
     return arguments;
   }
@@ skipping 633 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }