Implement async/await/yield and async for-in

pkg/compiler/lib/src/ssa/builder_kernel.dart

 // Copyright (c) 2016, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
@@ skipping 547 matching lines @@
     if (expression is ir.Throw) {
       // TODO(sra): Prevent generating a statement when inlining.
       _visitThrowExpression(expression.expression);
       closeAndGotoExit(new HThrow(pop(), null));
     } else {
       expression.accept(this);
       pop();
     }
   }
 
+  /// Returns true if the [type] is a valid return type for an asynchronous
+  /// function.
+  ///
+  /// Asynchronous functions return a `Future`, and a valid return is thus
+  /// either dynamic, Object, or Future.
+  ///
+  /// We do not accept the internal Future implementation class.
+  bool isValidAsyncReturnType(ir.DartType type) {
+    // TODO(sigurdm): In an internal library a function could be declared:
+    //
+    // _FutureImpl foo async => 1;
+    //
+    // This should be valid (because the actual value returned from an async
+    // function is a `_FutureImpl`), but currently false is returned in this
+    // case.
+    return type is ir.DynamicType ||
+        type == astAdapter.objectClass.thisType ||
+        (type is ir.InterfaceType && type == astAdapter.futureClass.thisType);
+  }
+
   @override
   void visitReturnStatement(ir.ReturnStatement returnStatement) {
     HInstruction value;
     if (returnStatement.expression == null) {
       value = graph.addConstantNull(closedWorld);
     } else {
       assert(_targetFunction != null && _targetFunction is ir.FunctionNode);
       returnStatement.expression.accept(this);
-      value = typeBuilder.potentiallyCheckOrTrustType(
-          pop(), astAdapter.getFunctionReturnType(_targetFunction));
+      value = pop();
+      if (_targetFunction.asyncMarker == ir.AsyncMarker.Async) {
+        var returnType = astAdapter.getDartType(_targetFunction.returnType);
+        if (compiler.options.enableTypeAssertions &&
+            !isValidAsyncReturnType(_targetFunction.returnType)) {
+          generateTypeError(
+              returnStatement,
+              "Async function returned a Future,"
+              " was declared to return a ${_targetFunction.returnType}.");
+          pop();
+          return;
+        }
+      } else {
+        value = typeBuilder.potentiallyCheckOrTrustType(
+            value, astAdapter.getFunctionReturnType(_targetFunction));
+      }
     }
     // TODO(het): Add source information
     // TODO(het): Set a return value instead of closing the function when we
     // support inlining.
     closeAndGotoExit(new HReturn(value, null));
   }
 
   @override
   void visitForStatement(ir.ForStatement forStatement) {
     assert(isReachable);
@@ skipping 26 matching lines @@
       forStatement.body.accept(this);
     }
 
     loopHandler.handleLoop(
         forStatement, buildInitializer, buildCondition, buildUpdate, buildBody);
   }
 
   @override
   void visitForInStatement(ir.ForInStatement forInStatement) {
     if (forInStatement.isAsync) {
-      compiler.reporter.internalError(astAdapter.getNode(forInStatement),
-          "Cannot compile async for-in using kernel.");
+      _buildAsyncForIn(forInStatement);
     }
     // If the expression being iterated over is a JS indexable type, we can
     // generate an optimized version of for-in that uses indexing.
     if (astAdapter.isJsIndexableIterator(forInStatement, closedWorld)) {
       _buildForInIndexable(forInStatement);
     } else {
       _buildForInIterator(forInStatement);
     }
   }
 
@@ skipping 134 matching lines @@
           selector: Selectors.current);
       localsHandler.updateLocal(
           astAdapter.getLocal(forInStatement.variable), pop());
       forInStatement.body.accept(this);
     }
 
     loopHandler.handleLoop(
         forInStatement, buildInitializer, buildCondition, () {}, buildBody);
   }
 
