Implementation of async-await transformation on js 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;
 
 const bool USE_CPS_IR = const bool.fromEnvironment("USE_CPS_IR");
 
@@ skipping 923 matching lines @@
     // will instantiate those two classes.
     addInterceptors(jsBoolClass, world, registry);
     addInterceptors(jsNullClass, world, registry);
     if (compiler.enableTypeAssertions) {
       // Unconditionally register the helper that checks if the
       // expression in an if/while/for is a boolean.
       // TODO(ngeoffray): Should we have the resolver register those instead?
       Element e = findHelper('boolConversionCheck');
       if (e != null) enqueue(world, e, registry);
     }
+
     if (TRACE_CALLS) {
       traceHelper = findHelper('traceHelper');
       assert(traceHelper != null);
       enqueueInResolution(traceHelper, registry);
     }
     registerCheckedModeHelpers(registry);
   }
 
   onResolutionComplete() {
     super.onResolutionComplete();
@@ skipping 636 matching lines @@
   }
 
   Element getCreateInvocationMirror() {
     return findHelper(Compiler.CREATE_INVOCATION_MIRROR);
   }
 
   Element getCyclicThrowHelper() {
     return findHelper("throwCyclicInit");
   }
 
+  Element getThenHelper() {
+    return findHelper("thenHelper");
+  }
+
+  Element getYieldStar() {
+    ClassElement classElement = findHelper("IterationMarker");
+    classElement.ensureResolved(compiler);
+    return classElement.lookupLocalMember("yieldStar");
+  }
+
+  Element getYieldSingle() {
+    ClassElement classElement = findHelper("IterationMarker");
+    classElement.ensureResolved(compiler);
+    return classElement.lookupLocalMember("yieldSingle");
+  }
+
+  Element getStreamHelper() {
+    return findHelper("streamHelper");
+  }
+
+  Element getEndOfIteration() {
+    ClassElement classElement = findHelper("IterationMarker");
+    classElement.ensureResolved(compiler);
+    return classElement.lookupLocalMember("endOfIteration");
+  }
+
+  Element getSyncStarIterable() {
+    ClassElement classElement = findHelper("SyncStarIterable");
+    classElement.ensureResolved(compiler);
+    return classElement;
+  }
+
+  Element getSyncStarIterableConstructor() {
+    ClassElement classElement = getSyncStarIterable();
+    classElement.ensureResolved(compiler);
+    return classElement.lookupConstructor("");
+  }
+
+  Element getCompleterConstructor() {
+    ClassElement classElement = find(compiler.asyncLibrary, "Completer");
+    classElement.ensureResolved(compiler);
+    return classElement.lookupConstructor("");
+  }
+
+  Element getASyncStarController() {
+    ClassElement classElement = findHelper("AsyncStarStreamController");
+    classElement.ensureResolved(compiler);
+    return classElement;
+  }
+
+  Element getASyncStarControllerConstructor() {
+    ClassElement classElement = getASyncStarController();
+    return classElement.lookupConstructor("");
+  }
+
+  Element getStreamIteratorConstructor() {
+    ClassElement classElement = find(compiler.asyncLibrary, "StreamIterator");
+    classElement.ensureResolved(compiler);
+    return classElement.lookupConstructor("");
+  }
+
   bool isNullImplementation(ClassElement cls) {
     return cls == jsNullClass;
   }
 
   ClassElement get intImplementation => jsIntClass;
   ClassElement get uint32Implementation => jsUInt32Class;
   ClassElement get uint31Implementation => jsUInt31Class;
   ClassElement get positiveIntImplementation => jsPositiveIntClass;
   ClassElement get doubleImplementation => jsDoubleClass;
   ClassElement get numImplementation => jsNumberClass;
@@ skipping 714 matching lines @@
   /// If [addExtension] is false, the ".part.js" suffix is left out.
   String deferredPartFileName(String name, {bool addExtension: true}) {
     assert(name != "");
     String outPath = compiler.outputUri != null
         ? compiler.outputUri.path
         : "out";
     String outName = outPath.substring(outPath.lastIndexOf('/') + 1);
     String extension = addExtension ? ".part.js" : "";
     return "${outName}_$name$extension";
   }
+
+  void registerAsyncMarker(FunctionElement element,
+                           Enqueuer enqueuer,
+                           Registry registry) {
+    if (element.asyncMarker == AsyncMarker.ASYNC) {
+      enqueue(enqueuer, getThenHelper(), registry);
+      enqueue(enqueuer, getCompleterConstructor(), registry);
+      enqueue(enqueuer, getStreamIteratorConstructor(), registry);
+    } else if (element.asyncMarker == AsyncMarker.SYNC_STAR) {
+      enqueuer.registerInstantiatedClass(getSyncStarIterable(), registry);
+      enqueue(enqueuer, getSyncStarIterableConstructor(), registry);
+      enqueue(enqueuer, getEndOfIteration(), registry);
+      enqueue(enqueuer, getYieldStar(), registry);
+    } else if (element.asyncMarker == AsyncMarker.ASYNC_STAR) {
+      enqueuer.registerInstantiatedClass(getASyncStarController(), registry);
+      enqueue(enqueuer, getStreamHelper(), registry);
+      enqueue(enqueuer, getYieldSingle(), registry);
+      enqueue(enqueuer, getYieldStar(), registry);
+      enqueue(enqueuer, getASyncStarControllerConstructor(), registry);
+      enqueue(enqueuer, getStreamIteratorConstructor(), registry);
+    }
+  }
 }
 
 class JavaScriptResolutionCallbacks extends ResolutionCallbacks {
   final JavaScriptBackend backend;
 
   JavaScriptResolutionCallbacks(this.backend);
 
   void registerBackendStaticInvocation(Element element, Registry registry) {
     registry.registerStaticInvocation(backend.registerBackendUse(element));
   }
@@ skipping 186 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);
 }