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 225 matching lines @@
   static final Uri DART_ISOLATE_HELPER =
       new Uri(scheme: 'dart', path: '_isolate_helper');
   static final Uri DART_HTML =
       new Uri(scheme: 'dart', path: 'html');
 
   static const String INVOKE_ON = '_getCachedInvocation';
   static const String START_ROOT_ISOLATE = 'startRootIsolate';
 
 
   String get patchVersion => emitter.patchVersion;
-  
+
   bool get supportsReflection => emitter.emitter.supportsReflection;
 
   final Annotations annotations;
 
   /// Reference to the internal library to lookup functions to always inline.
   LibraryElement internalLibrary;
 
 
   /// Set of classes that need to be considered for reflection although not
   /// otherwise visible during resolution.
@@ skipping 2467 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);
+    switch (element.asyncMarker) {
+      case AsyncMarker.ASYNC:
+        rewriter = new AsyncRewriter(
+            compiler,
+            compiler.currentElement,
+            asyncHelper:
+                emitter.staticFunctionAccess(getAsyncHelper()),
+            newCompleter: emitter.staticFunctionAccess(
+                getCompleterConstructor()),
+            safeVariableName: namer.safeVariablePrefixForAsyncRewrite,
+            bodyName: namer.deriveAsyncBodyName(name));
+        break;
+      case 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));
+         break;
+      case AsyncMarker.ASYNC_STAR:
+        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));
+        break;
+      default:
+        assert(element.asyncMarker == AsyncMarker.SYNC);
+        return code;
+    }
+    return rewriter.rewrite(code);
+  }
 }
 
 /// 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);
 }