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 2962 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++;
+    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);
+      ParamList parse_away;
+      ParseFormalParameterList(allow_explicit_default_values,
+                               false,
+                               &parse_away);
     }
   } else {
     ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
     // The number of parameters and their type are not yet set in local
     // functions, since they are not 'top-level' parsed.
     if (func.IsLocalFunction()) {
       AddFormalParamsToFunction(&params, func);
     }
     SetupDefaultsForOptionalParams(&params, default_parameter_values);
@@ skipping 29 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 2462 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() {
+  TRACE_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) {
+  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);
   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_result_type(AbstractType::Handle(Type::DynamicType()));
   sig = closure.Signature();
   sig_cls = library_.LookupLocalClass(sig);
   if (sig_cls.IsNull()) {
@@ skipping 23 matching lines @@
     current_block_->scope->set_begin_token_pos(statements->token_pos());
     current_block_->scope->set_end_token_pos(TokenPos());
   }
   current_block_ = current_block_->parent;
   return statements;
 }
 
 
 SequenceNode* Parser::CloseAsyncFunction(const Function& closure,
                                          SequenceNode* closure_body) {
+  TRACE_PARSER("CloseAsyncFunction");
   ASSERT(!closure.IsNull());
   ASSERT(closure_body != NULL);
   // The block for the async closure body has already been closed. Close the
   // corresponding function block.
   CloseBlock();
 
   // Create and return a new future that executes a closure with the current
   // body.
 
   bool found = false;
@@ skipping 76 matching lines @@
           new (I) LoadLocalNode(
               Scanner::kNoSourcePos,
               async_completer),
           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();
 }
 
 
 // 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.
@@ skipping 182 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 1852 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,
+                                    bool consume_cascades) {
+  TRACE_PARSER("ParseAwaitableExpr");
+  parsed_function()->reset_have_seen_await();
+  AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
+  if (parsed_function()->have_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());
+    AstNode* result = at.Transform(expr);
+    current_block_->statements->Add(intermediates_block);
+    parsed_function()->reset_have_seen_await();
+    return result;
+  }
+  return expr;
+}
+
+
 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") &&
+             (parsed_function()->function().IsAsyncFunction() ||
+              parsed_function()->function().is_async_closure())) {
+    // The body of an async function is parsed multiple times. The first time
+    // when setting up an AsyncFunction() for generating relevant scope
+    // information. The second time the body is parsed for actually generating
+    // code.
+    TRACE_PARSER("ParseAwaitExpr");
+    ConsumeToken();
+    parsed_function()->record_await();
+    primary = new(I) AwaitNode(
+        TokenPos(), ParseExpr(kAllowConst, kConsumeCascades));
   } 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