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

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

 // Copyright (c) 2012, 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.
 
 part of js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 2713 matching lines @@
     if (compiler.useCpsIr) {
       compiler.reportHint(
           node,
           MessageKind.GENERIC,
           {'text': "Generation of code with compile time errors is currently "
                    "not supported with the CPS IR."});
       return false;
     }
     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.
 class Annotations {
   static final Uri PACKAGE_EXPECT =
       new Uri(scheme: 'package', path: 'expect/expect.dart');
 
   final Compiler compiler;
 
   ClassElement expectNoInlineClass;
@@ skipping 270 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }