frog await: allow errors after the await within try-catch blocks.

frog/await/transformation.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Desugarizes all await calls in a single function. This visitor assumes that
  * the tree is already normalized with [AwaitNormalizer]. For this reason it
  * only needs to recurse on statements and not on expressions. Like in
  * [AwaitChecker], nested functions have to be processed separately.
  */
@@ skipping 12 matching lines @@
   static final _IGNORED_THEN_PARAM = _PREFIX + 'ignored_param';
   static final _CONTINUATION_PREFIX = _PREFIX + 'after_';
 
   static final _COMPLETE_METHOD = 'complete';
   static final _COMPLETE_EXCEPTION_METHOD = 'completeException';
 
 
   /** The continuation when visiting a particular statement. */
   Queue<Statement> continuation;
 
-  /** If not null, a closure to call when a future ends with an exception. */
-  Identifier currentExceptionHandler;
+  /** Closures to call when a future throws an exception (in reverse order). */
+  List<Identifier> exceptionHandlers;
+
+  /** All try-catch blocks enclosing the current statement. */
+  List<TryStatement> enclosingTrys;
 
   /** Counter to ensure created closure names are unique. */
   int continuationClosures = 0;
 
   /** Nodes containing await expressions (determined by [AwaitChecker]). */
   final NodeSet haveAwait;
 
-  AwaitProcessor(this.haveAwait) : continuation = new Queue<Statement>();
+  AwaitProcessor(this.haveAwait)
+      : continuation = new Queue<Statement>(),
+        exceptionHandlers = [],
+        enclosingTrys = [];
 
   visitVariableDefinition(VariableDefinition node) {
     if (!haveAwait.contains(node)) return node;
     final values = node.values;
     // After normalization, variable declarations with await can only occur at
     // the top-level and there is no other declaration.
     assert(values != null && values.length == 1
         && values[0] is AwaitExpression);
     final param = new Identifier(_THEN_PARAM, node.span);
     // T x = await t; ... becomes:
@@ skipping 137 matching lines @@
     // - consider when await shows in catch blocks, but not in the try block
     // - support exceptions after the await
     // - handle nested try blocks
     // - support finally
     // - consider throws within catch blocks, e.g:
     //   try { a } catch (E e1) { throw new E2(); } catch (E2 e2) { -- }
 
     String afterTry = _newClosureName(_CONTINUATION_PREFIX + "_try");
     Statement afterTryDef = _makeContinuation(afterTry, node.span);
 
-    // Transform the body first:
-    continuation = new Queue();
-    final exceptionHandlerName = new Identifier(
-        _newClosureName(_PREFIX + "exception_handler"), node.span);
-    currentExceptionHandler = exceptionHandlerName;
-    continuation.addFirst(_callNoArg(afterTry, node.span));
-    Statement body = node.body.visit(this);
-    currentExceptionHandler = null;
-
     final defs = []; // closures for each catch block (avoid duplicating code).
     final catches = []; // catch clauses of the transformed try-catch block
 
     // Catch blocks are passed as an exception handler on de-sugared awaits:
+    final handlerName = new Identifier(
+        _newClosureName(_PREFIX + "exception_handler"), node.span);
     // TODO(sigmund): add trace argument (library change in Future<T>)
     final handlerArg = new Identifier(_EXCEPTION_HANDLER_PARAM, node.span);
     final handlerBody = [];
 
-    // The exception handler is smaller when we encounter an untyped catch.
-    bool untypedCatch = false;
-
+    // Transform each catch-block internally.
+    bool untypedCatch = false; // When true, the exception handler is smaller.
     for (CatchNode n in node.catches) {
       String fname = _newClosureName(_PREFIX + "catch");
 
       // Code in transformed catch-block:
       continuation = new Queue();
       continuation.addFirst(_callNoArg(afterTry, node.span));
       continuation.addFirst(n.body.visit(this));
 
       defs.add(_makeCatchFunction(n, fname));
       catches.add(new CatchNode(n.exception, n.trace,
           new BlockStatement(
             [_callCatchFunction(n, fname), _returnFuture(n.span)], n.span),
           n.span));
 
-      // Code in exceptionHandler:
+      // Code in exception handler:
       if (!untypedCatch) {
         final exceptionHandlerCases = [
             _callCatchFunctionHelper(fname, handlerArg, null, n.span),
             _returnBoolean(n.span, true)];
         if (n.exception.type == null) {
           handlerBody.addAll(exceptionHandlerCases);
           untypedCatch = true;
         } else {
           handlerBody.add(new IfStatement(
-                new IsExpression(true, handlerArg, n.exception.type, n.span),
+                new IsExpression(true,
+                    new VarExpression(handlerArg, n.span),
+                    n.exception.type, n.span),
                 new BlockStatement(exceptionHandlerCases, n.span),
                 null, n.span));
         }
       }
     }
 
     if (!untypedCatch) {
       handlerBody.add(_returnBoolean(node.span, false));
     }
 
-    final handlerDef = new FunctionDefinition([], null,
-        exceptionHandlerName, [new FormalNode(
-          false, false, null, handlerArg, null, node.span)],
+    // Declare the exception handler
+    final handlerDef = new FunctionDefinition([], null, handlerName,
+        [new FormalNode(false, false, null, handlerArg, null, node.span)],
         null, null, new BlockStatement(handlerBody, node.span), node.span);
 
+    // Transform the try body, tracking the enclosing try blocks and
+    // exception handlers.
+    enclosingTrys.addLast(new TryStatement(
+          null /* this is replaced with code in [_desugarAwaitCall] */,
+          catches, node.finallyBlock, node.span));
+    exceptionHandlers.addLast(handlerName);
+    continuation = new Queue();
+    continuation.addFirst(_callNoArg(afterTry, node.span));
+    Statement body = node.body.visit(this);
+    exceptionHandlers.removeLast();
+    enclosingTrys.removeLast();
+
     continuation = new Queue();
     continuation.addAll(defs);
     continuation.add(handlerDef);
     continuation.add(new TryStatement(body,
           catches, node.finallyBlock, node.span));
     continuation.add(_callNoArg(afterTry, node.span));
     return afterTryDef;
   }
 
   /**
@@ skipping 101 matching lines @@
   }
 
   /**
    * Converts an await expression into several statements: calling
    * [:Future.then:] and propatating errors. This implementation assumes that
    * await calls are within blocks (after normalization).
    */
   _desugarAwaitCall(AwaitExpression node, Identifier param) {
     List<Statement> afterAwait = [];
     afterAwait.addAll(continuation);
-    if (afterAwait[afterAwait.length - 1] is ReturnStatement) {
+    if (afterAwait.last() is ReturnStatement) {
       // The only reason there is a `return` is because there was another await
       // and we introduced it. Such `return` is not needed in the callback.
-      afterAwait.length = afterAwait.length - 1;
+      afterAwait.removeLast();
+    }
+    // Within try-blocks, we wrap the continuation in a try-catch block:
+    Statement thenBody = new BlockStatement(afterAwait, node.span);
+    for (int i = enclosingTrys.length - 1; i >= 0; i--) {
+      final templateTry = enclosingTrys[i];
+      thenBody = new TryStatement(thenBody,
+          templateTry.catches, templateTry.finallyBlock, templateTry.span);
     }
 
     // A lambda function that executes the continuation.
     final thenArg = new LambdaExpression(
         new FunctionDefinition([], null, null,
         [new FormalNode(
           false, false, null /* infer type from body? */,
           param, null, param.span)
         ], null, null,
-        new BlockStatement(afterAwait, node.span), node.span),
+        thenBody, node.span),
         node.span);
 
     continuation.clear();
     continuation.addFirst(_returnFuture(node.span));
     // Within try-blocks, we also add an exception handler to propagate errors.
-    if (currentExceptionHandler != null) {
+    for (final handlerName in exceptionHandlers) {
       continuation.addFirst(new ExpressionStatement(new CallExpression(
           new DotExpression(node.body,
               new Identifier('handleException', node.span), node.span),
           [new ArgumentNode(null,
-              new VarExpression(currentExceptionHandler, node.span),
+              new VarExpression(handlerName, node.span),
               node.span)],
           node.span), node.span));
     }
     return _callThen(node.body, thenArg, node.span);
   }
 
   /** Make the statement: [: future.then(arg); :] */
   _callThen(Expression future, Expression arg, SourceSpan span) {
     return new CallExpression(
         new DotExpression(future, new Identifier('then', span), span),
@@ skipping 180 matching lines @@
 //   if (a) if (b) await t; 2;
 //  becomes:
 //   if (a) { if (b) { await t; } } 2;
 //  which becomes becomes:
 //    _2() { 2; } if (a) { if (b) { t.then((_) { _2(); } } } _2();
 //  (seems that 'a' doesn't need { })
 // - 'if/while' with only one statement in the continuation (check the
 // optimization that copies code rather than adding a continuation closure).
 // - await not inside a block (could break error propagation if normalization is
 // done incorrectly).