Implementation of async-await transformation on js ast.

pkg/compiler/lib/src/ssa/codegen.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 ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 34 matching lines @@
     return node.withPosition(sourcePosition, endSourcePosition);
   }
 
   SourceFile sourceFileOfElement(Element element) {
     return element.implementation.compilationUnit.script.file;
   }
 
   js.Fun buildJavaScriptFunction(FunctionElement element,
                                  List<js.Parameter> parameters,
                                  js.Block body) {
-    return attachPosition(new js.Fun(parameters, body), element);
+    js.AsyncModifier asyncModifier = element.asyncMarker.isAsync
+        ? (element.asyncMarker.isYielding
+            ? const js.AsyncModifier.asyncStar()
+            : const js.AsyncModifier.async())
+        : (element.asyncMarker.isYielding
+            ? const js.AsyncModifier.syncStar()
+            : const js.AsyncModifier.sync());
+
+    return attachPosition(
+        new js.Fun(parameters, body, asyncModifier: asyncModifier), element);
   }
 
   js.Expression generateCode(CodegenWorkItem work, HGraph graph) {
     if (work.element.isField) {
       return generateLazyInitializer(work, graph);
     } else {
       return generateMethod(work, graph);
     }
   }
 
   js.Expression generateLazyInitializer(work, graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen", graph);
       SsaCodeGenerator codegen = new SsaCodeGenerator(backend, work);
       codegen.visitGraph(graph);
       return new js.Fun(codegen.parameters,
           attachPosition(codegen.body, work.element));
     });
   }
 
   js.Expression generateMethod(CodegenWorkItem work, HGraph graph) {
     return measure(() {
+      Element element = work.element;
+      if (element is FunctionElement &&
+          element.asyncMarker != AsyncMarker.SYNC) {
+        work.registry.registerAsyncMarker(element);
+      }
       SsaCodeGenerator codegen = new SsaCodeGenerator(backend, work);
       codegen.visitGraph(graph);
       compiler.tracer.traceGraph("codegen", graph);
-      FunctionElement element = work.element;
       return buildJavaScriptFunction(element, codegen.parameters, codegen.body);
     });
   }
 }
 
 typedef void EntityAction(Entity element);
 
 class SsaCodeGenerator implements HVisitor, HBlockInformationVisitor {
   /**
    * Returned by [expressionType] to tell how code can be generated for
@@ skipping 1870 matching lines @@
 
   visitThrow(HThrow node) {
     if (node.isRethrow) {
       use(node.inputs[0]);
       pushStatement(new js.Throw(pop()), node);
     } else {
       generateThrowWithHelper('wrapException', node.inputs[0]);
     }
   }
 
+  visitAwait(HAwait node) {
+    use(node.inputs[0]);
+    push(new js.Await(pop()), node);
+  }
+
+  visitYield(HYield node) {
+    use(node.inputs[0]);
+    pushStatement(new js.Yield(pop(), node.hasStar), node);
+  }
+
   visitRangeConversion(HRangeConversion node) {
     // Range conversion instructions are removed by the value range
     // analyzer.
     assert(false);
   }
 
   visitBoundsCheck(HBoundsCheck node) {
     // TODO(ngeoffray): Separate the two checks of the bounds check, so,
     // e.g., the zero checks can be shared if possible.
 
@@ skipping 58 matching lines @@
       arguments.add(pop());
     }
     js.Call value = new js.Call(jsHelper, arguments.toList(growable: false));
     value = attachLocation(value, location);
     // BUG(4906): Using throw/return here adds to the size of the generated code
     // but it has the advantage of explicitly telling the JS engine that
     // this code path will terminate abruptly. Needs more work.
     if (helperName == 'wrapException') {
       pushStatement(new js.Throw(value));
     } else {
-      pushStatement(new js.Return(value));
+      pushStatement(new js.ExpressionStatement(value));

[floitsch, 2015/02/02 22:00:11]

I'm not sure I agree with this.
There is a reason the `return` is here.

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

Right - we need another solution. Return in a sync* or async* has a different
meaning.

[sigurdm, 2015/02/04 09:40:42]

I will omit the return only when in an async* or sync* function.

     }
   }
 
   visitThrowExpression(HThrowExpression node) {
     HInstruction argument = node.inputs[0];
     use(argument);
 
     Element helper = backend.findHelper("throwExpression");
     registry.registerStaticUse(helper);
 
@@ skipping 608 matching lines @@
   js.PropertyAccess accessHelper(String name) {
     Element helper = backend.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     registry.registerStaticUse(helper);
     return backend.emitter.staticFunctionAccess(helper);
   }
 }