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 {
 
 // Quick access to the locally defined isolate() method.
 #define I (isolate())
 
 // Nodes that are unreachable from already parsed expressions.
 #define FOR_EACH_UNREACHABLE_NODE(V)                                           \
+  V(AwaitMarker)                                                               \
   V(Case)                                                                      \
   V(CatchClause)                                                               \
   V(CloneContext)                                                              \
   V(ClosureCall)                                                               \
   V(DoWhile)                                                                   \
   V(If)                                                                        \
   V(InitStaticField)                                                           \
   V(InlinedFinally)                                                            \
   V(For)                                                                       \
   V(Jump)                                                                      \
@@ skipping 52 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::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;  // (return_type() == kContinuation)
   //   }
+  //   AwaitMarker(kTargetForContinuation);  // Join happens here.
+  //   :saved_try_ctx_var = :await_saved_try_ctx_var_y;
   //   :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 =
+      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_return_type(ReturnNode::kContinuation);
+  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());
+  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) ComparisonNode(
+          Scanner::kNoSourcePos,
+          Token::kIS,
+          load_result_param,
+          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));
+  // If this expression is part of a try block, also append the code for
+  // restoring the saved try context that lives on the stack.
+  if (parsed_function_->saved_try_ctx() != NULL) {
+    preamble_->Add(new (I) StoreLocalNode(
+        Scanner::kNoSourcePos,
+        parsed_function_->saved_try_ctx(),
+        new (I) LoadLocalNode(
+            Scanner::kNoSourcePos, parsed_function_->async_saved_try_ctx())));
+  }
 
   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