Await it!

runtime/vm/parser.cc

 // 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.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 5408 matching lines @@
                                   current_block_->scope->function_level() + 1,
                                   0);
   }
   ChainNewBlock(outer_scope);
 }
 
 
 void Parser::OpenAsyncClosure() {
   TRACE_PARSER("OpenAsyncClosure");
   parsed_function()->set_await_temps_scope(current_block_->scope);
-  // TODO(mlippautz): Set up explicit jump table for await continuations.
+  current_block_->scope->LookupVariable(Symbols::Completer(), false);

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

Could you add a comment why the variable is looked up? I presume it's to mark it
captured as a side effect of the lookup.

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

Yes, it's about capturing it. Moved into CloseAsyncClosure() and added a
comment.

 }
 
 
 RawFunction* Parser::OpenAsyncFunction(intptr_t formal_param_pos) {
   TRACE_PARSER("OpenAsyncFunction");
   // Create the closure containing the old body of this function.
   Class& sig_cls = Class::ZoneHandle(I);
   Type& sig_type = Type::ZoneHandle(I);
   Function& closure = Function::ZoneHandle(I);
   String& sig = String::ZoneHandle(I);
@@ skipping 76 matching lines @@
   const Class& completer = Class::ZoneHandle(I,
       GetClassForAsync(Symbols::Completer()));
   ASSERT(!completer.IsNull());
   const Function& completer_constructor = Function::ZoneHandle(I,
       completer.LookupFunction(Symbols::CompleterConstructor()));
   ASSERT(!completer_constructor.IsNull());
 
   // Add to AST:
   //   var :async_op;
   //   var :async_completer;
+  //   var :await_jump_var;
+  //   var :await_ctx_var;
   LocalVariable* async_op_var = new (I) LocalVariable(
       Scanner::kNoSourcePos,
       Symbols::AsyncOperation(),
       Type::ZoneHandle(I, Type::DynamicType()));
   current_block_->scope->AddVariable(async_op_var);
   found = closure_body->scope()->CaptureVariable(Symbols::AsyncOperation());
   ASSERT(found);
   LocalVariable* async_completer = new (I) LocalVariable(
       Scanner::kNoSourcePos,
       Symbols::AsyncCompleter(),
       Type::ZoneHandle(I, Type::DynamicType()));
   current_block_->scope->AddVariable(async_completer);
   found = closure_body->scope()->CaptureVariable(Symbols::AsyncCompleter());
   ASSERT(found);
+  LocalVariable* await_jump_var = new (I) LocalVariable(
+      Scanner::kNoSourcePos,
+      Symbols::AwaitJumpVar(),
+      Type::ZoneHandle(I, Type::DynamicType()));
+  current_block_->scope->AddVariable(await_jump_var);
+  found = closure_body->scope()->CaptureVariable(Symbols::AwaitJumpVar());
+  ASSERT(found);
+  LocalVariable* await_ctx_var = new (I) LocalVariable(
+      Scanner::kNoSourcePos,
+      Symbols::AwaitContextVar(),
+      Type::ZoneHandle(I, Type::DynamicType()));
+  current_block_->scope->AddVariable(await_ctx_var);
+  found = closure_body->scope()->CaptureVariable(Symbols::AwaitContextVar());
+  ASSERT(found);
+
+  // Add to AST:
+  //   :await_jump_var = null;
+  //   :await_ctx_var = null;
+  AstNode* null_literal = new(I) LiteralNode(

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

You should not need to initialize these to null explicitly. The runtime will do
this automatically for all locals (and context variables).

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

Done.

+      Scanner::kNoSourcePos, Object::null_instance());
+  current_block_->statements->Add(new(I) StoreLocalNode(
+      Scanner::kNoSourcePos, await_jump_var, null_literal));
+  current_block_->statements->Add(new(I) StoreLocalNode(
+      Scanner::kNoSourcePos, await_ctx_var, null_literal));
 
   // Add to AST:
   //   :async_completer = new Completer();
-  ArgumentListNode* empty_args = new (I) ArgumentListNode(
-      Scanner::kNoSourcePos);
+  ArgumentListNode* empty_args = new(I) ArgumentListNode(Scanner::kNoSourcePos);

[srdjan, 2014/08/20 17:50:06]

The prevalent type is new (I) (with space), please adapt code.

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

Done. I have seen "new(I)" and "new (I)" all around our codebase. Will write new
code with "new (I)".

   ConstructorCallNode* completer_constructor_node = new (I) ConstructorCallNode(
       Scanner::kNoSourcePos,
       TypeArguments::ZoneHandle(I),
       completer_constructor,
       empty_args);
   StoreLocalNode* store_completer = new (I) StoreLocalNode(
       Scanner::kNoSourcePos,
       async_completer,
       completer_constructor_node);
   current_block_->statements->Add(store_completer);
@@ skipping 30 matching lines @@
           Symbols::CompleterFuture()));
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::CloseAsyncClosure(SequenceNode* body) {
   TRACE_PARSER("CloseAsyncClosure");
   // We need a temporary expression to store intermediate return values.
   parsed_function()->EnsureExpressionTemp();
+  body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);

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

A comment would be nice explaining why you are looking up the variables.

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

Added a comment in the source.

Currently, all variables from all scopes are captured anyways. This lookup
ensures that if we do something smarter later on we will still have the
necessary internal variables available.

+  body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
+  body->scope()->RecursivelyCaptureAllVariables();
 }
 
 
 // Set up default values for all optional parameters to the function.
 void Parser::SetupDefaultsForOptionalParams(const ParamList* params,
                                             Array* default_values) {
   if (params->num_optional_parameters > 0) {
     // Build array of default parameter values.
     ParamDesc* param =
       params->parameters->data() + params->num_fixed_parameters;
@@ skipping 5653 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart