[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 2663 matching lines @@
           is_object_conditional, pos);
     }
 
     // ES6 14.6.1 Static Semantics: IsInTailPosition
     if (allow_tailcalls() && !is_sloppy(language_mode())) {
       function_state_->AddExpressionInTailPosition(return_value);
     }
   }
   ExpectSemicolon(CHECK_OK);
 
-  if (is_generator()) {
+  if (is_generator() || is_async_function()) {
     return_value = BuildIteratorResult(return_value, true);
   }
 
   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 1324 matching lines @@
   // Getter ::
   //   '(' ')' '{' FunctionBody '}'
   //
   // Setter ::
   //   '(' PropertySetParameterList ')' '{' FunctionBody '}'
 
   int pos = function_token_pos == RelocInfo::kNoPosition
       ? peek_position() : function_token_pos;
 
   bool is_generator = IsGeneratorFunction(kind);
+  bool is_async = IsAsyncFunction(kind);
 
   // Anonymous functions were passed either the empty symbol or a null
   // handle as the function name.  Remember if we were passed a non-empty
   // handle to decide whether to invoke function name inference.
   bool should_infer_name = function_name == NULL;
 
   // We want a non-null handle as the function name.
   if (should_infer_name) {
     function_name = ast_value_factory()->empty_string();
   }
@@ skipping 11 matching lines @@
   bool should_be_used_once_hint = false;
   bool has_duplicate_parameters;
   // Parse function.
   {
     AstNodeFactory function_factory(ast_value_factory());
     FunctionState function_state(&function_state_, &scope_, scope, kind,
                                  &function_factory);
     scope_->SetScopeName(function_name);
     ExpressionClassifier formals_classifier(this, &duplicate_finder);
 
-    if (is_generator) {
+    if (is_generator || is_async) {
       // For generators, allocating variables in contexts is currently a win
       // because it minimizes the work needed to suspend and resume an
       // activation.  The machine code produced for generators (by full-codegen)
       // relies on this forced context allocation, but not in an essential way.
       scope_->ForceContextAllocation();
 
       // Calling a generator returns a generator object.  That object is stored
       // 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);
+      if (is_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);
     ParseFormalParameterList(&formals, &formals_classifier, CHECK_OK);
     arity = formals.Arity();
     Expect(Token::RPAREN, CHECK_OK);
     int formals_end_position = scanner()->location().end_pos;
@@ skipping 399 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;
 }
 
+Expression* Parser::EmitCreateJSGeneratorObject(int pos) {
+  DCHECK_NOT_NULL(function_state_->generator_object_variable());

[caitp (gmail), 2016/04/26 22:01:30]

these don't really add much, but since they're used more than once, it's good to
have. Saves a few lines of duplicate code at least

+  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::EmitYieldJSGeneratorObject(Expression* allocation) {
+  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());
+  return factory()->NewYield(get_proxy, assignment, RelocInfo::kNoPosition);
+}
 
 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);
+        Expression* yield = EmitYieldJSGeneratorObject(allocation);
 
-        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),
             zone());
       }
 
       ParseStatementList(try_block->statements(), Token::RBRACE, CHECK_OK);
 
       Statement* final_return = factory()->NewReturnStatement(
           BuildIteratorResult(nullptr, true), RelocInfo::kNoPosition);
       try_block->statements()->Add(final_return, zone());
 
       Block* finally_block =
           factory()->NewBlock(nullptr, 1, false, RelocInfo::kNoPosition);
       ZoneList<Expression*>* args =
           new (zone()) ZoneList<Expression*>(1, zone());
       VariableProxy* call_proxy = factory()->NewVariableProxy(
           function_state_->generator_object_variable());
       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)) {
+      Expression* inner_generator = nullptr;
+      {
+        Scope* generator_scope =
+            NewScope(inner_scope, FUNCTION_SCOPE, kAsyncFunction);
+
+        // For generators, allocating variables in contexts is currently a win
+        // because it minimizes the work needed to suspend and resume an
+        // activation.  The machine code produced for generators (by
+        // full-codegen)
+        // relies on this forced context allocation, but not in an essential
+        // way.
+        generator_scope->ForceContextAllocation();
+
+        FunctionState generator_state_(&function_state_, &scope_,
+                                       generator_scope, kAsyncFunction,
+                                       factory());
+        generator_scope->set_start_position(pos);
+        ZoneList<Statement*>* generator_body =
+            new (zone()) ZoneList<Statement*>(8, zone());
+
+        // Calling a generator returns a generator object.  That object is
+        // stored
+        // 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());
+        generator_state_.set_generator_object_variable(temp);
+
+        Expression* allocation = EmitCreateJSGeneratorObject(pos);
+        Expression* yield = EmitYieldJSGeneratorObject(allocation);
+
+        generator_body->Add(
+            factory()->NewExpressionStatement(yield, RelocInfo::kNoPosition),
+            zone());
+
+        ParseStatementList(generator_body, Token::RBRACE, CHECK_OK);
+
+        Statement* final_return = factory()->NewReturnStatement(
+            BuildIteratorResult(nullptr, true), RelocInfo::kNoPosition);
+        generator_body->Add(final_return, zone());
+        generator_scope->set_end_position(scanner()->location().end_pos);
+
+        inner_generator = factory()->NewFunctionLiteral(
+            function_name, generator_scope, generator_body,
+            generator_state_.materialized_literal_count(),
+            generator_state_.expected_property_count(), 0,
+            FunctionLiteral::kNoDuplicateParameters,
+            FunctionLiteral::kAnonymousExpression,
+            FunctionLiteral::kShouldEagerCompile, kGeneratorFunction,
+            RelocInfo::kNoPosition);
+      }
+
+      ZoneList<Expression*>* call_generator_args =
+          new (zone()) ZoneList<Expression*>(2, zone());
+      call_generator_args->Add(inner_generator, zone());
+      call_generator_args->Add(
+          ThisExpression(inner_scope, factory(), RelocInfo::kNoPosition),
+          zone());
+      Expression* call_generator = factory()->NewCallRuntime(
+          Runtime::kInlineCall, call_generator_args, RelocInfo::kNoPosition);
+
+      ZoneList<Expression*>* async_function_start_args =
+          new (zone()) ZoneList<Expression*>(1, zone());
+      async_function_start_args->Add(call_generator, zone());
+      Expression* async_function_start = factory()->NewCallRuntime(
+          Context::ASYNC_FUNCTION_START_INDEX, async_function_start_args,
+          RelocInfo::kNoPosition);
+      body->Add(factory()->NewReturnStatement(async_function_start,
+                                              RelocInfo::kNoPosition),
+                zone());
     } 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)) {
+      // If an exception occurs during parameter initialization, return a
+      // rejected promise.
+      //
+      // try { <init_block> } catch (error) { return Promise.reject(error); }
+      Block* try_block = init_block;
+      Scope* catch_scope = NewScope(scope_, CATCH_SCOPE);
+      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);
+
+      ZoneList<Expression*>* promise_reject_arguments =
+          new (zone()) ZoneList<Expression*>(1, zone());
+      promise_reject_arguments->Add(factory()->NewVariableProxy(catch_variable),
+                                    zone());
+      CallRuntime* promise_reject = factory()->NewCallRuntime(
+          Context::PROMISE_CREATE_REJECTED_INDEX, promise_reject_arguments,
+          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);
+
+      init_block =
+          factory()->NewBlock(nullptr, 1, true, RelocInfo::kNoPosition);
+      init_block->statements()->Add(try_catch_statement, zone());
+    }
+
     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 770 matching lines @@
 }
 
 void ParserTraits::RewriteNonPattern(Type::ExpressionClassifier* classifier,
                                      bool* ok) {
   parser_->RewriteNonPattern(classifier, ok);
 }
 
 Expression* ParserTraits::RewriteAwaitExpression(Expression* value, int pos) {
   // TODO(caitp): Implement AsyncFunctionAwait()
   // per tc39.github.io/ecmascript-asyncawait/#abstract-ops-async-function-await
-  return value;
+  Expression* generator_object = parser_->factory()->NewVariableProxy(
+      parser_->function_state_->generator_object_variable());
+  value = BuildIteratorResult(value, false);
+  return parser_->factory()->NewYield(generator_object, value, 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 1470 matching lines @@
                         try_block, target);
     final_loop = target;
   }
 
   return final_loop;
 }
 
 
 }  // namespace internal
 }  // namespace v8