Introduce await

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"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
@@ skipping 2945 matching lines @@
   }
   ASSERT((CurrentToken() == Token::kLPAREN) ||
          func.IsGetterFunction() ||
          func.is_async_closure());
   const bool allow_explicit_default_values = true;
   if (func.IsGetterFunction()) {
     // Populate function scope with the formal parameters. Since in this case
     // we are compiling a getter this will at most populate the receiver.
     AddFormalParamsToScope(&params, current_block_->scope);
   } else if (func.is_async_closure()) {
+    // Async closures have one optional parameter for continuation results.
+    ParamDesc result_param;
+    result_param.name = &Symbols::AsyncOperationParam();
+    result_param.default_value = &Object::null_instance();
+    result_param.type = &Type::ZoneHandle(I, Type::DynamicType());
+    params.parameters->Add(result_param);
+    params.num_optional_parameters++;

[hausner, 2014/08/07 21:48:43]

Why is this parameter optional? The caller will always pass a parameter, even if
it's null.

[Michael Lippautz (Google), 2014/08/08 18:12:18]

Maybe I am missing something, but the first time we invoke :async_op we do not
have a parameter.

  foo() async {
    ...
    var c = new Completer();
    var :async_op = (:result_param = null) {
      ...
    }
    new Future(:async_op); // HERE
    return c.future;
  }

The future constructor expects a computation without parameter.

+    params.has_optional_positional_parameters = true;
+    SetupDefaultsForOptionalParams(&params, default_parameter_values);
     AddFormalParamsToScope(&params, current_block_->scope);
     ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
     ASSERT(func.NumParameters() == params.parameters->length());
     if (!Function::Handle(func.parent_function()).IsGetterFunction()) {
       // Parse away any formal parameters, as they are accessed as as context
       // variables.
       ParseFormalParameterList(allow_explicit_default_values, false, &params);
     }
   } else {
     ParseFormalParameterList(allow_explicit_default_values, false, &params);
@@ skipping 36 matching lines @@
   }
 
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
   func.set_modifier(func_modifier);
 
   OpenBlock();  // Open a nested scope for the outermost function block.
 
   Function& async_closure = Function::ZoneHandle(I);
   if (func.IsAsyncFunction() && !func.is_async_closure()) {
     async_closure = OpenAsyncFunction(formal_params_pos);
+  } else if (func.is_async_closure()) {
+    OpenAsyncClosure();
   }
 
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     if (String::Handle(I, func.name()).Equals(
         Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(I, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
@@ skipping 2461 matching lines @@
     // We are parsing a nested function while compiling the enclosing function.
     outer_scope =
         new(I) LocalScope(current_block_->scope,
                                   current_block_->scope->function_level() + 1,
                                   0);
   }
   ChainNewBlock(outer_scope);
 }
 
 
+void Parser::OpenAsyncClosure() {
+  parsed_function()->set_await_temps_scope(current_block_->scope);
+  // TODO(mlippautz): Set up explicit jump table for await continuations.
+}
+
+
 RawFunction* Parser::OpenAsyncFunction(intptr_t formal_param_pos) {
   // 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);
   ParamList closure_params;
   closure_params.AddFinalParameter(
       formal_param_pos,
       &Symbols::ClosureParameter(),
       &Type::ZoneHandle(I, Type::DynamicType()));
+  ParamDesc result_param;
+  result_param.name = &Symbols::AsyncOperationParam();
+  result_param.default_value = &Object::null_instance();
+  result_param.type = &Type::ZoneHandle(I, Type::DynamicType());
+  closure_params.parameters->Add(result_param);
+  closure_params.has_optional_positional_parameters = true;
+  closure_params.num_optional_parameters++;
   closure = Function::NewClosureFunction(
       Symbols::AnonymousClosure(),
       innermost_function(),
       formal_param_pos);
   AddFormalParamsToFunction(&closure_params, closure);
   closure.set_is_async_closure(true);
+  closure.set_is_inlinable(false);
   closure.set_result_type(AbstractType::Handle(Type::DynamicType()));
   sig = closure.Signature();
   sig_cls = library_.LookupLocalClass(sig);
   if (sig_cls.IsNull()) {
     sig_cls = Class::NewSignatureClass(sig, closure, script_, formal_param_pos);
     library_.AddClass(sig_cls);
   }
   closure.set_signature_class(sig_cls);
   sig_type = sig_cls.SignatureType();
   if (!sig_type.IsFinalized()) {
@@ skipping 346 matching lines @@
   const intptr_t ident_pos = TokenPos();
   const String& ident = *CurrentLiteral();
   LocalVariable* variable = new(I) LocalVariable(
       ident_pos, ident, type);
   ConsumeToken();  // Variable identifier.
   AstNode* initialization = NULL;
   if (CurrentToken() == Token::kASSIGN) {
     // Variable initialization.
     const intptr_t assign_pos = TokenPos();
     ConsumeToken();
-    AstNode* expr = ParseExpr(is_const, kConsumeCascades);
+    AstNode* expr = ParseAwaitableExpr(is_const, kConsumeCascades);
     initialization = new(I) StoreLocalNode(
         assign_pos, variable, expr);
     if (is_const) {
       ASSERT(expr->IsLiteralNode());
       variable->SetConstValue(expr->AsLiteralNode()->literal());
     }
   } else if (is_final || is_const) {
     ReportError(ident_pos,
                 "missing initialization of 'final' or 'const' variable");
   } else {
@@ skipping 1856 matching lines @@
         scope->LocalLookupVariable(Symbols::ExceptionVar());
     ASSERT(excp_var != NULL);
     LocalVariable* trace_var =
         scope->LocalLookupVariable(Symbols::StackTraceVar());
     ASSERT(trace_var != NULL);
     statement = new(I) ThrowNode(
         statement_pos,
         new(I) LoadLocalNode(statement_pos, excp_var),
         new(I) LoadLocalNode(statement_pos, trace_var));
   } else {
-    statement = ParseExpr(kAllowConst, kConsumeCascades);
+    statement = ParseAwaitableExpr(kAllowConst, kConsumeCascades);
     ExpectSemicolon();
   }
   return statement;
 }
 
 
 void Parser::ReportError(const Error& error) {
   Report::LongJump(error);
   UNREACHABLE();
 }
@@ skipping 635 matching lines @@
       ASSERT(field.value() != Object::sentinel().raw());
       ASSERT(field.value() != Object::transition_sentinel().raw());
       return new(iso) LiteralNode(expr->token_pos(),
                              Instance::ZoneHandle(iso, field.value()));
     }
   }
   return expr;
 }
 
 
+AstNode* Parser::ParseAwaitableExpr(bool require_compiletime_const,

[hausner, 2014/08/07 21:48:43]

As discussed offline, I believe all expressions are "awaitable". So this code
may belong in ParseExpr.

[Michael Lippautz (Google), 2014/08/08 18:12:18]

Again discussed offline :)

Example:

  var x = ((await foo()) + (await bar()))

ParseExpr is called 3 (?) times for the right hand side, i.e., for (await
foo()), (await bar()), and the binary op. We need to transform this expression
as a whole though.

If we would transform the subexpressions, we would end up with something alike:

  // preamble for await foo()
  t_1 = foo();
  <continuation code>
  // preamble for await bar()
  t_1 = bar();
  <continuation code>
  // We did overwrite t_1 already, so we cannot continue?
  t2 = ?
  
The idea is to keep ParseAwaitableExpr() and insert it at the appropriate
positions on statement level.

+                                    bool consume_cascades) {
+  TRACE_PARSER("ParseAwaitableExpr");
+  parsed_function()->reset_seen_await();
+  AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
+  if (parsed_function()->seen_await()) {
+    if (!current_block_->scope->LookupVariable(
+            Symbols::AsyncOperation(), true)) {
+      // Async operations are always encapsulated into a local function. We only
+      // need to transform the expression when generating code for this inner
+      // function.
+      return expr;
+    }
+    SequenceNode* intermediates_block = new (I) SequenceNode(
+        Scanner::kNoSourcePos, current_block_->scope);
+    AwaitTransformer at(intermediates_block, library_, parsed_function());
+    at.Transform(expr);
+    current_block_->statements->Add(intermediates_block);
+    parsed_function()->reset_seen_await();
+    return at.Result();
+  }
+  return expr;
+}
+
+
+AstNode* Parser::ParseAwaitExpr() {

[hausner, 2014/08/07 21:48:43]

Could maybe inline this code in ParsePrimary.

[Michael Lippautz (Google), 2014/08/08 18:12:18]

Done.

+  TRACE_PARSER("ParseAwaitExpr");
+  ConsumeToken();
+  parsed_function()->record_await();
+  return new (I) AwaitNode(
+      TokenPos(), ParseExpr(kAllowConst, kConsumeCascades));
+}
+
+
 AstNode* Parser::ParseExpr(bool require_compiletime_const,
                            bool consume_cascades) {
   TRACE_PARSER("ParseExpr");
   String* expr_ident =
       Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
   const intptr_t expr_pos = TokenPos();
 
   if (CurrentToken() == Token::kTHROW) {
     ConsumeToken();
     if (CurrentToken() == Token::kSEMICOLON) {
@@ skipping 2348 matching lines @@
   TRACE_PARSER("ParsePrimary");
   ASSERT(!is_top_level_);
   AstNode* primary = NULL;
   const Token::Kind token = CurrentToken();
   if (IsFunctionLiteral()) {
     // The name of a literal function is visible from inside the function, but
     // must not collide with names in the scope declaring the literal.
     OpenBlock();
     primary = ParseFunctionStatement(true);
     CloseBlock();
+  } else if (IsLiteral("await")) {
+    primary = ParseAwaitExpr();
   } else if (IsIdentifier()) {
     intptr_t qual_ident_pos = TokenPos();
     const LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(I, ParsePrefix());
     String& ident = *CurrentLiteral();
     ConsumeToken();
     if (prefix.IsNull()) {
       if (!ResolveIdentInLocalScope(qual_ident_pos, ident, &primary)) {
         // Check whether the identifier is a type parameter.
         if (!current_class().IsNull()) {
           TypeParameter& type_param = TypeParameter::ZoneHandle(I,
@@ skipping 520 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart