Move the try-catch out of the async-function

pkg/compiler/lib/src/js/rewrite_async.dart

 // Copyright (c) 2015, 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 rewrite_async;
 
-// TODO(sigurdm): Move the try/catch expression to a js_helper function.
-// That would also simplify the sync* case, where the error can just be thrown.
-
 import "dart:math" show max;
 import 'dart:collection';
 
 import 'package:_internal/compiler/js_lib/shared/async_await_error_codes.dart'
     as error_codes;
 
 import "js.dart" as js;
 
 import '../util/util.dart';
 import '../dart2jslib.dart' show DiagnosticListener;
@@ skipping 674 matching lines @@
   ///
   /// function (x, y, z) async {
   ///   var p = await foo();
   ///   return bar(p);
   /// }
   ///
   /// Becomes (without error handling):
   ///
   /// function(x, y, z) {
   ///   var goto = 0, returnValue, completer = new Completer(), p;
-  ///   function helper(result) {
+  ///   function body(result) {
   ///     while (true) {
   ///       switch (goto) {
   ///         case 0:
   ///           goto = 1 // Remember where to continue when the future succeeds.
   ///           return thenHelper(foo(), helper, completer);
   ///         case 1:
   ///           p = result;
   ///           returnValue = bar(p);
   ///           goto = 2;
   ///           break;
   ///         case 2:
   ///           return thenHelper(returnValue, null, completer)
   ///       }
   ///     }
   ///     return thenHelper(null, helper, completer);
   ///   }
   /// }
   ///
   /// Try/catch is implemented by maintaining [handlerName] to contain the label
-  /// of the current handler. The switch is nested inside a try/catch that will
-  /// redirect the flow to the current handler.
+  /// of the current handler. If [bodyName] throws, the caller should catch the
+  /// error and recall [bodyName] with first argument [error_codes.ERROR] and
+  /// second argument the error.
   ///
   /// A `finally` clause is compiled similar to normal code, with the additional
   /// complexity that `finally` clauses need to know where to jump to after the
   /// clause is done. In the translation, each flow-path that enters a `finally`
   /// sets up the variable [nextName] with a stack of finally-blocks and a final
   /// jump-target (exit, catch, ...).
   ///
-  /// function (x, y, z) async {
+  /// function(x, y, z) async {
   ///   try {
   ///     try {
   ///       throw "error";
   ///     } finally {
   ///       finalize1();
   ///     }
   ///   } catch (e) {
   ///     handle(e);
   ///   } finally {
   ///     finalize2();
   ///   }
   /// }
   ///
   /// Translates into (besides the fact that structures not containing
   /// await/yield/yield* are left intact):
   ///
   /// function(x, y, z) {
   ///   var goto = 0;
   ///   var returnValue;
   ///   var completer = new Completer();
   ///   var handler = 8; // Outside try-blocks go to the rethrow label.
   ///   var p;
-  ///   var storedError;
+  ///   var currentError;
   ///   // The result can be either the result of an awaited future, or an
   ///   // error if the future completed with an error.
-  ///   function helper(errorCode, result) {
+  ///   function body(errorCode, result) {
   ///     if (errorCode == 1) {
-  ///       storedError = result;
+  ///       currentError = result;
   ///       goto = handler;
   ///     }
   ///     while (true) {
