js_runtime: Split _asyncHelper into separate functions

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;
 
 import 'dart:collection';
 import 'dart:math' show max;
 
 import 'package:js_runtime/shared/async_await_error_codes.dart' as error_codes;
@@ skipping 1634 matching lines @@
 
 class AsyncRewriter extends AsyncRewriterBase {
   bool get isAsync => true;
 
   /// The Completer that will finish an async function.
   ///
   /// Not used for sync* or async* functions.
   String completerName;
   js.VariableUse get completer => new js.VariableUse(completerName);
 
-  /// The function called by an async function to simulate an await or return.
+  /// The function called by an async function to initiate asynchronous
+  /// execution of the body.  This is called with:
   ///
-  /// For an await it is called with:
+  /// - The body function [bodyName].
+  /// - the completer object [completer].
+  ///
+  /// It returns the completer's future. Passing the completer and returning its
+  /// future is a convenience to allow both the initiation and fetching the
+  /// future to be compactly encoded in a return statement's expression.
+  final js.Expression asyncStart;
+
+  /// Function called by the async function to simulate an `await`
+  /// expression. It is called with:
   ///
   /// - The value to await
   /// - The body function [bodyName]
+  final js.Expression asyncAwait;
+
+  /// Function called by the async function to simulate a return.
+  /// It is called with:
+  ///
+  /// - The value to return
   /// - The completer object [completer]
+  final js.Expression asyncReturn;
+
+  /// Function called by the async function to simulate a rethrow.
+  /// It is called with:
   ///
-  /// For a return it is called with:
-  ///
-  /// - The value to complete the completer with.
-  /// - [error_codes.SUCCESS]
+  /// - The value containing the exception and stack
   /// - The completer object [completer]
-  ///
-  /// For a throw it is called with:
-  ///
-  /// - The error to complete the completer with.
-  /// - [error_codes.ERROR]
-  /// - The completer object [completer]
-  final js.Expression asyncHelper;
+  final js.Expression asyncRethrow;
 
   /// Constructor used to initialize the [completer] variable.
   ///
   /// Specific to async methods.
   final js.Expression completerFactory;
 
   final js.Expression wrapBody;
 
   AsyncRewriter(DiagnosticReporter reporter, Spannable spannable,
-      {this.asyncHelper,
+      {this.asyncStart,
+      this.asyncAwait,
+      this.asyncReturn,
+      this.asyncRethrow,
       this.completerFactory,
       this.wrapBody,
       String safeVariableName(String proposedName),
       js.Name bodyName})
       : super(reporter, spannable, safeVariableName, bodyName);
 
   @override
   void addYield(js.DartYield node, js.Expression expression) {
     reporter.internalError(spannable, "Yield in non-generating async function");
   }
 
   void addErrorExit() {
     beginLabel(rethrowLabel);
     addStatement(js.js.statement(
-        "return #thenHelper(#currentError, #errorCode, #completer);", {
-      "thenHelper": asyncHelper,
-      "errorCode": js.number(error_codes.ERROR),
+        "return #thenHelper(#currentError, #completer);", {
+      "thenHelper": asyncRethrow,
       "currentError": currentError,
       "completer": completer
     }));
   }
 
   /// Returning from an async method calls [asyncStarHelper] with the result.
   /// (the result might have been stored in [returnValue] by some finally
   /// block).
   void addSuccesExit() {
     if (analysis.hasExplicitReturns) {
       beginLabel(exitLabel);
     } else {
       addStatement(new js.Comment("implicit return"));
     }
-    addStatement(js.js.statement(
-        "return #runtimeHelper(#returnValue, #successCode, #completer);", {
-      "runtimeHelper": asyncHelper,
-      "successCode": js.number(error_codes.SUCCESS),
+    addStatement(
+        js.js.statement("return #runtimeHelper(#returnValue, #completer);", {
+      "runtimeHelper": asyncReturn,
       "returnValue":
           analysis.hasExplicitReturns ? returnValue : new js.LiteralNull(),
       "completer": completer
     }));
   }
 
   @override
   Iterable<js.VariableInitialization> variableInitializations() {
     List<js.VariableInitialization> variables = <js.VariableInitialization>[];
     variables.add(
         _makeVariableInitializer(completer, new js.Call(completerFactory, [])));
     if (analysis.hasExplicitReturns) {
       variables.add(_makeVariableInitializer(returnValue, null));
     }
     return variables;
   }
 
   @override
   void initializeNames() {
     completerName = freshName("completer");
   }
 
   @override
   js.Statement awaitStatement(js.Expression value) {
     return js.js.statement(
         """
           return #asyncHelper(#value,
-                              #bodyName,
-                              #completer);
+                              #bodyName);
           """,
         {
-          "asyncHelper": asyncHelper,
+          "asyncHelper": asyncAwait,
           "value": value,
           "bodyName": bodyName,
-          "completer": completer
         });
   }
 
   @override
   js.Fun finishFunction(
       List<js.Parameter> parameters,
       js.Statement rewrittenBody,
       js.VariableDeclarationList variableDeclarations,
       SourceInformation sourceInformation) {
     return js.js(
         """
         function (#parameters) {
           #variableDeclarations;
           var #bodyName = #wrapBody(function (#errorCode, #result) {
             if (#errorCode === #ERROR) {
                 #currentError = #result;
                 #goto = #handler;
             }
             #rewrittenBody;
           });
-          return #asyncHelper(null, #bodyName, #completer);
+          return #asyncStart(#bodyName, #completer);
         }""",
         {
           "parameters": parameters,
           "variableDeclarations": variableDeclarations,
           "ERROR": js.number(error_codes.ERROR),
           "rewrittenBody": rewrittenBody,
           "bodyName": bodyName,
           "currentError": currentError,
           "goto": goto,
           "handler": handler,
           "errorCode": errorCodeName,
           "result": resultName,
-          "asyncHelper": asyncHelper,
+          "asyncStart": asyncStart,
           "completer": completer,
           "wrapBody": wrapBody,
         }).withSourceInformation(sourceInformation);
   }
 }
 
 class SyncStarRewriter extends AsyncRewriterBase {
   bool get isSyncStar => true;
 
   /// Constructor creating the Iterable for a sync* method. Called with
@@ skipping 786 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }