WIP [esnext] implement async iteration proposal

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 <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 536 matching lines @@
   set_allow_natives(FLAG_allow_natives_syntax || info->is_native());
   set_allow_tailcalls(FLAG_harmony_tailcalls && !info->is_native() &&
                       info->isolate()->is_tail_call_elimination_enabled());
   set_allow_harmony_do_expressions(FLAG_harmony_do_expressions);
   set_allow_harmony_function_sent(FLAG_harmony_function_sent);
   set_allow_harmony_async_await(FLAG_harmony_async_await);
   set_allow_harmony_restrictive_generators(FLAG_harmony_restrictive_generators);
   set_allow_harmony_trailing_commas(FLAG_harmony_trailing_commas);
   set_allow_harmony_class_fields(FLAG_harmony_class_fields);
   set_allow_harmony_object_spread(FLAG_harmony_object_spread);
+  set_allow_harmony_async_iteration(FLAG_harmony_async_iteration);
   for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount;
        ++feature) {
     use_counts_[feature] = 0;
   }
   if (info->ast_value_factory() == NULL) {
     // info takes ownership of AstValueFactory.
     info->set_ast_value_factory(new AstValueFactory(zone(), info->hash_seed()));
     info->set_ast_value_factory_owned();
     ast_value_factory_ = info->ast_value_factory();
     ast_node_factory_.set_ast_value_factory(ast_value_factory_);
@@ skipping 1231 matching lines @@
   throw_arguments->Add(result_proxy_again, zone());
   Expression* throw_call = factory()->NewCallRuntime(
       Runtime::kThrowIteratorResultNotAnObject, throw_arguments, pos);
 
   return factory()->NewBinaryOperation(
       Token::AND,
       factory()->NewUnaryOperation(Token::NOT, is_spec_object_call, pos),
       throw_call, pos);
 }
 
+Expression* Parser::AwaitIteratorNextResult(Expression* iterator,
+                                            Variable* result, int pos) {
+  Expression* next_literal = factory()->NewStringLiteral(
+      ast_value_factory()->next_string(), kNoSourcePosition);
+  Expression* next_property =
+      factory()->NewProperty(iterator, next_literal, kNoSourcePosition);
+  ZoneList<Expression*>* next_arguments =
+      new (zone()) ZoneList<Expression*>(0, zone());
+  Expression* next_call =
+      factory()->NewCall(next_property, next_arguments, pos);
+
+  // Await(iterator.next())
+  Expression* await_next_call = RewriteAwaitExpression(next_call, pos);
+
+  Expression* result_proxy = factory()->NewVariableProxy(result);
+  Expression* left = factory()->NewAssignment(Token::ASSIGN, result_proxy,
+                                              await_next_call, pos);
+
+  // %_IsJSReceiver(...)
+  ZoneList<Expression*>* is_spec_object_args =
+      new (zone()) ZoneList<Expression*>(1, zone());
+  is_spec_object_args->Add(left, zone());
+  Expression* is_spec_object_call = factory()->NewCallRuntime(
+      Runtime::kInlineIsJSReceiver, is_spec_object_args, pos);
+
+  // %ThrowIteratorResultNotAnObject(result)
+  Expression* result_proxy_again = factory()->NewVariableProxy(result);
+  ZoneList<Expression*>* throw_arguments =
+      new (zone()) ZoneList<Expression*>(1, zone());
+  throw_arguments->Add(result_proxy_again, zone());
+  Expression* throw_call = factory()->NewCallRuntime(
+      Runtime::kThrowIteratorResultNotAnObject, throw_arguments, pos);
+
+  return factory()->NewBinaryOperation(
+      Token::AND,
+      factory()->NewUnaryOperation(Token::NOT, is_spec_object_call, pos),
+      throw_call, pos);
+}
+
 Statement* Parser::InitializeForEachStatement(ForEachStatement* stmt,
                                               Expression* each,
                                               Expression* subject,
                                               Statement* body,
                                               int each_keyword_pos) {
   ForOfStatement* for_of = stmt->AsForOfStatement();
   if (for_of != NULL) {
     const bool finalize = true;
     return InitializeForOfStatement(for_of, each, subject, body, finalize,
                                     each_keyword_pos);
@@ skipping 267 matching lines @@
     block->statements()->Add(body, zone());
     block->statements()->Add(set_completion_normal, zone());
     body = block;
   }
 
   for_of->Initialize(body, iterator, assign_iterator, next_result, result_done,
                      assign_each);
   return finalize ? FinalizeForOfStatement(for_of, completion, nopos) : for_of;
 }
 
+Statement* Parser::InitializeForAwaitOfStatement(ForEachStatement* stmt,
+                                                 Expression* each,
+                                                 Expression* iterable,
+                                                 Statement* body, bool finalize,
+                                                 int next_result_pos) {
+  DCHECK(stmt->IsForOfStatement());
+  ForOfStatement* for_of = stmt->AsForOfStatement();
+
+  // Create the auxiliary expressions needed for iterating over the iterable,
+  // and initialize the given ForOfStatement with them.
+  // If finalize is true, also instrument the loop with code that performs the
+  // proper ES6 iterator finalization.  In that case, the result is not
+  // immediately a ForOfStatement.
+
+  const int nopos = kNoSourcePosition;
+  auto avfactory = ast_value_factory();
+
+  Variable* iterator = NewTemporary(ast_value_factory()->dot_iterator_string());
+  Variable* result = NewTemporary(ast_value_factory()->dot_result_string());
+  Variable* completion = NewTemporary(avfactory->empty_string());
+
+  // iterator = GetIterator(iterable, async)
+  Expression* assign_iterator;
+  {
+    assign_iterator = factory()->NewAssignment(
+        Token::ASSIGN, factory()->NewVariableProxy(iterator),
+        factory()->NewGetIterator(iterable, GetIterator::kAsync,
+                                  iterable->position()),
+        iterable->position());
+  }
+
+  Expression* next_result;
+  {
+    Expression* iterator_proxy = factory()->NewVariableProxy(iterator);
+    next_result =
+        AwaitIteratorNextResult(iterator_proxy, result, next_result_pos);
+  }
+
+  // result.done
+  Expression* result_done;
+  {
+    Expression* done_literal = factory()->NewStringLiteral(
+        ast_value_factory()->done_string(), kNoSourcePosition);
+    Expression* result_proxy = factory()->NewVariableProxy(result);
+    result_done =
+        factory()->NewProperty(result_proxy, done_literal, kNoSourcePosition);
+  }
+
+  // result.value
+  Expression* result_value;
+  {
+    Expression* value_literal =
+        factory()->NewStringLiteral(avfactory->value_string(), nopos);
+    Expression* result_proxy = factory()->NewVariableProxy(result);
+    result_value = factory()->NewProperty(result_proxy, value_literal, nopos);
+  }
+
+  // {{completion = kAbruptCompletion;}}
+  Statement* set_completion_abrupt;
+  if (finalize) {
+    Expression* proxy = factory()->NewVariableProxy(completion);
+    Expression* assignment = factory()->NewAssignment(
+        Token::ASSIGN, proxy,
+        factory()->NewSmiLiteral(Parser::kAbruptCompletion, nopos), nopos);
+
+    Block* block = factory()->NewBlock(nullptr, 1, true, nopos);
+    block->statements()->Add(
+        factory()->NewExpressionStatement(assignment, nopos), zone());
+    set_completion_abrupt = block;
+  }
+
+  // do { let tmp = #result_value; #set_completion_abrupt; tmp }
+  // Expression* result_value (gets overwritten)
+  if (finalize) {
+    Variable* var_tmp = NewTemporary(avfactory->empty_string());
+    Expression* tmp = factory()->NewVariableProxy(var_tmp);
+    Expression* assignment =
+        factory()->NewAssignment(Token::ASSIGN, tmp, result_value, nopos);
+
+    Block* block = factory()->NewBlock(nullptr, 2, false, nopos);
+    block->statements()->Add(
+        factory()->NewExpressionStatement(assignment, nopos), zone());
+    block->statements()->Add(set_completion_abrupt, zone());
+
+    result_value = factory()->NewDoExpression(block, var_tmp, nopos);
+  }
+
+  // each = #result_value;
+  Expression* assign_each;
+  {
+    assign_each =
+        factory()->NewAssignment(Token::ASSIGN, each, result_value, nopos);
+    if (each->IsArrayLiteral() || each->IsObjectLiteral()) {
+      assign_each = PatternRewriter::RewriteDestructuringAssignment(
+          this, assign_each->AsAssignment(), scope());
+    }
+  }
+
+  // {{completion = kNormalCompletion;}}
+  Statement* set_completion_normal;
+  if (finalize) {
+    Expression* proxy = factory()->NewVariableProxy(completion);
+    Expression* assignment = factory()->NewAssignment(
+        Token::ASSIGN, proxy,
+        factory()->NewSmiLiteral(Parser::kNormalCompletion, nopos), nopos);
+
+    Block* block = factory()->NewBlock(nullptr, 1, true, nopos);
+    block->statements()->Add(
+        factory()->NewExpressionStatement(assignment, nopos), zone());
+    set_completion_normal = block;
+  }
+
+  // { #loop-body; #set_completion_normal }
+  // Statement* body (gets overwritten)
+  if (finalize) {
+    Block* block = factory()->NewBlock(nullptr, 2, false, nopos);
+    block->statements()->Add(body, zone());
+    block->statements()->Add(set_completion_normal, zone());
+    body = block;
+  }
+
+  for_of->Initialize(body, iterator, assign_iterator, next_result, result_done,
+                     assign_each);
+  return finalize ? FinalizeForOfStatement(for_of, completion, nopos) : for_of;
+}
+
 Statement* Parser::DesugarLexicalBindingsInForStatement(
     ForStatement* loop, Statement* init, Expression* cond, Statement* next,
     Statement* body, Scope* inner_scope, const ForInfo& for_info, bool* ok) {
   // ES6 13.7.4.8 specifies that on each loop iteration the let variables are
   // copied into a new environment.  Moreover, the "next" statement must be
   // evaluated not in the environment of the just completed iteration but in
   // that of the upcoming one.  We achieve this with the following desugaring.
   // Extra care is needed to preserve the completion value of the original loop.
   //
   // We are given a for statement of the form
@@ skipping 643 matching lines @@
         zone(), &scanner_, stack_limit_, ast_value_factory(),
         &pending_error_handler_, runtime_call_stats_, parsing_on_main_thread_);
 #define SET_ALLOW(name) reusable_preparser_->set_allow_##name(allow_##name());
     SET_ALLOW(natives);
     SET_ALLOW(harmony_do_expressions);
     SET_ALLOW(harmony_function_sent);
     SET_ALLOW(harmony_async_await);
     SET_ALLOW(harmony_trailing_commas);
     SET_ALLOW(harmony_class_fields);
     SET_ALLOW(harmony_object_spread);
+    SET_ALLOW(harmony_async_iteration);
 #undef SET_ALLOW
   }
   // Aborting inner function preparsing would leave scopes in an inconsistent
   // state; we don't parse inner functions in the abortable mode anyway.
   DCHECK(!is_inner_function || !may_abort);
 
   PreParser::PreParseResult result = reusable_preparser_->PreParseFunction(
       kind, function_scope, parsing_module_, is_inner_function, may_abort,
       use_counts_);
 
@@ skipping 1150 matching lines @@
   // The operand needs to be evaluated on a separate statement in order to get
   // a break location, and the .promise needs to be read earlier so that it
   // doesn't insert a false location.
   // TODO(littledan): investigate why this ordering is needed in more detail.
   Variable* generator_object_variable =
       function_state_->generator_object_variable();
   DCHECK_NOT_NULL(generator_object_variable);
 
   const int nopos = kNoSourcePosition;
 
+  if (is_async_generator()) {
+    ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
+    Expression* generator_object =
+        factory()->NewVariableProxy(generator_object_variable);
+    args->Add(generator_object, zone());
+    args->Add(value, zone());
+
+    Expression* await = factory()->NewCallRuntime(
+        Context::ASYNC_GENERATOR_AWAIT_CAUGHT, args, nopos);
+
+    return factory()->NewYield(generator_object, await, nopos,
+                               Yield::kOnExceptionRethrow, Yield::kAwait);
+  }
+
   Block* do_block = factory()->NewBlock(nullptr, 2, false, nopos);
 
   Variable* promise = PromiseVariable();
 
   // Wrap value evaluation to provide a break location.
   Variable* temp_var = NewTemporary(ast_value_factory()->empty_string());
   Expression* value_assignment = factory()->NewAssignment(
       Token::ASSIGN, factory()->NewVariableProxy(temp_var), value, nopos);
   do_block->statements()->Add(
       factory()->NewExpressionStatement(value_assignment, value->position()),
@@ skipping 15 matching lines @@
                                 async_function_await_args, nopos);
   do_block->statements()->Add(
       factory()->NewExpressionStatement(async_function_await, await_pos),
       zone());
 
   // Wrap await to provide a break location between value evaluation and yield.
   Expression* do_expr = factory()->NewDoExpression(do_block, promise, nopos);
 
   generator_object = factory()->NewVariableProxy(generator_object_variable);
   return factory()->NewYield(generator_object, do_expr, nopos,
-                             Yield::kOnExceptionRethrow);
+                             Yield::kOnExceptionRethrow, Yield::kAwait);
 }
 
 class NonPatternRewriter : public AstExpressionRewriter {
  public:
   NonPatternRewriter(uintptr_t stack_limit, Parser* parser)
       : AstExpressionRewriter(stack_limit), parser_(parser) {}
   ~NonPatternRewriter() override {}
 
  private:
   bool RewriteExpression(Expression* expr) override {
@@ skipping 1160 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8