-  ///       try {
-  ///         switch (goto) {
-  ///           case 0:
-  ///             handler = 4; // The outer catch-handler
-  ///             handler = 1; // The inner (implicit) catch-handler
-  ///             throw "error";
-  ///             next = [3];
-  ///             // After the finally (2) continue normally after the try.
-  ///             goto = 2;
-  ///             break;
-  ///           case 1: // (implicit) catch handler for inner try.
-  ///             next = [3]; // destination after the finally.
-  ///             // fall-though to the finally handler.
-  ///           case 2: // finally for inner try
-  ///             handler = 4; // catch-handler for outer try.
-  ///             finalize1();
-  ///             goto = next.pop();
-  ///             break;
-  ///           case 3: // exiting inner try.
-  ///             next = [6];
-  ///             goto = 5; // finally handler for outer try.
-  ///             break;
-  ///           case 4: // catch handler for outer try.
-  ///             handler = 5; // If the handler throws, do the finally ..
-  ///             next = [8] // ... and rethrow.
-  ///             e = storedError;
-  ///             handle(e);
-  ///             // Fall through to finally.
-  ///           case 5: // finally handler for outer try.
-  ///             handler = null;
-  ///             finalize2();
-  ///             goto = next.pop();
-  ///             break;
-  ///           case 6: // Exiting outer try.
-  ///           case 7: // return
-  ///             return thenHelper(returnValue, 0, completer);
-  ///           case 8: // Rethrow
-  ///             return thenHelper(storedError, 1, completer);
-  ///         }
-  ///       } catch (error) {
-  ///         storedError = error;
-  ///         goto = handler;
+  ///       switch (goto) {
+  ///         case 0:
+  ///           handler = 4; // The outer catch-handler
+  ///           handler = 1; // The inner (implicit) catch-handler
+  ///           throw "error";
+  ///           next = [3];
+  ///           // After the finally (2) continue normally after the try.
+  ///           goto = 2;
+  ///           break;
+  ///         case 1: // (implicit) catch handler for inner try.
+  ///           next = [3]; // destination after the finally.
+  ///           // fall-though to the finally handler.
+  ///         case 2: // finally for inner try
+  ///           handler = 4; // catch-handler for outer try.
+  ///           finalize1();
+  ///           goto = next.pop();
+  ///           break;
+  ///         case 3: // exiting inner try.
+  ///           next = [6];
+  ///           goto = 5; // finally handler for outer try.
+  ///           break;
+  ///         case 4: // catch handler for outer try.
+  ///           handler = 5; // If the handler throws, do the finally ..
+  ///           next = [8] // ... and rethrow.
+  ///           e = storedError;
+  ///           handle(e);
+  ///           // Fall through to finally.
+  ///         case 5: // finally handler for outer try.
+  ///           handler = null;
+  ///           finalize2();
+  ///           goto = next.pop();
+  ///           break;
+  ///         case 6: // Exiting outer try.
+  ///         case 7: // return
+  ///           return thenHelper(returnValue, 0, completer);
+  ///         case 8: // Rethrow
+  ///           return thenHelper(currentError, 1, completer);
   ///       }
   ///     }
   ///     return thenHelper(null, helper, completer);
   ///   }
   /// }
   ///
   @override
   js.Expression visitFun(js.Fun node) {
     if (isSync) return node;
 
@@ skipping 11 matching lines @@
     addExit();
 
     List<js.SwitchClause> clauses = labelledParts.keys.map((label) {
       return new js.Case(js.number(label), new js.Block(labelledParts[label]));
     }).toList();
     js.Statement helperBody =
         new js.Switch(new js.VariableUse(gotoName), clauses);
     if (hasJumpThoughOuterLabel) {
       helperBody = new js.LabeledStatement(outerLabelName, helperBody);
     }
-    helperBody = js.js.statement("""
-        try {
-          #body
-        } catch (#error){
-          #currentError = #error;
-          #goto = #handler;
-        }""", {
-          "body": helperBody,
-          "goto": gotoName,
-          "error": errorName,
-          "currentError": currentErrorName,
-          "handler": handlerName,
-        });
+
     List<js.VariableInitialization> inits = <js.VariableInitialization>[];
 
     js.VariableInitialization makeInit(String name, js.Expression initValue) {
       return new js.VariableInitialization(
           new js.VariableDeclaration(name), initValue);
     }
 
     inits.add(makeInit(gotoName, js.number(0)));
     if (isAsync) {
       inits.add(makeInit(completerName, new js.New(newCompleter, [])));
     } else if (isAsyncStar) {
       inits.add(makeInit(controllerName,
           new js.Call(newController, [new js.VariableUse(bodyName)])));

[sra1, 2015/02/19 20:55:02]

new js.Call...  ->   js('#(#)', [newController, bodyName]))

[sigurdm, 2015/02/23 14:58:37]

Done.

     }
     inits.add(makeInit(handlerName, js.number(rethrowLabel)));
     inits.add(makeInit(currentErrorName, null));
     if (hasJumpThroughFinally || analysis.hasYield) {
       inits.add(makeInit(nextName, null));
     }
     if (analysis.hasExplicitReturns && isAsync) {
       inits.add(makeInit(returnValueName, null));
     }
-    if (isSyncStar) {
-      inits.add(makeInit(resultName, null));
-    }
     if (analysis.hasThis && !isSyncStar) {
       // Sync* functions must remember `this` on the level of the outer
       // function.
       inits.add(makeInit(selfName, new js.This()));

[sra1, 2015/02/19 20:55:02]

new js.This()  -->  js('this')

[sigurdm, 2015/02/23 14:58:37]

Done.

     }
     inits.addAll(localVariables.map((js.VariableDeclaration decl) {
       return new js.VariableInitialization(decl, null);
     }));
     inits.addAll(new Iterable.generate(tempVarHighWaterMark,
         (int i) => makeInit(useTempVar(i + 1).name, null)));
     js.VariableDeclarationList varDecl = new js.VariableDeclarationList(inits);
     // TODO(sigurdm): Explain the difference between these cases.
     if (isSyncStar) {
       return js.js("""
           function (#params) {
             if (#needsThis)
               var #self = this;
             return new #newIterable(function () {
               #varDecl;
-              return function #body() {
+              return function #body(#errorCode, #result) {
+                if (#errorCode == #ERROR) {

[sra1, 2015/02/19 20:55:02]

== --> ===

[sigurdm, 2015/02/23 14:58:37]

Done.

+                    #currentError = #result;
+                    #goto = #handler;
+                }
                 while (true)
                   #helperBody;
               };
             });
           }
           """, {
         "params": node.params,
         "needsThis": analysis.hasThis,
         "helperBody": helperBody,
         "varDecl": varDecl,
+        "errorCode": errorCodeName,
         "newIterable": newIterable,
         "body": bodyName,
         "self": selfName,
+        "result": resultName,
+        "goto": gotoName,
+        "handler": handlerName,
+        "currentError": currentErrorName,
+        "ERROR": js.number(error_codes.ERROR),
       });
     }
     return js.js("""
         function (#params) {
           #varDecl;
           function #bodyName(#errorCode, #result) {
             if (#hasYield)
               switch (#errorCode) {
                 case #STREAM_WAS_CANCELED:
                   #next = #nextWhenCanceled;
@@ skipping 192 matching lines @@
       return withExpression(node.condition, (js.Expression condition) {
         return new js.Conditional(condition, node.then, node.otherwise);
       });
     }
     int thenLabel = newLabel("then");
     int joinLabel = newLabel("join");
     int elseLabel = newLabel("else");
     withExpression(node.condition, (js.Expression condition) {
       addExpressionStatement(new js.Assignment(new js.VariableUse(gotoName),
           new js.Conditional(
               condition, js.number(thenLabel), js.number(elseLabel))));

[sra1, 2015/02/19 20:55:02]

js.statement('# = # ? # : #',
  gotoName, condition, js.number(thenLabel), js.number(elseLabel));

[sigurdm, 2015/02/23 14:58:37]

Done.

     }, store: false);
     addBreak();
     beginLabel(thenLabel);
     withExpression(node.then, (js.Expression value) {
       if (!isResult(value)) {
         addExpressionStatement(
             new js.Assignment(new js.VariableUse(resultName), value));
       }
     }, store: false);
     addGoto(joinLabel);
@@ skipping 1175 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }