dart2dart: Implementation of simple try/catch.

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 93 matching lines @@
 /// continues are collected by a JumpCollector and processed later, on demand.
 /// The site of the break or continue is represented by a continuation
 /// invocation that will have its target and arguments filled in later.
 ///
 /// The environment of the builder at that point is captured and should not
 /// be subsequently mutated until the jump is resolved.
 class JumpCollector {
   final JumpTarget target;
   final List<ir.InvokeContinuation> _invocations = <ir.InvokeContinuation>[];
   final List<Environment> _environments = <Environment>[];
+  final List<Iterable<LocalVariableElement>> boxedTryVariables =
+      <Iterable<LocalVariableElement>>[];
 
   JumpCollector(this.target);
 
   bool get isEmpty => _invocations.isEmpty;
   int get length => _invocations.length;
   List<ir.InvokeContinuation> get invocations => _invocations;
   List<Environment> get environments => _environments;
 
   void addJump(IrBuilder builder) {
+    // Unbox all variables that were boxed on entry to try blocks between the
+    // jump and the target.
+    for (Iterable<LocalVariableElement> boxedOnEntry in boxedTryVariables) {
+      for (LocalVariableElement variable in boxedOnEntry) {
+        assert(builder.isInMutableVariable(variable));
+        ir.Primitive value = builder.buildLocalGet(variable);
+        builder.environment.update(variable, value);
+      }
+    }
     ir.InvokeContinuation invoke = new ir.InvokeContinuation.uninitialized();
     builder.add(invoke);
     _invocations.add(invoke);
     _environments.add(builder.environment);
     builder._current = null;
     // TODO(kmillikin): Can we set builder.environment to null to make it
     // less likely to mutate it?
   }
+
+  /// Add a set of variables that were boxed on entry to a try block.
+  ///
+  /// Jumps from a try block to targets outside have to unbox the variables
+  /// that were boxed on entry before invoking the target continuation.  Call
+  /// this function before translating a try block and call [leaveTry] after
+  /// translating it.
+  void enterTry(Iterable<LocalVariableElement> boxedOnEntry) {
+    // The boxed variables are maintained as a stack to make leaving easy.
+    boxedTryVariables.add(boxedOnEntry);
+  }
+
+  /// Remove the most recently added set of variables boxed on entry to a try
+  /// block.
+  ///
+  /// Call [enterTry] before translating a try block and call this function
+  /// after translating it.
+  void leaveTry() {
+    boxedTryVariables.removeLast();
+  }
 }
 
 /// Function for building a node in the context of the current builder.
 typedef ir.Node BuildFunction(node);
 
 /// Function for building nodes in the context of the provided [builder].
 typedef ir.Node SubbuildFunction(IrBuilder builder);
 
 /// Mixin that provides encapsulated access to nested builders.
 abstract class IrBuilderMixin<N> {
@@ skipping 60 matching lines @@
   IrBuilderDelimitedState(this.constantSystem, this.currentElement);
 }
 
 /// A factory for building the cps IR.
 ///
 /// [DartIrBuilder] and [JsIrBuilder] implement nested functions and captured
 /// variables in different ways.
 abstract class IrBuilder {
   IrBuilder _makeInstance();
 
+  /// 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
+  /// entire lifetime as mutable variables (e.g., variables that are boxed
+  /// in mutable variables for a try block).
+  void removeMutableVariable(Local local);
+
   void declareLocalVariable(LocalVariableElement element,
                             {ir.Primitive initialValue});
   ir.Primitive buildLocalGet(LocalElement element);
   ir.Primitive buildLocalSet(LocalElement element, ir.Primitive value);
 
   /// Called when entering a nested function with free variables.
   ///
   /// The free variables must subsequently be accessible using [buildLocalGet]
   /// and [buildLocalSet].
   void _enterClosureEnvironment(ClosureEnvironment env);
@@ skipping 588 matching lines @@
         environment = thenBuilder.environment;
       } else if (elseBuilder.isOpen) {
         if (elseBuilder._root != null) _current = elseBuilder._current;
         environment = elseBuilder.environment;
       } else {
         _current = null;
       }
     }
   }
 
+  void jumpTo(ir.Continuation continuation) {
+    assert(isOpen);
+    assert(environment.length >= continuation.parameters.length);
+    ir.InvokeContinuation jump = new ir.InvokeContinuation.uninitialized();
+    jump.continuation = new ir.Reference(continuation);
+    jump.arguments = new List<ir.Reference>.generate(
+        continuation.parameters.length, (i) {
+      return new ir.Reference(environment[i]);
+    });
+    add(jump);
+    _current = null;
+  }
+
   /// Invoke a join-point continuation that contains arguments for all local
   /// variables.
   ///
   /// Given the continuation and a list of uninitialized invocations, fill
   /// in each invocation with the continuation and appropriate arguments.
   void invokeFullJoin(ir.Continuation join,
                       JumpCollector jumps,
                       {recursive: false}) {
+    // TODO(kmillikin): If the JumpCollector collected open IrBuilders instead
+    // of pairs of invocations and environments, we could use IrBuilder.jumpTo
+    // here --- the code is almost the same.
     join.isRecursive = recursive;
     for (int i = 0; i < jumps.length; ++i) {
       Environment currentEnvironment = jumps.environments[i];
       ir.InvokeContinuation invoke = jumps.invocations[i];
       invoke.continuation = new ir.Reference(join);
       invoke.arguments = new List<ir.Reference>.generate(
           join.parameters.length,
           (i) => new ir.Reference(currentEnvironment[i]));
       invoke.isRecursive = recursive;
     }
@@ skipping 674 matching lines @@
     return join;
   }
 }
 
 /// 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>{};
 
-  final DartCapturedVariableInfo capturedVariables;
+  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>();
@@ skipping 11 matching lines @@
 /// 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,
-                DartCapturedVariableInfo capturedVariables)
+                DartCapturedVariables capturedVariables)
       : dartState = new DartIrBuilderSharedState(capturedVariables) {
     _init(constantSystem, currentElement);
   }
 
-  /// True if [local] should currently be accessed from a [MutableVariable].
+  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) {
+    dartState.local2mutable.remove(local);
+  }
+
   /// Gets the [MutableVariable] containing the value of [local].
   ir.MutableVariable getMutableVariable(Local local) {
     return dartState.local2mutable[local];
   }
 
   void _enterScope(ClosureScope scope) {
     assert(scope == null);
   }
 
   void _enterClosureEnvironment(ClosureEnvironment env) {
@@ skipping 153 matching lines @@
   final JsIrBuilderSharedState jsState;
 
   IrBuilder _makeInstance() => new JsIrBuilder._blank(jsState);
   JsIrBuilder._blank(this.jsState);
 
   JsIrBuilder(ConstantSystem constantSystem, ExecutableElement currentElement)
       : jsState = new JsIrBuilderSharedState() {
     _init(constantSystem, currentElement);
   }
 
+  Map<ast.TryStatement, TryStatementInfo> get tryStatements => null;
+  Set<Local> get mutableCapturedVariables => null;
+  bool isInMutableVariable(Local local) => false;
+  void makeMutableVariable(Local local) {}
+  void removeMutableVariable(Local local) {}
+
   void _enterClosureEnvironment(ClosureEnvironment env) {
     if (env == null) return;
 
     // Obtain a reference to the function object (this).
     ir.Primitive thisPrim = new ir.This();
     add(new ir.LetPrim(thisPrim));
 
     // Obtain access to the free variables.
     env.freeVariables.forEach((Local local, ClosureLocation location) {
       if (location.isBox) {
@@ skipping 258 matching lines @@
   /// If non-null, [thisLocal] has an entry in [freeVariables] describing where
   /// to find the captured value of `this`.
   final ThisLocal thisLocal;
 
   /// Maps [LocalElement]s, [BoxLocal]s and [ThisLocal] to their location.
   final Map<Local, ClosureLocation> freeVariables;
 
   ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
 }
 
-/// Information about which variables are captured by a nested function.
-///
-/// This is used by the [DartIrBuilder] instead of [ClosureScope] and
-/// [ClosureEnvironment].
-abstract class DartCapturedVariableInfo {
-  Iterable<Local> get capturedVariables;
+class TryStatementInfo {
+  final Set<LocalVariableElement> declared = new Set<LocalVariableElement>();
+  final Set<LocalVariableElement> boxedOnEntry =
+      new Set<LocalVariableElement>();
 }