dart2js cps: Support async/await by rewriting the JavaScript AST.

pkg/compiler/lib/src/js_backend/backend.dart

Index: pkg/compiler/lib/src/js_backend/backend.dart
diff --git a/pkg/compiler/lib/src/js_backend/backend.dart b/pkg/compiler/lib/src/js_backend/backend.dart
index 1c0f82c678f7346723807bd2df9ac4fab933c7a5..099a813756d08271acfd33c319e139476a15557d 100644
--- a/pkg/compiler/lib/src/js_backend/backend.dart
+++ b/pkg/compiler/lib/src/js_backend/backend.dart
@@ -2731,6 +2731,55 @@ class JavaScriptBackend extends Backend {
     }
     return true;
   }
+
+  jsAst.Expression rewriteAsync(FunctionElement element,
+                                jsAst.Expression code) {
+    AsyncRewriterBase rewriter = null;
+    jsAst.Name name = namer.methodPropertyName(element);
+    if (element.asyncMarker == AsyncMarker.ASYNC) {
+      rewriter = new AsyncRewriter(
+          compiler,
+          compiler.currentElement,
+          asyncHelper:
+              emitter.staticFunctionAccess(getAsyncHelper()),
+          newCompleter: emitter.staticFunctionAccess(
+              getCompleterConstructor()),
+          safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
+          bodyName: namer.deriveAsyncBodyName(name));
+    } else if (element.asyncMarker == AsyncMarker.SYNC_STAR) {
+      rewriter = new SyncStarRewriter(
+          compiler,
+          compiler.currentElement,
+          endOfIteration: emitter.staticFunctionAccess(
+              getEndOfIteration()),
+          newIterable: emitter.staticFunctionAccess(
+              getSyncStarIterableConstructor()),
+          yieldStarExpression: emitter.staticFunctionAccess(
+              getYieldStar()),
+          uncaughtErrorExpression: emitter.staticFunctionAccess(
+              getSyncStarUncaughtError()),
+          safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
+          bodyName: namer.deriveAsyncBodyName(name));
+    }
+    else if (element.asyncMarker == AsyncMarker.ASYNC_STAR) {

[Kevin Millikin (Google), 2015/08/07 08:52:32]

else if is on the wrong line.  I'd probably write a switch here and return from
each of the cases, but yours is OK too.

+      rewriter = new AsyncStarRewriter(
+          compiler,
+          compiler.currentElement,
+          asyncStarHelper: emitter.staticFunctionAccess(
+              getAsyncStarHelper()),
+          streamOfController: emitter.staticFunctionAccess(
+              getStreamOfController()),
+          newController: emitter.staticFunctionAccess(
+              getASyncStarControllerConstructor()),
+          safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
+          yieldExpression: emitter.staticFunctionAccess(
+              getYieldSingle()),
+          yieldStarExpression: emitter.staticFunctionAccess(
+              getYieldStar()),
+          bodyName: namer.deriveAsyncBodyName(name));
+    }
+    return rewriter != null ? rewriter.rewrite(code) : code;

[Kevin Millikin (Google), 2015/08/07 08:52:32]

It seems like the only call is guarded by asyncMarker != AsyncMarker.SYNC.  I
think it's clearer to either assert that (and so rewriter is not null unless we
get a new AsyncMarker), or else to call this function unconditionally because it
can handle any function.

+  }
 }
 
 /// Handling of special annotations for tests.