+  void _buildAsyncForIn(ir.ForInStatement forInStatement) {
+    // The async-for is implemented with a StreamIterator.
+    HInstruction streamIterator;
+
+    forInStatement.iterable.accept(this);
+    _pushStaticInvocation(
+        astAdapter.streamIteratorConstructor,
+        [pop(), graph.addConstantNull(closedWorld)],
+        astAdapter.streamIteratorConstructorType);
+    streamIterator = pop();
+
+    void buildInitializer() {}
+
+    HInstruction buildCondition() {
+      TypeMask mask = astAdapter.typeOfIteratorMoveNext(forInStatement);
+      _pushDynamicInvocation(forInStatement, mask, [streamIterator],
+          selector: Selectors.moveNext);
+      HInstruction future = pop();
+      push(new HAwait(future, astAdapter.makeSubtypeOfObject(closedWorld)));
+      return popBoolified();
+    }
+
+    void buildBody() {
+      TypeMask mask = astAdapter.typeOfIteratorCurrent(forInStatement);
+      _pushDynamicInvocation(forInStatement, mask, [streamIterator],
+          selector: Selectors.current);
+      localsHandler.updateLocal(
+          astAdapter.getLocal(forInStatement.variable), pop());
+      forInStatement.body.accept(this);
+    }
+
+    void buildUpdate() {}
+
+    // Creates a synthetic try/finally block in case anything async goes amiss.
+    TryCatchFinallyBuilder tryBuilder = new TryCatchFinallyBuilder(this);
+    // Build fake try body:
+    loopHandler.handleLoop(forInStatement, buildInitializer, buildCondition,
+        buildUpdate, buildBody);
+
+    void finalizerFunction() {
+      _pushDynamicInvocation(forInStatement, null, [streamIterator],
+          selector: Selectors.cancel);
+      push(new HAwait(pop(), astAdapter.makeSubtypeOfObject(closedWorld)));
+      pop();

[sra1, 2017/01/14 02:56:23]

push/pop = add

[Emily Fortuna, 2017/01/17 20:58:21]

Done.

+    }
+
+    tryBuilder
+      ..closeTryBody()
+      ..buildFinallyBlock(
+          new ir.TryFinally(null, new _FakeStatement(finalizerFunction)))

[sra1, 2017/01/14 02:56:23]

I'd rather buildFinallyBlock took a function (finalizerFunction).

[Emily Fortuna, 2017/01/17 20:58:21]

Done.

+      ..cleanUp();
+  }
+
   HInstruction callSetRuntimeTypeInfo(
       HInstruction typeInfo, HInstruction newObject) {
     // Set the runtime type information on the object.
     ir.Procedure typeInfoSetterFn = astAdapter.setRuntimeTypeInfo;
     // TODO(efortuna): Insert source information in this static invocation.
     _pushStaticInvocation(typeInfoSetterFn, <HInstruction>[newObject, typeInfo],
         commonMasks.dynamicType);
 
     // The new object will now be referenced through the
     // `setRuntimeTypeInfo` call. We therefore set the type of that
@@ skipping 1438 matching lines @@
   void _visitThrowExpression(ir.Expression expression) {
     bool old = _inExpressionOfThrow;
     try {
       _inExpressionOfThrow = true;
       expression.accept(this);
     } finally {
       _inExpressionOfThrow = old;
     }
   }
 
+  void visitYieldStatement(ir.YieldStatement yieldStatement) {
+    yieldStatement.expression.accept(this);
+    add(new HYield(pop(), yieldStatement.isYieldStar));
+  }
+
+  @override
+  void visitAwaitExpression(ir.AwaitExpression await) {
+    await.operand.accept(this);
+    HInstruction awaited = pop();
+    // TODO(herhut): Improve this type.
+    push(new HAwait(awaited, astAdapter.makeSubtypeOfObject(closedWorld)));
+  }
+
   @override
   void visitRethrow(ir.Rethrow rethrowNode) {
     HInstruction exception = rethrowableException;
     if (exception == null) {
       exception = graph.addConstantNull(closedWorld);
       compiler.reporter.internalError(astAdapter.getNode(rethrowNode),
           'rethrowableException should not be null.');
     }
     SourceInformation sourceInformation = null;
     closeAndGotoExit(new HThrow(exception, sourceInformation, isRethrow: true));
@@ skipping 49 matching lines @@
       tryCatch.body.accept(this);
       tryBuilder
         ..closeTryBody()
         ..buildCatch(tryCatch);
     } else {
       tryFinally.body.accept(this);
       tryBuilder.closeTryBody();
     }
 
     tryBuilder
       ..buildFinallyBlock(tryFinally)

[sra1, 2017/01/14 02:56:23]

..buildFinallyBlock(() { tryFinally.finalizer.accept(this); })

[Emily Fortuna, 2017/01/17 20:58:21]

Done.

       ..cleanUp();
   }
 }
 
 /// Class in charge of building try, catch and/or finally blocks. This handles
 /// the instructions that need to be output and the dominator calculation of
 /// this sequence of code.
 class TryCatchFinallyBuilder {
   HBasicBlock enterBlock;
   HBasicBlock startTryBlock;
@@ skipping 76 matching lines @@
 
     // 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(startCatchBlock);
     _addExitTrySuccessor(startFinallyBlock);
   }
 
   /// Build the finally{} clause of a try/{catch}/finally statement. Note this
   /// does not examine the body of the try clause, only the finally portion.
   void buildFinallyBlock(ir.TryFinally tryFinally) {

[sra1, 2017/01/14 02:56:23]

buildFinallyBlock(void buildFinalizer()) {

[Emily Fortuna, 2017/01/17 20:58:20]

Done.

     kernelBuilder.localsHandler = new LocalsHandler.from(originalSavedLocals);
     startFinallyBlock = kernelBuilder.graph.addNewBlock();
     kernelBuilder.open(startFinallyBlock);
     tryFinally.finalizer.accept(kernelBuilder);

[sra1, 2017/01/14 02:56:23]

buildFinalizer();

[Emily Fortuna, 2017/01/17 20:58:21]

Done.

     if (!kernelBuilder.isAborted()) {
       endFinallyBlock = kernelBuilder.close(new HGoto());
     }
     tryInstruction.finallyBlock = startFinallyBlock;
     finallyGraph =
         new SubGraph(startFinallyBlock, kernelBuilder.lastOpenedBlock);
   }
 
   void closeTryBody() {
     // We use a [HExitTry] instead of a [HGoto] for the try block
@@ skipping 104 matching lines @@
     kernelBuilder.open(exitBlock);
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
   }
 }
+
+/// Helper class to do the work of acting like a ir.TryFinally finalizer
+/// statement without actually having any source code. This is used for the
+/// buildAsyncForIn method but allows us to reuse code in
+/// TryCatchFinallyBuilder. Sure would be nice if we could have nested classes.
+class _FakeStatement extends ir.Statement {

[sra1, 2017/01/14 02:56:23]

I'm not keen on this. See other comments

[Emily Fortuna, 2017/01/17 20:58:20]

Done.

+  Function finalizerFunc;
+  _FakeStatement(this.finalizerFunc);
+
+  accept(ir.StatementVisitor not_used) => finalizerFunc();
+
+  visitChildren(ir.Visitor v) {}
+  transformChildren(ir.Transformer v) {}
+}