Implementation of async-await transformation on js ast.

pkg/compiler/lib/src/ssa/builder.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 SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
 
   SsaFunctionCompiler(JavaScriptBackend backend, bool generateSourceMap)
       : generator = new SsaCodeGeneratorTask(backend),
         builder = new SsaBuilderTask(backend, generateSourceMap),
         optimizer = new SsaOptimizerTask(backend);
 
   /// Generates JavaScript code for `work.element`.
   /// Using the ssa builder, optimizer and codegenerator.
   js.Fun compile(CodegenWorkItem work) {
     HGraph graph = builder.build(work);
     optimizer.optimize(work, graph);
-    return generator.generateCode(work, graph);
+    Element element = work.element;
+    js.Expression result = generator.generateCode(work, graph);
+    if (element is FunctionElement) {

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

For another CL: the FunctionCompiler should *not* be in the ssa-builder file.

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

Acknowledged.

+      JavaScriptBackend backend = builder.backend;
+      if (element.asyncMarker == AsyncMarker.ASYNC) {
+        result = new AsyncRewriter(
+            thenHelper:
+                backend.emitter.staticFunctionAccess(backend.getThenHelper()),
+            newController: new js.New(backend.emitter.staticFunctionAccess(
+                backend.getCompleterConstructor()), []),
+            safeVariableName: backend.namer.safeVariableName)
+            .rewrite(result);

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

The "rewrite" drowns in the whole expression.
Create a rewriter first, and then call 'rewrite' on it.

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

Done.

+      } else if (element.asyncMarker == AsyncMarker.SYNC_STAR) {
+        result = new AsyncRewriter(
+            endOfIteration: backend.emitter.staticFunctionAccess(
+                backend.getEndOfIteration()),
+            newIterable: backend.emitter.staticFunctionAccess(
+                backend.getSyncStarIterableConstructor()),
+            yieldStarExpression: backend.emitter.staticFunctionAccess(
+                backend.getSyncStarYieldStar()),
+            safeVariableName: backend.namer.safeVariableName)
+            .rewrite(result);
+      }
+      else if (element.asyncMarker == AsyncMarker.ASYNC_STAR) {
+        result = new AsyncRewriter(
+            thenHelper: backend.emitter.staticFunctionAccess(
+                backend.getStreamHelper()),
+            newController: new js.Call(backend.emitter.staticFunctionAccess(
+                backend.getMakeController()), []),
+            safeVariableName: backend.namer.safeVariableName,
+            yieldExpression: backend.emitter.staticFunctionAccess(
+                backend.getYieldSingle()))
+            .rewrite(result);
+      }
+    }
+    return result;
   }
 
   Iterable<CompilerTask> get tasks {
     return <CompilerTask>[builder, optimizer, generator];
   }
 }
 
 /// A synthetic local variable only used with the SSA graph.
 ///
 /// For instance used for holding return value of function or the exception of a
@@ skipping 322 matching lines @@
     }
   }
 
   /**
    * Returns true if the local can be accessed directly. Boxed variables or
    * captured variables that are stored in the closure-field return [:false:].
    */
   bool isAccessedDirectly(Local local) {
     assert(local != null);
     return !redirectionMapping.containsKey(local)
-        && !closureData.usedVariablesInTry.contains(local);
+        && !closureData.variablesUsedInTryOrGenerator.contains(local);
   }
 
   bool isStoredInClosureField(Local local) {
     assert(local != null);
     if (isAccessedDirectly(local)) return false;
     CapturedVariable redirectTarget = redirectionMapping[local];
     if (redirectTarget == null) return false;
     return redirectTarget is ClosureFieldElement;
   }
 
   bool isBoxed(Local local) {
     if (isAccessedDirectly(local)) return false;
     if (isStoredInClosureField(local)) return false;
     return redirectionMapping.containsKey(local);
   }
 
