[esnext] prototype runtime implementation for async functions

src/parsing/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/parsing/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 1092 matching lines @@
 
       scope->set_start_position(shared_info->start_position());
       ExpressionClassifier formals_classifier(this);
       ParserFormalParameters formals(scope);
       Checkpoint checkpoint(this);
       {
         // Parsing patterns as variable reference expression creates
         // NewUnresolved references in current scope. Entrer arrow function
         // scope for formal parameter parsing.
         BlockState block_state(&scope_, scope);
+        function_state.set_parse_phase(FunctionParsePhase::FormalParameters);
         if (Check(Token::LPAREN)) {
           // '(' StrictFormalParameters ')'
           ParseFormalParameterList(&formals, &formals_classifier, &ok);
           if (ok) ok = Check(Token::RPAREN);
         } else {
           // BindingIdentifier
           ParseFormalParameter(&formals, &formals_classifier, &ok);
           if (ok) {
             DeclareFormalParameter(formals.scope, formals.at(0),
                                    &formals_classifier);
           }
         }
       }
 
       if (ok) {
+        function_state.set_parse_phase(FunctionParsePhase::FunctionBody);
         checkpoint.Restore(&formals.materialized_literals_count);
         // Pass `accept_IN=true` to ParseArrowFunctionLiteral --- This should
         // not be observable, or else the preparser would have failed.
         Expression* expression = ParseArrowFunctionLiteral(
             true, formals, is_async, formals_classifier, &ok);
         if (ok) {
           // Scanning must end at the same position that was recorded
           // previously. If not, parsing has been interrupted due to a stack
           // overflow, at which point the partially parsed arrow function
           // concise body happens to be a valid expression. This is a problem
@@ skipping 1575 matching lines @@
         // ES6 14.6.1 Static Semantics: IsInTailPosition
         Scanner::Location loc(pos, pos + 1);
         function_state_->AddExpressionInTailPosition(return_value, loc);
       }
     }
   }
   ExpectSemicolon(CHECK_OK);
 
   if (is_generator()) {
     return_value = BuildIteratorResult(return_value, true);
+  } else if (is_async_function()) {
+    return_value = EmitPromiseResolve(return_value, return_value->position());

[neis, 2016/05/11 09:45:16]

Can you call these functions Build* rather than Emit*?

   }
 
   result = factory()->NewReturnStatement(return_value, loc.beg_pos);
 
   Scope* decl_scope = scope_->DeclarationScope();
   if (decl_scope->is_script_scope() || decl_scope->is_eval_scope()) {
     ReportMessageAt(loc, MessageTemplate::kIllegalReturn);
     *ok = false;
     return NULL;
   }
@@ skipping 1220 matching lines @@
     expr = assignment->target();
 
     // TODO(adamk): Only call this if necessary.
     RewriteParameterInitializerScope(parser_->stack_limit(), initializer,
                                      parser_->scope_, parameters->scope);
   }
 
   AddFormalParameter(parameters, expr, initializer, end_pos, is_rest);
 }
 
+void ParserTraits::ParseAsyncArrowSingleExpressionBody(
+    ZoneList<Statement*>* body, bool accept_IN,
+    Type::ExpressionClassifier* classifier, int pos, bool* ok) {
+  parser_->DesugarAsyncFunctionBody(
+      parser_->ast_value_factory()->empty_string(), parser_->scope_, body,
+      classifier, kAsyncArrowFunction, FunctionBody::ArrowConcise, accept_IN,
+      pos, ok);
+}
+
+void Parser::DesugarAsyncFunctionBody(const AstRawString* function_name,
+                                      Scope* scope, ZoneList<Statement*>* body,
+                                      ExpressionClassifier* classifier,
+                                      FunctionKind kind, FunctionBody body_type,
+                                      bool accept_IN, int pos, bool* ok) {

[neis, 2016/05/11 09:45:16]

Please add a comment here on what the desugaring is doing, eg in the form of JS
pseudo code.

[caitp (gmail), 2016/05/11 13:42:23]

Done.

+  scope->ForceContextAllocation();
+  // Calling a generator returns a generator object.  That object is
+  // stored

[neis, 2016/05/11 09:45:16]

format (but not sure it's worth to duplicate this comment here)

[caitp (gmail), 2016/05/11 13:42:23]

Removed it

+  // in a temporary variable, a definition that is used by "yield"
+  // expressions. This also marks the FunctionState as a generator.
+  Variable* temp =
+      scope_->NewTemporary(ast_value_factory()->dot_generator_object_string());
+  function_state_->set_generator_object_variable(temp);
+
+  // Create generator, but do not yield.
+  Expression* allocation = EmitCreateJSGeneratorObject(pos);
+  Expression* assign_yield =

[neis, 2016/05/11 09:45:16]

assign_yield is a very misleading name.

[caitp (gmail), 2016/05/11 13:42:23]

Renamed to `init_generator_variable`

+      factory()->NewAssignment(Token::INIT, factory()->NewVariableProxy(temp),
+                               allocation, RelocInfo::kNoPosition);
+
+  body->Add(
+      factory()->NewExpressionStatement(assign_yield, RelocInfo::kNoPosition),
+      zone());
+

[neis, 2016/05/11 09:45:16]

I would rewrite this as follows:

// Create generator, but do not yield.
{
  Variable* temp =
      scope_->NewTemporary(ast_value_factory()->dot_generator_object_string());
  function_state_->set_generator_object_variable(temp);

  Expression* assignment = factory()->NewAssignment(
      Token::INIT, factory()->NewVariableProxy(temp),
      EmitCreateJSGeneratorObject(pos), RelocInfo::kNoPosition);
  body->Add(
      factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition),
      zone());
}

+  Block* try_block = factory()->NewBlock(NULL, 8, true, RelocInfo::kNoPosition);
+
+  ZoneList<Statement*>* inner_body = try_block->statements();
+
+  Expression* return_value = nullptr;
+  if (body_type == FunctionBody::Normal) {
+    ParseStatementList(inner_body, Token::RBRACE, ok);
+    if (!*ok) return;
+    return_value = factory()->NewUndefinedLiteral(RelocInfo::kNoPosition);
+  } else {
+    return_value = ParseAssignmentExpression(accept_IN, classifier, ok);
+    if (!*ok) return;
+    ParserTraits::RewriteNonPattern(classifier, ok);
+    if (!*ok) return;
+  }
+
+  return_value = EmitPromiseResolve(return_value, return_value->position());
+  inner_body->Add(
+      factory()->NewReturnStatement(return_value, return_value->position()),
+      zone());
+
+  Block* catch_block = BuildRejectPromiseOnException(try_block);

[neis, 2016/05/11 09:45:17]

Calling this catch_block is confusing, as it's the whole try-catch statement. I
would just inline it.

+
+  body->Add(catch_block, zone());
+
+  scope->set_end_position(scanner()->location().end_pos);
+}
 
 DoExpression* Parser::ParseDoExpression(bool* ok) {
   // AssignmentExpression ::
   //     do '{' StatementList '}'
   int pos = peek_position();
 
   Expect(Token::DO, CHECK_OK);
   Variable* result =
       scope_->NewTemporary(ast_value_factory()->dot_result_string());
   Block* block = ParseBlock(nullptr, false, CHECK_OK);
@@ skipping 116 matching lines @@
       // expressions. This also marks the FunctionState as a generator.
       Variable* temp = scope_->NewTemporary(
           ast_value_factory()->dot_generator_object_string());
       function_state.set_generator_object_variable(temp);
     }
 
     Expect(Token::LPAREN, CHECK_OK);
     int start_position = scanner()->location().beg_pos;
     scope_->set_start_position(start_position);
     ParserFormalParameters formals(scope);
+    function_state.set_parse_phase(FunctionParsePhase::FormalParameters);
     ParseFormalParameterList(&formals, &formals_classifier, CHECK_OK);
     arity = formals.Arity();
     Expect(Token::RPAREN, CHECK_OK);
     int formals_end_position = scanner()->location().end_pos;
 
     CheckArityRestrictions(arity, kind, formals.has_rest, start_position,
                            formals_end_position, CHECK_OK);
     Expect(Token::LBRACE, CHECK_OK);
-
+    function_state.set_parse_phase(FunctionParsePhase::FunctionBody);
     // Don't include the rest parameter into the function's formal parameter
     // count (esp. the SharedFunctionInfo::internal_formal_parameter_count,
     // which says whether we need to create an arguments adaptor frame).
     if (formals.has_rest) arity--;
 
     // Determine if the function can be parsed lazily. Lazy parsing is different
     // from lazy compilation; we need to parse more eagerly than we compile.
 
     // We can only parse lazily if we also compile lazily. The heuristics for
     // lazy compilation are:
@@ skipping 383 matching lines @@
       param_scope = param_scope->FinalizeBlockScope();
       if (param_scope != nullptr) {
         CheckConflictingVarDeclarations(param_scope, CHECK_OK);
       }
       init_block->statements()->Add(param_block, zone());
     }
   }
   return init_block;
 }
 
+Block* Parser::BuildRejectPromiseOnException(Block* block) {
+  // try { <block> } catch (error) { return Promise.reject(error); }
+  Block* try_block = block;
+  Scope* catch_scope = NewScope(scope_, CATCH_SCOPE);
+  catch_scope->set_is_hidden();
+  Variable* catch_variable =
+      catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(), VAR,
+                                kCreatedInitialized, Variable::NORMAL);
+  Block* catch_block =
+      factory()->NewBlock(nullptr, 1, true, RelocInfo::kNoPosition);
+
+  Expression* promise_reject = EmitPromiseReject(
+      factory()->NewVariableProxy(catch_variable), RelocInfo::kNoPosition);
+
+  ReturnStatement* return_promise_reject =
+      factory()->NewReturnStatement(promise_reject, RelocInfo::kNoPosition);
+  catch_block->statements()->Add(return_promise_reject, zone());
+  TryStatement* try_catch_statement =
+      factory()->NewTryCatchStatement(try_block, catch_scope, catch_variable,
+                                      catch_block, RelocInfo::kNoPosition);
+
+  block = factory()->NewBlock(nullptr, 1, true, RelocInfo::kNoPosition);
+  block->statements()->Add(try_catch_statement, zone());
+  return block;
+}
+
+Expression* Parser::EmitCreateJSGeneratorObject(int pos) {
+  DCHECK_NOT_NULL(function_state_->generator_object_variable());
+  ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
+  args->Add(factory()->NewThisFunction(pos), zone());
+  args->Add(ThisExpression(scope_, factory(), RelocInfo::kNoPosition), zone());
+  return factory()->NewCallRuntime(Runtime::kCreateJSGeneratorObject, args,
+                                   pos);
+}
+
+Expression* Parser::EmitPromiseResolve(Expression* value, int pos) {
+  ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(1, zone());
+  args->Add(value, zone());
+  return factory()->NewCallRuntime(Context::PROMISE_CREATE_RESOLVED_INDEX, args,
+                                   pos);
+}
+
+Expression* Parser::EmitPromiseReject(Expression* value, int pos) {
+  ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(1, zone());
+  args->Add(value, zone());
+  return factory()->NewCallRuntime(Context::PROMISE_CREATE_REJECTED_INDEX, args,
+                                   pos);
+}
 
 ZoneList<Statement*>* Parser::ParseEagerFunctionBody(
     const AstRawString* function_name, int pos,
     const ParserFormalParameters& parameters, FunctionKind kind,
     FunctionLiteral::FunctionType function_type, bool* ok) {
   // Everything inside an eagerly parsed function will be parsed eagerly
   // (see comment above).
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
   ZoneList<Statement*>* result = new(zone()) ZoneList<Statement*>(8, zone());
 
@@ skipping 33 matching lines @@
       // - InitialYield yields the actual generator object.
       // - Any return statement inside the body will have its argument wrapped
       //   in a "done" iterator result object.
       // - If the generator terminates for whatever reason, we must close it.
       //   Hence the finally clause.
 
       Block* try_block =
           factory()->NewBlock(nullptr, 3, false, RelocInfo::kNoPosition);
 
       {
-        ZoneList<Expression*>* arguments =
-            new (zone()) ZoneList<Expression*>(2, zone());
-        arguments->Add(factory()->NewThisFunction(pos), zone());
-        arguments->Add(
-            ThisExpression(scope_, factory(), RelocInfo::kNoPosition), zone());
-        CallRuntime* allocation = factory()->NewCallRuntime(
-            Runtime::kCreateJSGeneratorObject, arguments, pos);
-
+        Expression* allocation = EmitCreateJSGeneratorObject(pos);
         VariableProxy* init_proxy = factory()->NewVariableProxy(
             function_state_->generator_object_variable());
         Assignment* assignment = factory()->NewAssignment(
             Token::INIT, init_proxy, allocation, RelocInfo::kNoPosition);
         VariableProxy* get_proxy = factory()->NewVariableProxy(
             function_state_->generator_object_variable());
         Yield* yield =
             factory()->NewYield(get_proxy, assignment, RelocInfo::kNoPosition);
         try_block->statements()->Add(
             factory()->NewExpressionStatement(yield, RelocInfo::kNoPosition),
@@ skipping 15 matching lines @@
       args->Add(call_proxy, zone());
       Expression* call = factory()->NewCallRuntime(
           Runtime::kGeneratorClose, args, RelocInfo::kNoPosition);
       finally_block->statements()->Add(
           factory()->NewExpressionStatement(call, RelocInfo::kNoPosition),
           zone());
 
       body->Add(factory()->NewTryFinallyStatement(try_block, finally_block,
                                                   RelocInfo::kNoPosition),
                 zone());
+    } else if (IsAsyncFunction(kind)) {
+      const bool accept_IN = true;
+      DesugarAsyncFunctionBody(function_name, inner_scope, body, nullptr, kind,
+                               FunctionBody::Normal, accept_IN, pos, CHECK_OK);
     } else {
       ParseStatementList(body, Token::RBRACE, CHECK_OK);
     }
 
     if (IsSubclassConstructor(kind)) {
       body->Add(
           factory()->NewReturnStatement(
               this->ThisExpression(scope_, factory(), RelocInfo::kNoPosition),
               RelocInfo::kNoPosition),
               zone());
     }
   }
 
   Expect(Token::RBRACE, CHECK_OK);
   scope_->set_end_position(scanner()->location().end_pos);
 
   if (!parameters.is_simple) {
     DCHECK_NOT_NULL(inner_scope);
     DCHECK_EQ(body, inner_block->statements());
     SetLanguageMode(scope_, inner_scope->language_mode());
     Block* init_block = BuildParameterInitializationBlock(parameters, CHECK_OK);
+
+    if (IsAsyncFunction(kind)) {
+      init_block = BuildRejectPromiseOnException(init_block);
+    }
+
     DCHECK_NOT_NULL(init_block);
 
     inner_scope->set_end_position(scanner()->location().end_pos);
     inner_scope = inner_scope->FinalizeBlockScope();
     if (inner_scope != nullptr) {
       CheckConflictingVarDeclarations(inner_scope, CHECK_OK);
       InsertShadowingVarBindingInitializers(inner_block);
     }
 
     result->Add(init_block, zone());
@@ skipping 784 matching lines @@
                                                       Expression* right,
                                                       int pos) {
   return parser_->RewriteAssignExponentiation(left, right, pos);
 }
 
 void ParserTraits::RewriteNonPattern(Type::ExpressionClassifier* classifier,
                                      bool* ok) {
   parser_->RewriteNonPattern(classifier, ok);
 }
 
 Expression* ParserTraits::RewriteAwaitExpression(Expression* value, int pos) {

[neis, 2016/05/11 09:45:17]

Also add a comment here please.

-  // TODO(caitp): Implement AsyncFunctionAwait()
-  // per tc39.github.io/ecmascript-asyncawait/#abstract-ops-async-function-await
-  return value;
+  Variable* generator_object_variable =
+      parser_->function_state_->generator_object_variable();
+
+  DCHECK_NOT_NULL(generator_object_variable);
+
+  Expression* generator_object =
+      parser_->factory()->NewVariableProxy(generator_object_variable);
+
+  ZoneList<Expression*>* async_function_await_args =
+      new (zone()) ZoneList<Expression*>(2, zone());
+  async_function_await_args->Add(generator_object, zone());
+  async_function_await_args->Add(value, zone());
+  Expression* async_function_await = parser_->factory()->NewCallRuntime(
+      Context::ASYNC_FUNCTION_AWAIT_INDEX, async_function_await_args,
+      RelocInfo::kNoPosition);
+
+  generator_object =
+      parser_->factory()->NewVariableProxy(generator_object_variable);
+  return parser_->factory()->NewYield(generator_object, async_function_await,
+                                      pos);
 }
 
 Zone* ParserTraits::zone() const {
   return parser_->function_state_->scope()->zone();
 }
 
 
 ZoneList<Expression*>* ParserTraits::GetNonPatternList() const {
   return parser_->function_state_->non_patterns_to_rewrite();
 }
@@ skipping 1473 matching lines @@
                         try_block, target);
     final_loop = target;
   }
 
   return final_loop;
 }
 
 
 }  // namespace internal
 }  // namespace v8