Await it!

runtime/vm/ast_transformer.cc

 // Copyright (c) 2014, 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.
 
 #include "vm/ast_transformer.h"
 
 #include "vm/parser.h"
 
 namespace dart {
 
@@ skipping 67 matching lines @@
 void AwaitTransformer::VisitLiteralNode(LiteralNode* node) {
   result_ = node;
 }
 
 
 void AwaitTransformer::VisitTypeNode(TypeNode* node) {
   result_ = new(I) TypeNode(node->token_pos(), node->type());
 }
 
 
+void AwaitTransformer::VisitAwaitMarkerNode(AwaitMarkerNode* node) {
+  // Await markers are generated by the transformer, but should never reach a
+  // transformer.

[hausner, 2014/08/20 19:47:48]

should never be visited by the transformer?

Why not list this node in the FOR_EACH_UNREACHABLE_NODE macro above?

[Michael Lippautz (Google), 2014/08/20 20:56:06]

Done.

+  UNREACHABLE();
+}
+
 
 void AwaitTransformer::VisitAwaitNode(AwaitNode* node) {
   // Await transformation:
   //
   //   :await_temp_var_X = <expr>;
   //   :result_param = :await_temp_var_X;
   //   if (:result_param is Future) {
-  //     // :result_param.then(:async_op);
+  //     AwaitMarker(kNewcontinuationState);
+  //     :result_param.then(:async_op);
+  //     return;  // (is_regular_return() == false)
   //   }
   //   :await_temp_var_(X+1) = :result_param;
 
   LocalVariable* async_op = preamble_->scope()->LookupVariable(
       Symbols::AsyncOperation(), false);
   ASSERT(async_op != NULL);
   LocalVariable* result_param = preamble_->scope()->LookupVariable(
       Symbols::AsyncOperationParam(), false);
   ASSERT(result_param != NULL);
 
   node->expr()->Visit(this);
-  preamble_->Add(new(I) StoreLocalNode(Scanner::kNoSourcePos,
-                                       result_param,
-                                       result_));
+  preamble_->Add(new(I) StoreLocalNode(
+      Scanner::kNoSourcePos, result_param, result_));
   LoadLocalNode* load_result_param = new(I) LoadLocalNode(
       Scanner::kNoSourcePos, result_param);
   SequenceNode* is_future_branch = new(I) SequenceNode(
       Scanner::kNoSourcePos, preamble_->scope());
+  AwaitMarkerNode* await_marker =

[hausner, 2014/08/20 19:47:48]

A comment would be helpful here, explaining what the AwaitMarker node is for.
Maybe it makes sense to describe the purpose of these nodes in ast.h rather than
here, might make more sense. These nodes are not straight-forward to understand
like an IfNode or StaticCall node.

[Michael Lippautz (Google), 2014/08/20 20:56:06]

Done in ast.h

+      new(I) AwaitMarkerNode(AwaitMarkerNode::kNewContinuationState);
+  await_marker->set_scope(preamble_->scope());
+  is_future_branch->Add(await_marker);
   ArgumentListNode* args = new(I) ArgumentListNode(Scanner::kNoSourcePos);
   args->Add(new(I) LoadLocalNode(Scanner::kNoSourcePos, async_op));
-  // TODO(mlippautz): Once continuations are supported, just call .then().
-  // is_future_branch->Add(new(I) InstanceCallNode(
-  // Scanner::kNoSourcePos, load_result_param, Symbols::FutureThen(), args));
-  //
-  // For now, throw an exception.
-  const String& exception = String::ZoneHandle(
-      I, String::New("awaitable futures not yet supported", Heap::kOld));
-  is_future_branch->Add(new(I) ThrowNode(
-      Scanner::kNoSourcePos,
-      new(I) LiteralNode(
-          Scanner::kNoSourcePos,
-          String::ZoneHandle(I, Symbols::New(exception))),
-      NULL));
+  is_future_branch->Add(new(I) InstanceCallNode(
+      Scanner::kNoSourcePos, load_result_param, Symbols::FutureThen(), args));
+  ReturnNode* continuation_return = new(I) ReturnNode(Scanner::kNoSourcePos);
+  continuation_return->set_is_regular_return(false);

[hausner, 2014/08/20 19:47:48]

It would be nice to have a more descriptive name than "is_regular_return". Is it
a yield? (That word will probably be used later on for streams, though.) Or is
it a suspend instead of return?

[Michael Lippautz (Google), 2014/08/20 20:56:06]

As discussed offline: ReturnNodes will get a type() and for now they can be
kRegular (user dart code) or kContinuation (continuation returns). 

We can extend this once we have yield.

+  is_future_branch->Add(continuation_return);
+
   const Class& cls = Class::ZoneHandle(
       I, library_.LookupClass(Symbols::Future()));
   const AbstractType& future_type = AbstractType::ZoneHandle(I,
       cls.RareType());
   ASSERT(!future_type.IsNull());
-  TypeNode* future_type_node = new(I) TypeNode(
-      Scanner::kNoSourcePos, future_type);
-  IfNode* is_future_if = new(I) IfNode(
+  preamble_->Add(new(I) IfNode(
       Scanner::kNoSourcePos,
       new(I) ComparisonNode(Scanner::kNoSourcePos,
                             Token::kIS,
                             load_result_param,
-                            future_type_node),
+                            new(I) TypeNode(Scanner::kNoSourcePos,
+                                            future_type)),
       is_future_branch,
-      NULL);
-  preamble_->Add(is_future_if);
-
-  // TODO(mlippautz): Join for await needs to happen here.
+      NULL));
+  preamble_->Add(new(I) AwaitMarkerNode(
+      AwaitMarkerNode::kTargetForContinuation));
 
   LocalVariable* result = AddToPreambleNewTempVar(new(I) LoadLocalNode(
       Scanner::kNoSourcePos, result_param));
   result_ = new(I) LoadLocalNode(Scanner::kNoSourcePos, result);
 }
 
 
 // Transforms boolean expressions into a sequence of evaluatons that only lazily
 // evaluate subexpressions.
 //
@@ skipping 342 matching lines @@
 void AwaitTransformer::VisitThrowNode(ThrowNode* node) {
   // TODO(mlippautz): Check if relevant.
   AstNode* new_exception = Transform(node->exception());
   AstNode* new_stacktrace = Transform(node->stacktrace());
   result_ = new(I) ThrowNode(node->token_pos(),
                              new_exception,
                              new_stacktrace);
 }
 
 }  // namespace dart