-  bool isUsedInTry(Local local) {
-    return closureData.usedVariablesInTry.contains(local);
+  bool isUsedInTryOrGenerator(Local local) {
+    return closureData.variablesUsedInTryOrGenerator.contains(local);
   }
 
   /**
    * Returns an [HInstruction] for the given element. If the element is
    * boxed or stored in a closure then the method generates code to retrieve
    * the value.
    */
   HInstruction readLocal(Local local) {
     if (isAccessedDirectly(local)) {
       if (directLocals[local] == null) {
@@ skipping 21 matching lines @@
       // accessed as direct local. Inside the nested closure the box is
       // accessed through a closure-field.
       // Calling [readLocal] makes sure we generate the correct code to get
       // the box.
       HInstruction box = readLocal(redirect.box);
       HInstruction lookup = new HFieldGet(
           redirect, box, builder.getTypeOfCapturedVariable(redirect));
       builder.add(lookup);
       return lookup;
     } else {
-      assert(isUsedInTry(local));
+      assert(isUsedInTryOrGenerator(local));
       HLocalValue localValue = getLocal(local);
       HInstruction instruction = new HLocalGet(
           local, localValue, builder.backend.dynamicType);
       builder.add(instruction);
       return instruction;
     }
   }
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisLocal);
@@ skipping 35 matching lines @@
       directLocals[local] = value;
     } else if (isBoxed(local)) {
       BoxFieldElement redirect = redirectionMapping[local];
       // The box itself could be captured, or be local. A local variable that
       // is captured will be boxed, but the box itself will be a local.
       // Inside the closure the box is stored in a closure-field and cannot
       // be accessed directly.
       HInstruction box = readLocal(redirect.box);
       builder.add(new HFieldSet(redirect, box, value));
     } else {
-      assert(isUsedInTry(local));
+      assert(isUsedInTryOrGenerator(local));
       HLocalValue localValue = getLocal(local);
       builder.add(new HLocalSet(local, localValue, value));
     }
   }
 
   /**
    * This function, startLoop, must be called before visiting any children of
    * the loop. In particular it needs to be called before executing the
    * initializers.
    *
@@ skipping 4665 matching lines @@
   visitThrow(ast.Throw node) {
     visitThrowExpression(node.expression);
     if (isReachable) {
       handleInTryStatement();
       push(new HThrowExpression(pop()));
       isReachable = false;
     }
   }
 
   visitYield(ast.Yield node) {
-    // Dummy implementation.
     visit(node.expression);
+    HInstruction yielded = pop();
+    push(new HYield(yielded, node.hasStar));

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

I think there is a function that does this. Maybe 'add' or something.
(in any case: push followed by pop should not be necessary).

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

Right, add does it.

     pop();
   }
 
   visitAwait(ast.Await node) {
-    // Dummy implementation.
     visit(node.expression);
+    HInstruction awaited = pop();
+    // TODO(herhut): Improve this type.
+    push(new HAwait(awaited, new TypeMask.subclass(compiler.objectClass,
+                                                   compiler.world)));
   }
 
   visitTypeAnnotation(ast.TypeAnnotation node) {
     compiler.internalError(node,
         'Visiting type annotation in SSA builder.');
   }
 
   visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isReachable);
     for (Link<ast.Node> link = node.definitions.nodes;
@@ skipping 123 matching lines @@
       return new NullJumpHandler(compiler);
     }
     if (isLoopJump && node is ast.SwitchStatement) {
       // Create a special jump handler for loops created for switch statements
       // with continue statements.
       return new SwitchCaseJumpHandler(this, element, node);
     }
     return new JumpHandler(this, element);
   }
 
+

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

no need for the new line.

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

Done.

   visitForIn(ast.ForIn node) {
+    if (node.isAsync) {

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

Move the code into a separate function.

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

Done.

+      // The async for is implemented with a StreamIterator.

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

async-for

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

Done.

+      HInstruction streamIterator;
+
+      visit(node.expression);
+      HInstruction expression = pop();
+      pushInvokeStatic(node,
+                       backend.getStreamIteratorConstructor(),
+                       [expression, graph.addConstantNull(compiler)]);
+      streamIterator = pop();
+      void buildInitializer() {

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

nested functions should have a new line before and after.

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

Done.

+      }
+      HInstruction buildCondition() {
+        Selector selector = elements.getMoveNextSelector(node);
+        pushInvokeDynamic(node, selector, [streamIterator]);
+        HInstruction future = pop();
+        push(new HAwait(future, new TypeMask.subclass(compiler.objectClass,
+                                                      compiler.world)));
+        return popBoolified();
+      }
+      void buildBody() {
+        Selector call = elements.getCurrentSelector(node);
+        pushInvokeDynamic(node, call, [streamIterator]);
+
+        ast.Node identifier = node.declaredIdentifier;
+        Element variable = elements.getForInVariable(node);
+        Selector selector = elements.getSelector(identifier);
+
+        HInstruction value = pop();
+        if (identifier.asSend() != null
+            && Elements.isInstanceSend(identifier, elements)) {
+          HInstruction receiver = generateInstanceSendReceiver(identifier);
+          assert(receiver != null);
+          generateInstanceSetterWithCompiledReceiver(
+              null,
+              receiver,
+              value,
+              selector: selector,
+              location: identifier);
+        } else {
+          generateNonInstanceSetter(
+              null, variable, value, location: identifier);
+        }
+        pop(); // Pop the value pushed by the setter call.
+
+        visit(node.body);
+      }
+      buildProtected(() {
+        handleLoop(node, buildInitializer, buildCondition, () {}, buildBody);

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

Since you already give a name to the buildInitializer, might as well do the same
for the updater.
Alternatively assign them to local variables, so that they have a name:

Function buildInitializer = () {};
Function buildUpdate = () {};
handleLoop(...);

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

Done.

+      }, () {
+        pushInvokeDynamic(node, new Selector.call("cancel", null, 0),
+            [streamIterator]);
+        push(new HAwait(pop(), new TypeMask.subclass(compiler.objectClass,
+            compiler.world)));
+        pop();
+      });
+      return;
+    }
+
     // Generate a structure equivalent to:
     //   Iterator<E> $iter = <iterable>.iterator;
     //   while ($iter.moveNext()) {
     //     E <declaredIdentifier> = $iter.current;
     //     <body>
     //   }
 
     // The iterator is shared between initializer, condition and body.
     HInstruction iterator;
     void buildInitializer() {
@@ skipping 515 matching lines @@
   }
 
   visitSwitchCase(ast.SwitchCase node) {
     compiler.internalError(node, 'SsaFromAstMixin.visitSwitchCase.');
   }
 
   visitCaseMatch(ast.CaseMatch node) {
     compiler.internalError(node, 'SsaFromAstMixin.visitCaseMatch.');
   }
 
+  buildProtected(void buildTry(), void buildFinally()) {

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

return type.

Change name, since it's not a general "buildProtected".

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

Done.

[floitsch, 2015/02/04 12:31:27]

That's not what I meant.
If the buildProtected works in the general case, then keep the name. I was under
the impression that it is specialized for the buildAsyncForIn. (It definitely
would be if you don't clone the locals).

+    // Save the current locals. The catch block and the finally block
+    // must not reuse the existing locals handler. None of the variables
+    // that have been defined in the body-block will be used, but for
+    // loops we will add (unnecessary) phis that will reference the body
+    // variables. This makes it look as if the variables were used
+    // in a non-dominated block.

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

Does this comment apply for us?

Do we really need to clone the localshandler?

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

Not sure - I will ask

[sigurdm, 2015/02/04 11:43:39]

I discussed with Karl, and you are right - it is only needed for the
catch-block. I will remove it.

[floitsch, 2015/02/04 12:31:27]

I would say no, since the only variable that is used in the finally is the
iterator, and that one is finally. It might be safer to do a clone, though.

+    LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
+    HBasicBlock enterBlock = openNewBlock();
+    HTry tryInstruction = new HTry();
+    close(tryInstruction);
+    bool oldInTryStatement = inTryStatement;
+    inTryStatement = true;
+
+    HBasicBlock startTryBlock;
+    HBasicBlock endTryBlock;
+    HBasicBlock startFinallyBlock;
+    HBasicBlock endFinallyBlock;
+
+    startTryBlock = graph.addNewBlock();
+    open(startTryBlock);
+    buildTry();
+    // We use a [HExitTry] instead of a [HGoto] for the try block
+    // because it will have multiple successors: the join block, and
+    // the catch or finally block.

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

It won't have any catch block.

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

Done.

+    if (!isAborted()) endTryBlock = close(new HExitTry());
+    SubGraph bodyGraph = new SubGraph(startTryBlock, lastOpenedBlock);
+    SubGraph catchGraph = null;

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

Remove variable.

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

Done.

+    HLocalValue exception = null;

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

Remove (and inline) ?

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

Done.

+
+    SubGraph finallyGraph = null;
+
+    localsHandler = new LocalsHandler.from(savedLocals);
+    startFinallyBlock = graph.addNewBlock();
+    open(startFinallyBlock);
+    buildFinally();
+    if (!isAborted()) endFinallyBlock = close(new HGoto());
+    tryInstruction.finallyBlock = startFinallyBlock;
+    finallyGraph = new SubGraph(startFinallyBlock, lastOpenedBlock);
+
+    HBasicBlock exitBlock = graph.addNewBlock();
+
+    addExitTrySuccessor(successor) {

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

add return type. (especially for nested functions).
(also missing type for argument).

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

Done.

+      if (successor == null) return;

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

Check should be unnecessary.

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

Done.

+      // Iterate over all blocks created inside this try/catch, and
+      // attach successor information to blocks that end with
+      // [HExitTry].
+      for (int i = startTryBlock.id; i < successor.id; i++) {
+        HBasicBlock block = graph.blocks[i];
+        var last = block.last;
+        if (last is HExitTry) {
+          block.addSuccessor(successor);
+        }
+      }
+    }
+
+    // Setup all successors. The entry block that contains the [HTry]
+    // has 1) the body, 2) the catch, 3) the finally, and 4) the exit

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

no catch.

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

Done.

+    // blocks as successors.
+    enterBlock.addSuccessor(startTryBlock);
+    enterBlock.addSuccessor(startFinallyBlock);
+    enterBlock.addSuccessor(exitBlock);
+
+    // The body has either the catch or the finally block as successor.

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

no catch.

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

Done.

+    if (endTryBlock != null) {
+      endTryBlock.addSuccessor(startFinallyBlock);
+      endTryBlock.addSuccessor(exitBlock);
+    }
+
+    // The finally block has the exit block as successor.
+    endFinallyBlock.addSuccessor(exitBlock);
+
+    // If a block inside try/catch aborts (eg with a return statement),
+    // we explicitely mark this block a predecessor of the catch
+    // block and the finally block.
+    addExitTrySuccessor(startFinallyBlock);
+
+    // Use the locals handler not altered by the catch and finally
+    // blocks.
+    localsHandler = savedLocals;
+    open(exitBlock);
+    enterBlock.setBlockFlow(
+        new HTryBlockInformation(
+          wrapStatementGraph(bodyGraph),
+          exception,
+          null, // No catchGraph
+          wrapStatementGraph(finallyGraph)),
+        exitBlock);
+    inTryStatement = oldInTryStatement;
+  }
+
   visitTryStatement(ast.TryStatement node) {
     // Save the current locals. The catch block and the finally block
     // must not reuse the existing locals handler. None of the variables
     // that have been defined in the body-block will be used, but for
     // loops we will add (unnecessary) phis that will reference the body
     // variables. This makes it look as if the variables were used
     // in a non-dominated block.
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     HBasicBlock enterBlock = openNewBlock();
     HTry tryInstruction = new HTry();
@@ skipping 174 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
           wrapStatementGraph(bodyGraph),
           exception,
           wrapStatementGraph(catchGraph),
           wrapStatementGraph(finallyGraph)),
         exitBlock);
     inTryStatement = oldInTryStatement;
   }
 
+
   visitCatchBlock(ast.CatchBlock node) {
     visit(node.block);
   }
 
   visitTypedef(ast.Typedef node) {
     compiler.unimplemented(node, 'SsaFromAstMixin.visitTypedef.');
   }
 
   visitTypeVariable(ast.TypeVariable node) {
     compiler.internalError(node, 'SsaFromAstMixin.visitTypeVariable.');
@@ skipping 155 matching lines @@
   InlineWeeder(this.maxInliningNodes,
                this.useMaxInliningNodes,
                this.allowLoops);
 
   static bool canBeInlined(ast.FunctionExpression functionExpression,
                            int maxInliningNodes,
                            bool useMaxInliningNodes,
                            {bool allowLoops: false}) {
     InlineWeeder weeder =
         new InlineWeeder(maxInliningNodes, useMaxInliningNodes, allowLoops);
+    if (functionExpression.asyncModifier != null) return false;
     weeder.visit(functionExpression.initializers);
     weeder.visit(functionExpression.body);
     return !weeder.tooDifficult;
   }
 
   bool registerNode() {
     if (!useMaxInliningNodes) return true;
     if (nodeCount++ > maxInliningNodes) {
       tooDifficult = true;
       return false;
@@ skipping 66 matching lines @@
   void visitThrow(ast.Throw node) {
     if (!registerNode()) return;
     // For now, we don't want to handle throw after a return even if
     // it is in an "if".
     if (seenReturn) {
       tooDifficult = true;
     } else {
       node.visitChildren(this);
     }
   }
+
+  void visitAwait(ast.Await node) {
+    if (!registerNode()) return;
+    tooDifficult = true;

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

How can this happen, when we already return if there is an async-modifier?

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

Right - I added this one first, then realized that it was not enough. But now it
is redundant.

+  }
 }
 
 abstract class InliningState {
   /**
    * Invariant: [function] must be an implementation element.
    */
   final FunctionElement function;
 
   InliningState(this.function) {
     assert(function.isImplementation);
@@ skipping 351 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }