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 45 matching lines @@
       canBeInlined[element] = false;
       canBeInlinedInsideLoop[element] = false;
     } else {
       canBeInlined[element] = false;
     }
   }
 }
 
 class JavaScriptBackend extends Backend {
   static final Uri DART_JS_HELPER = new Uri(scheme: 'dart', path: '_js_helper');
+  static final Uri DART_ASYNC = new Uri(scheme: 'dart', path: 'async');

[Johnni Winther, 2015/02/02 10:45:10]

Not needed (exists on [Compiler]).

[sigurdm, 2015/02/03 16:59:27]

Done

   static final Uri DART_INTERCEPTORS =
       new Uri(scheme: 'dart', path: '_interceptors');
   static final Uri DART_INTERNAL =
       new Uri(scheme: 'dart', path: '_internal');
   static final Uri DART_FOREIGN_HELPER =
       new Uri(scheme: 'dart', path: '_foreign_helper');
   static final Uri DART_JS_MIRRORS =
       new Uri(scheme: 'dart', path: '_js_mirrors');
   static final Uri DART_JS_NAMES =
       new Uri(scheme: 'dart', path: '_js_names');
@@ skipping 39 matching lines @@
   /**
    * The generated code as a js AST for compiled methods.
    */
   Map<Element, jsAst.Expression> get generatedCode {
     return compiler.enqueuer.codegen.generatedCode;
   }
 
   FunctionInlineCache inlineCache = new FunctionInlineCache();
 
   LibraryElement jsHelperLibrary;
+  LibraryElement asyncLibrary;
   LibraryElement interceptorsLibrary;
   LibraryElement foreignLibrary;
   LibraryElement isolateHelperLibrary;
 
   ClassElement closureClass;
   ClassElement boundClosureClass;
   Element assertMethod;
   Element invokeOnMethod;
 
   ClassElement jsInterceptorClass;
@@ skipping 799 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 getFuture() {

[Johnni Winther, 2015/02/02 10:45:10]

This is [Compiler.futureClass].

[sigurdm, 2015/02/03 16:59:27]

And was not used anymore.
Thanks.

+    return asyncLibrary.find("Future");
+  }
+
+  Element getThenHelper() {
+    return findHelper("thenHelper");
+  }
+
+  Element getSyncStarYieldStar() {
+    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(asyncLibrary, "Completer");
+    classElement.ensureResolved(compiler);
+    return classElement
+        .lookupConstructor("");
+  }
+
+  Element getMakeController() {
+    return findHelper("makeAsyncStarController");
+  }
+
+  Element getStreamIteratorConstructor() {
+    ClassElement classElement = find(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 79 matching lines @@
       }
       return true;
     }
     return false;
   }
 
   void onLibraryCreated(LibraryElement library) {
     Uri uri = library.canonicalUri;
     if (uri == DART_JS_HELPER) {
       jsHelperLibrary = library;
+    } else if (uri == DART_ASYNC) {
+      asyncLibrary = library;

[Johnni Winther, 2015/02/02 10:45:10]

Not needed.

[sigurdm, 2015/02/03 16:59:27]

Done

     } else if (uri == DART_INTERNAL) {
       internalLibrary = library;
     } else if (uri ==  DART_INTERCEPTORS) {
       interceptorsLibrary = library;
     } else if (uri ==  DART_FOREIGN_HELPER) {
       foreignLibrary = library;
     } else if (uri == DART_ISOLATE_HELPER) {
       isolateHelperLibrary = library;
     }
   }
@@ skipping 615 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, getSyncStarYieldStar(), registry);
+    } else if (element.asyncMarker == AsyncMarker.ASYNC_STAR) {
+      enqueue(enqueuer, getStreamHelper(), registry);
+      enqueue(enqueuer, getYieldSingle(), registry);
+      enqueue(enqueuer, getMakeController(), 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);
 }