Implement try/finally by inlining the finally code.

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 '../compile_time_constants.dart' show BackendConstantEnvironment;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart' show ConstantValue, PrimitiveConstantValue;
@@ skipping 113 matching lines @@
 /// give a handle to the continuation and its environment.
 abstract class JumpCollector {
   final JumpTarget target;
 
   ir.Continuation _continuation = null;
   final Environment _continuationEnvironment;
 
   final List<Iterable<LocalVariableElement>> _boxedTryVariables =
       <Iterable<LocalVariableElement>>[];
 
+  /// A stack of all the enclosing finally blocks up to the target of the jump.
+  ///
+  /// There are null entries which correspond to try/catch (no finally).
+  final List<SubbuildFunction> _finallyBlocks = <SubbuildFunction>[];
+
   JumpCollector(this._continuationEnvironment, this.target);
 
   /// True if the collector has not recorded any jumps to its continuation.
   bool get isEmpty;
 
   /// The continuation encapsulated by this collector.
   ir.Continuation get continuation;
 
   /// The compile-time environment to be used for translating code in the body
   /// of the continuation.
   Environment get environment;
 
   /// Emit a jump to the continuation for a given [IrBuilder].
   void addJump(IrBuilder builder);
 
   /// Add a set of variables that were boxed on entry to a try block.
   ///
   /// All 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) {
+  void enterTry(Iterable<LocalVariableElement> boxedOnEntry,
+                [SubbuildFunction buildFinallyBlock]) {
     // The boxed variables are maintained as a stack to make leaving easy.
     _boxedTryVariables.add(boxedOnEntry);
+    _finallyBlocks.add(buildFinallyBlock);
   }
 
   /// 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();
+    _finallyBlocks.removeLast();
   }
 
   void _buildTryExit(IrBuilder builder) {
     for (Iterable<LocalVariableElement> boxedOnEntry in _boxedTryVariables) {
       for (LocalVariableElement variable in boxedOnEntry) {
         assert(builder.isInMutableVariable(variable));
         ir.Primitive value = builder.buildLocalVariableGet(variable);
         builder.environment.update(variable, value);
       }
     }
+    for (SubbuildFunction buildFinallyBlock in _finallyBlocks.reversed) {
+      if (buildFinallyBlock != null) buildFinallyBlock(builder);
+      if (!builder.isOpen) return;

[asgerf, 2015/06/23 08:43:40]

The inlined finally block seems to be evaluated in scope of its own catch
handler.

Here is a test:
https://gist.github.com/asgerf/0c79a1d8de3e4819864f

Like the fallthrough exit, it must happen at the join point.

[Kevin Millikin (Google), 2015/06/23 09:26:59]

That's pretty serious, thanks for spotting it.

+    }
   }
 }
 
 /// A class to collect 'forward' jumps.
 ///
 /// A forward jump to a continuation in the sense of the CPS translation is
 /// a jump where the jump is emitted before any code in the body of the
 /// continuation is translated.  They have the property that continuation
 /// parameters and the environment for the translation of the body can be
 /// determined based on the invocations, before translating the body.  A
@@ skipping 30 matching lines @@
   }
 
   Environment get environment {
     if (_continuation == null) _setContinuation();
     return _continuationEnvironment;
   }
 
   void addJump(IrBuilder builder) {
     assert(_continuation == null);
     _buildTryExit(builder);
+    if (!builder.isOpen) return;
+
     ir.InvokeContinuation invoke = new ir.InvokeContinuation.uninitialized();
     builder.add(invoke);
     _invocations.add(invoke);
     _invocationEnvironments.add(builder.environment);
     builder._current = null;
     // TODO(kmillikin): Can we set builder.environment to null to make it
     // less likely to mutate it?
   }
 
   void _setContinuation() {
@@ skipping 78 matching lines @@
     _continuation = new ir.Continuation(parameters, isRecursive: true);
   }
 
   bool isEmpty = true;
 
   ir.Continuation get continuation => _continuation;
   Environment get environment => _continuationEnvironment;
 
   void addJump(IrBuilder builder) {
     assert(_continuation.parameters.length <= builder.environment.length);
+    _buildTryExit(builder);
+    if (!builder.isOpen) return;
+
     isEmpty = false;
-    _buildTryExit(builder);
     builder.add(new ir.InvokeContinuation(_continuation,
         builder.environment.index2value.take(_continuation.parameters.length)
             .toList(),
         isRecursive: true));
     builder._current = null;
   }
 }
 
 /// Function for building a node in the context of the current builder.
 typedef ir.Node BuildFunction(node);
@@ skipping 55 matching lines @@
   final BackendConstantEnvironment constants;
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
   /// A stack of collectors for breaks.
   final List<JumpCollector> breakCollectors = <JumpCollector>[];
 
   /// A stack of collectors for continues.
   final List<JumpCollector> continueCollectors = <JumpCollector>[];
 
+  /// A stack of enclosing finally blocks, used when translating return.
+  final List<SubbuildFunction> finallyBlocks = <SubbuildFunction>[];
+
   final List<ConstDeclaration> localConstants = <ConstDeclaration>[];
 
   final ExecutableElement currentElement;
 
   final ir.Continuation returnContinuation = new ir.Continuation.retrn();
   ir.Parameter _thisParameter;
   ir.Parameter enclosingMethodThisParameter;
 
   final List<ir.Parameter> functionParameters = <ir.Parameter>[];
 
@@ skipping 1312 matching lines @@
   ///
   /// [tryInfo] provides information on local variables declared and boxed
   /// within this try statement.
   /// [buildTryBlock] builds the try block.
   /// [catchClauseInfos] provides access to the catch type, exception variable,
   /// and stack trace variable, and a function for building the catch block.
   void buildTry(
       {TryStatementInfo tryStatementInfo,
        SubbuildFunction buildTryBlock,
        List<CatchClauseInfo> catchClauseInfos: const <CatchClauseInfo>[],
+       SubbuildFunction buildFinallyBlock,
        ClosureClassMap closureClassMap}) {
     assert(isOpen);
 
     // Catch handlers are in scope for their body.  The CPS translation of
     // [[try tryBlock catch (e) catchBlock; successor]] is:
     //
     // let cont join(v0, v1, ...) = [[successor]] in
     //   let mutable m0 = x0 in
     //     let mutable m1 = x1 in
     //       ...
@@ skipping 12 matching lines @@
     //
     // In other words, both the try and catch block are in the scope of the
     // join-point continuation, and they are both in the scope of a sequence
     // of mutable bindings for the variables assigned in the try.  The join-
     // point continuation is not in the scope of these mutable bindings.
     // The tryBlock is in the scope of a binding for the catch handler.  Each
     // instruction (specifically, each call) in the tryBlock is in the dynamic
     // 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.
-    JumpCollector join = new ForwardJumpCollector(environment);
-    IrBuilder tryCatchBuilder = makeDelimitedBuilder();
+    if (catchClauseInfos.isNotEmpty) {
+      JumpCollector join = new ForwardJumpCollector(environment);
+      IrBuilder tryCatchBuilder = makeDelimitedBuilder();
 
-    // Variables treated as mutable in a try are not mutable outside of it.
-    // Work with a copy of the outer builder's mutable variables.
-    tryCatchBuilder.mutableVariables =
-        new Map<Local, ir.MutableVariable>.from(mutableVariables);
-    for (LocalVariableElement variable in tryStatementInfo.boxedOnEntry) {
-      assert(!tryCatchBuilder.isInMutableVariable(variable));
-      ir.Primitive value = tryCatchBuilder.buildLocalVariableGet(variable);
-      tryCatchBuilder.makeMutableVariable(variable);
-      tryCatchBuilder.declareLocalVariable(variable, initialValue: value);
+      // Variables treated as mutable in a try are not mutable outside of it.
+      // Work with a copy of the outer builder's mutable variables.
+      tryCatchBuilder.mutableVariables =
+          new Map<Local, ir.MutableVariable>.from(mutableVariables);
+      for (LocalVariableElement variable in tryStatementInfo.boxedOnEntry) {
+        assert(!tryCatchBuilder.isInMutableVariable(variable));
+        ir.Primitive value = tryCatchBuilder.buildLocalVariableGet(variable);
+        tryCatchBuilder.makeMutableVariable(variable);
+        tryCatchBuilder.declareLocalVariable(variable, initialValue: value);
+      }
+
+      IrBuilder tryBuilder = tryCatchBuilder.makeDelimitedBuilder();
+
+      void interceptJump(JumpCollector collector) {
+        collector.enterTry(tryStatementInfo.boxedOnEntry);
+      }
+      void restoreJump(JumpCollector collector) {
+        collector.leaveTry();
+      }
+      tryBuilder.state.breakCollectors.forEach(interceptJump);
+      tryBuilder.state.continueCollectors.forEach(interceptJump);
+      buildTryBlock(tryBuilder);
+      if (tryBuilder.isOpen) {
+        interceptJump(join);
+        tryBuilder.jumpTo(join);
+        restoreJump(join);
+      }
+      tryBuilder.state.breakCollectors.forEach(restoreJump);
+      tryBuilder.state.continueCollectors.forEach(restoreJump);
+
+      IrBuilder catchBuilder = tryCatchBuilder.makeDelimitedBuilder();
+      for (LocalVariableElement variable in tryStatementInfo.boxedOnEntry) {
+        assert(catchBuilder.isInMutableVariable(variable));
+        ir.Primitive value = catchBuilder.buildLocalVariableGet(variable);
+        // After this point, the variables that were boxed on entry to the try
+        // are no longer treated as mutable.
+        catchBuilder.removeMutableVariable(variable);
+        catchBuilder.environment.update(variable, value);
+      }
+
+      // Handlers are always translated as having both exception and stack trace
+      // parameters.  Multiple clauses do not have to use the same names for
+      // them.  Choose the first of each as the name hint for the respective
+      // handler parameter.
+      ir.Parameter exceptionParameter =
+          new ir.Parameter(catchClauseInfos.first.exceptionVariable);
+      LocalVariableElement traceVariable;
+      CatchClauseInfo catchAll;
+      for (int i = 0; i < catchClauseInfos.length; ++i) {
+        CatchClauseInfo info = catchClauseInfos[i];
+        if (info.type == null) {
+          catchAll = info;
+          catchClauseInfos.length = i;
+          break;
+        }
+        if (traceVariable == null) {
+          traceVariable = info.stackTraceVariable;
+        }
+      }
+      ir.Parameter traceParameter = new ir.Parameter(traceVariable);
+      // Expand multiple catch clauses into an explicit if/then/else.  Iterate
+      // them in reverse so the current block becomes the next else block.
+      ir.Expression catchBody;
+      if (catchAll == null) {
+        catchBody = new ir.Rethrow();
+      } else {
+        IrBuilder clauseBuilder = catchBuilder.makeDelimitedBuilder();
+        clauseBuilder.declareLocalVariable(catchAll.exceptionVariable,
+                                           initialValue: exceptionParameter);
+        if (catchAll.stackTraceVariable != null) {
+          clauseBuilder.declareLocalVariable(catchAll.stackTraceVariable,
+                                             initialValue: traceParameter);
+        }
+        catchAll.buildCatchBlock(clauseBuilder);
+        if (clauseBuilder.isOpen) clauseBuilder.jumpTo(join);
+        catchBody = clauseBuilder._root;
+      }
+      for (CatchClauseInfo clause in catchClauseInfos.reversed) {
+        IrBuilder clauseBuilder = catchBuilder.makeDelimitedBuilder();
+        clauseBuilder.declareLocalVariable(clause.exceptionVariable,
+                                           initialValue: exceptionParameter);
+        if (clause.stackTraceVariable != null) {
+          clauseBuilder.declareLocalVariable(clause.stackTraceVariable,
+                                             initialValue: traceParameter);
+        }
+        clause.buildCatchBlock(clauseBuilder);
+        if (clauseBuilder.isOpen) clauseBuilder.jumpTo(join);
+        ir.Continuation thenContinuation = new ir.Continuation([]);
+        thenContinuation.body = clauseBuilder._root;
+        ir.Continuation elseContinuation = new ir.Continuation([]);
+        elseContinuation.body = catchBody;
+
+        // Build the type test guarding this clause. We can share the
+        // environment with the nested builder because this part cannot mutate
+        // it.
+        IrBuilder checkBuilder = catchBuilder.makeDelimitedBuilder(environment);
+        ir.Primitive typeMatches =
+            checkBuilder.buildTypeOperator(exceptionParameter,
+                                           clause.type,
+                                           isTypeTest: true);
+        checkBuilder.add(new ir.LetCont.many([thenContinuation,
+                                              elseContinuation],
+                             new ir.Branch(new ir.IsTrue(typeMatches),
+                                           thenContinuation,
+                                           elseContinuation)));
+        catchBody = checkBuilder._root;
+      }
+
+      List<ir.Parameter> catchParameters =
+          <ir.Parameter>[exceptionParameter, traceParameter];
+      ir.Continuation catchContinuation = new ir.Continuation(catchParameters);
+      catchBuilder.add(catchBody);
+      catchContinuation.body = catchBuilder._root;
+
+      tryCatchBuilder.add(
+          new ir.LetHandler(catchContinuation, tryBuilder._root));
+      add(new ir.LetCont(join.continuation, tryCatchBuilder._root));
+      environment = join.environment;
+    } else {
+      // Try/finally.
+      JumpCollector join = new ForwardJumpCollector(environment);
+      IrBuilder tryFinallyBuilder = makeDelimitedBuilder();
+
+      tryFinallyBuilder.mutableVariables =
+          new Map<Local, ir.MutableVariable>.from(mutableVariables);
+      for (LocalVariableElement variable in tryStatementInfo.boxedOnEntry) {
+        assert(!tryFinallyBuilder.isInMutableVariable(variable));
+        ir.Primitive value = tryFinallyBuilder.buildLocalVariableGet(variable);
+        tryFinallyBuilder.makeMutableVariable(variable);
+        tryFinallyBuilder.declareLocalVariable(variable, initialValue: value);
+      }
+
+      IrBuilder tryBuilder = tryFinallyBuilder.makeDelimitedBuilder();
+
+      void interceptJump(JumpCollector collector) {
+        collector.enterTry(tryStatementInfo.boxedOnEntry, buildFinallyBlock);
+      }
+      void restoreJump(JumpCollector collector) {
+        collector.leaveTry();
+      }
+      tryBuilder.state.breakCollectors.forEach(interceptJump);
+      tryBuilder.state.continueCollectors.forEach(interceptJump);
+      tryBuilder.state.finallyBlocks.add(buildFinallyBlock);
+      buildTryBlock(tryBuilder);
+      if (tryBuilder.isOpen) {
+        // To cover control falling off the end of the try block, the finally
+        // code is translated at the join point.  This ensures that it is
+        // correctly outside the scope of the catch handler.
+        join.enterTry(tryStatementInfo.boxedOnEntry);
+        tryBuilder.jumpTo(join);
+        join.leaveTry();
+      }
+      tryBuilder.state.breakCollectors.forEach(restoreJump);
+      tryBuilder.state.continueCollectors.forEach(restoreJump);
+      tryBuilder.state.finallyBlocks.removeLast();
+
+      IrBuilder catchBuilder = tryFinallyBuilder.makeDelimitedBuilder();
+      for (LocalVariableElement variable in tryStatementInfo.boxedOnEntry) {
+        assert(catchBuilder.isInMutableVariable(variable));
+        ir.Primitive value = catchBuilder.buildLocalVariableGet(variable);
+        catchBuilder.removeMutableVariable(variable);
+        catchBuilder.environment.update(variable, value);
+      }
+
+      buildFinallyBlock(catchBuilder);
+      if (catchBuilder.isOpen) {
+        catchBuilder.add(new ir.Rethrow());
+        catchBuilder._current = null;
+      }
+      List<ir.Parameter> catchParameters =
+          <ir.Parameter>[new ir.Parameter(null), new ir.Parameter(null)];
+      ir.Continuation catchContinuation = new ir.Continuation(catchParameters);
+      catchContinuation.body = catchBuilder._root;
+      tryFinallyBuilder.add(
+          new ir.LetHandler(catchContinuation, tryBuilder._root));
+      add(new ir.LetCont(join.continuation, tryFinallyBuilder._root));
+      environment = join.environment;
+      buildFinallyBlock(this);
     }
-
-    IrBuilder tryBuilder = tryCatchBuilder.makeDelimitedBuilder();
-
-    void interceptJumps(JumpCollector collector) {
-      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 tryStatementInfo.boxedOnEntry) {
-      assert(catchBuilder.isInMutableVariable(variable));
-      ir.Primitive value = catchBuilder.buildLocalVariableGet(variable);
-      // After this point, the variables that were boxed on entry to the try
-      // are no longer treated as mutable.
-      catchBuilder.removeMutableVariable(variable);
-      catchBuilder.environment.update(variable, value);
-    }
-
-    // Handlers are always translated as having both exception and stack trace
-    // parameters.  Multiple clauses do not have to use the same names for
-    // them.  Choose the first of each as the name hint for the respective
-    // handler parameter.
-    ir.Parameter exceptionParameter =
-        new ir.Parameter(catchClauseInfos.first.exceptionVariable);
-    LocalVariableElement traceVariable;
-    CatchClauseInfo catchAll;
-    for (int i = 0; i < catchClauseInfos.length; ++i) {
-      CatchClauseInfo info = catchClauseInfos[i];
-      if (info.type == null) {
-        catchAll = info;
-        catchClauseInfos.length = i;
-        break;
-      }
-      if (traceVariable == null) {
-        traceVariable = info.stackTraceVariable;
-      }
-    }
-    ir.Parameter traceParameter = new ir.Parameter(traceVariable);
-    // Expand multiple catch clauses into an explicit if/then/else.  Iterate
-    // them in reverse so the current block becomes the next else block.
-    ir.Expression catchBody;
-    if (catchAll == null) {
-      catchBody = new ir.Rethrow();
-    } else {
-      IrBuilder clauseBuilder = catchBuilder.makeDelimitedBuilder();
-      clauseBuilder.declareLocalVariable(catchAll.exceptionVariable,
-                                         initialValue: exceptionParameter);
-      if (catchAll.stackTraceVariable != null) {
-        clauseBuilder.declareLocalVariable(catchAll.stackTraceVariable,
-                                           initialValue: traceParameter);
-      }
-      catchAll.buildCatchBlock(clauseBuilder);
-      if (clauseBuilder.isOpen) clauseBuilder.jumpTo(join);
-      catchBody = clauseBuilder._root;
-    }
-    for (CatchClauseInfo clause in catchClauseInfos.reversed) {
-      IrBuilder clauseBuilder = catchBuilder.makeDelimitedBuilder();
-      clauseBuilder.declareLocalVariable(clause.exceptionVariable,
-                                         initialValue: exceptionParameter);
-      if (clause.stackTraceVariable != null) {
-        clauseBuilder.declareLocalVariable(clause.stackTraceVariable,
-                                           initialValue: traceParameter);
-      }
-      clause.buildCatchBlock(clauseBuilder);
-      if (clauseBuilder.isOpen) clauseBuilder.jumpTo(join);
-      ir.Continuation thenContinuation = new ir.Continuation([]);
-      thenContinuation.body = clauseBuilder._root;
-      ir.Continuation elseContinuation = new ir.Continuation([]);
-      elseContinuation.body = catchBody;
-
-      // Build the type test guarding this clause. We can share the environment
-      // with the nested builder because this part cannot mutate it.
-      IrBuilder checkBuilder = catchBuilder.makeDelimitedBuilder(environment);
-      ir.Primitive typeMatches =
-          checkBuilder.buildTypeOperator(exceptionParameter,
-                                         clause.type,
-                                         isTypeTest: true);
-      checkBuilder.add(new ir.LetCont.many([thenContinuation, elseContinuation],
-                           new ir.Branch(new ir.IsTrue(typeMatches),
-                                         thenContinuation,
-                                         elseContinuation)));
-      catchBody = checkBuilder._root;
-    }
-
-    List<ir.Parameter> catchParameters =
-        <ir.Parameter>[exceptionParameter, traceParameter];
-    ir.Continuation catchContinuation = new ir.Continuation(catchParameters);
-    catchBuilder.add(catchBody);
-    catchContinuation.body = catchBuilder._root;
-
-    tryCatchBuilder.add(
-        new ir.LetHandler(catchContinuation, tryBuilder._root));
-    add(new ir.LetCont(join.continuation, tryCatchBuilder._root));
-    environment = join.environment;
   }
 
   /// Create a return statement `return value;` or `return;` if [value] is
   /// null.
   void buildReturn([ir.Primitive value]) {
     // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
     //   where (C', x) = Build(e, C)
     //
     // Return without a subexpression is translated as if it were return null.
     assert(isOpen);
     if (value == null) {
       value = buildNullConstant();
     }
-    add(new ir.InvokeContinuation(state.returnContinuation, [value]));
-    _current = null;
+    for (SubbuildFunction buildFinallyBlock in state.finallyBlocks.reversed) {
+      buildFinallyBlock(this);
+      if (!isOpen) break;
+    }
+    if (isOpen) {
+      add(new ir.InvokeContinuation(state.returnContinuation, [value]));
+      _current = null;
+    }
   }
 
   /// Create a blocks of [statements] by applying [build] to all reachable
   /// statements. The first statement is assumed to be reachable.
   // TODO(johnniwinther): Type [statements] as `Iterable` when `NodeList` uses
   // `List` instead of `Link`.
   void buildBlock(var statements, BuildFunction build) {
     // Build(Block(stamements), C) = C'
     //   where C' = statements.fold(Build, C)
     assert(isOpen);
@@ skipping 719 matching lines @@
                    this.buildCatchBlock});
 }
 
 class SwitchCaseInfo {
   final List<ir.Primitive> constants = <ir.Primitive>[];
   final SubbuildFunction buildBody;
 
   SwitchCaseInfo(this.buildBody);
 
   void addConstant(ir.Primitive constant) => constants.add(constant);
-}
+}