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 535 matching lines @@
                 info->extension() == nullptr && can_compile_lazily;
   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_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 1194 matching lines @@
         try_block, catch_info.scope, catch_info.variable, catch_block, pos);
   } else {
     DCHECK_NOT_NULL(finally_block);
     return factory()->NewTryFinallyStatement(try_block, finally_block, pos);
   }
 }
 
 // !%_IsJSReceiver(result = iterator.next()) &&
 //     %ThrowIteratorResultNotAnObject(result)
 Expression* Parser::BuildIteratorNextResult(Expression* iterator,
-                                            Variable* result, int pos) {
+                                            Variable* result, IteratorType type,
+                                            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);
+  if (type == IteratorType::kAsync) {
+    next_call = RewriteAwaitExpression(next_call, pos);
+  }
   Expression* result_proxy = factory()->NewVariableProxy(result);
   Expression* left =
       factory()->NewAssignment(Token::ASSIGN, result_proxy, 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);
@@ skipping 200 matching lines @@
         Token::ASSIGN, factory()->NewVariableProxy(iterator),
         factory()->NewGetIterator(iterable, iterable->position()),
         iterable->position());
   }
 
   // !%_IsJSReceiver(result = iterator.next()) &&
   //     %ThrowIteratorResultNotAnObject(result)
   Expression* next_result;
   {
     Expression* iterator_proxy = factory()->NewVariableProxy(iterator);
-    next_result =
-        BuildIteratorNextResult(iterator_proxy, result, next_result_pos);
+    next_result = BuildIteratorNextResult(
+        iterator_proxy, result, IteratorType::kNormal, 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);
@@ skipping 67 matching lines @@
   // 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;
+  return finalize ? FinalizeForOfStatement(for_of, completion,
+                                           IteratorType::kNormal, nopos)
+                  : for_of;
+}
+
+Statement* Parser::InitializeForAwaitOfStatement(ForEachStatement* stmt,
+                                                 Expression* each,
+                                                 Expression* iterable,
+                                                 Statement* body, bool finalize,
+                                                 int next_result_pos) {

[Dan Ehrenberg, 2017/01/13 22:09:02]

This is really similar to  Parser::InitializeForOfStatement . Should that just
take an IteratorType argument?

[caitp, 2017/01/13 22:33:30]

I'm undecided on this.

I think the code is easier to  understand when separated, but since i opted to
pass the IteratorType for other methods to avoid duplication, it's probably fine
to reuse it for for-of

[Dan Ehrenberg, 2017/01/14 00:48:38]

For me, it's easier to understand code when it's not duplicated, at least when
it's in a large amount like this. When there's so much copy-paste, it takes me a
while to go through everything to find what the difference is between the two
sections. At least that was my experience reviewing this patch.

+  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 = BuildIteratorNextResult(
+        iterator_proxy, result, IteratorType::kAsync, 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,
+                                           IteratorType::kAsync, 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.
@@ skipping 644 matching lines @@
     reusable_preparser_ = new PreParser(
         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_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);

[Dan Ehrenberg, 2017/01/13 22:09:02]

Why don't you have to apply the same sort of block thing that the rest of this
function does in order to get single stepping to work as expected? I would've
expected that your modification here would be to just switch between the two
different runtime function indices, and otherwise do all the same things? (Even
if you're not passing the Promise for now, presumably you'll need to once catch
prediction support is added.)

[caitp, 2017/01/13 22:33:30]

I haven't tested any of this with the inspector yet, but I'd like to minimize
the number of new runtime mechanics in the parser, as it doesn't seem like a
sensible place for them to me. If debugging is awful with it, it will be
improved, but hopefully not using do expressions or the parser

[Dan Ehrenberg, 2017/01/14 00:48:38]

I'm confused; if you wanted to minimize the amount of mechanics in the parser,
why not just do the exact same thing that the rest of this does? It would mean
that this patch just adds one line here instead of 12. I don't think Yang or I
were happy to put this logic in the parser, but that's where it goes in the
current system. When we refactor things to not have the logic in the parser,
then we can do it for both async functions and async generators.

+  }
+
   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 337 matching lines @@
 // IteratorClose(iterator, input, output) expands to the following:
 //
 //   let iteratorReturn = iterator.return;
 //   if (IS_NULL_OR_UNDEFINED(iteratorReturn)) return input;
 //   output = %_Call(iteratorReturn, iterator, input);
 //   if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
 
 Expression* Parser::RewriteYieldStar(Expression* generator,
                                      Expression* iterable, int pos) {
   const int nopos = kNoSourcePosition;
+  IteratorType type =
+      is_async_generator() ? IteratorType::kAsync : IteratorType::kNormal;
 
   // Forward definition for break/continue statements.
   WhileStatement* loop = factory()->NewWhileStatement(nullptr, nopos);
 
   // let input = undefined;
   Variable* var_input = NewTemporary(ast_value_factory()->empty_string());
   Statement* initialize_input;
   {
     Expression* input_proxy = factory()->NewVariableProxy(var_input);
     Expression* assignment =
@@ skipping 22 matching lines @@
     Expression* assignment =
         factory()->NewAssignment(Token::ASSIGN, output_proxy,
                                  factory()->NewUndefinedLiteral(nopos), nopos);
     initialize_output = factory()->NewExpressionStatement(assignment, nopos);
   }
 
   // let iterator = GetIterator(iterable);
   Variable* var_iterator = NewTemporary(ast_value_factory()->empty_string());
   Statement* get_iterator;
   {
-    Expression* iterator = factory()->NewGetIterator(iterable, nopos);
+    GetIterator::Hint hint = GetIterator::kNormal;
+    if (type == IteratorType::kAsync) {
+      hint = GetIterator::kAsync;
+    }
+    Expression* iterator = factory()->NewGetIterator(iterable, hint, nopos);
     Expression* iterator_proxy = factory()->NewVariableProxy(var_iterator);
     Expression* assignment = factory()->NewAssignment(
         Token::ASSIGN, iterator_proxy, iterator, nopos);
     get_iterator = factory()->NewExpressionStatement(assignment, nopos);
   }
 
   // output = iterator.next(input);
   Statement* call_next;
   {
     Expression* iterator_proxy = factory()->NewVariableProxy(var_iterator);
     Expression* literal =
         factory()->NewStringLiteral(ast_value_factory()->next_string(), nopos);
     Expression* next_property =
         factory()->NewProperty(iterator_proxy, literal, nopos);
     Expression* input_proxy = factory()->NewVariableProxy(var_input);
     auto args = new (zone()) ZoneList<Expression*>(1, zone());
     args->Add(input_proxy, zone());
     Expression* call = factory()->NewCall(next_property, args, nopos);
+    if (type == IteratorType::kAsync) {
+      call = RewriteAwaitExpression(call, nopos);
+    }
     Expression* output_proxy = factory()->NewVariableProxy(var_output);
     Expression* assignment =
         factory()->NewAssignment(Token::ASSIGN, output_proxy, call, nopos);
     call_next = factory()->NewExpressionStatement(assignment, nopos);
   }
 
   // if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
   Statement* validate_next_output;
   {
     Expression* is_receiver_call;
@@ skipping 43 matching lines @@
         Token::EQ, factory()->NewVariableProxy(var_throw),
         factory()->NewNullLiteral(nopos), nopos);
     Expression* call =
         NewThrowTypeError(MessageTemplate::kThrowMethodMissing,
                           ast_value_factory()->empty_string(), nopos);
     Statement* throw_call = factory()->NewExpressionStatement(call, nopos);
 
     Block* then = factory()->NewBlock(nullptr, 4 + 1, false, nopos);
     BuildIteratorCloseForCompletion(
         scope(), then->statements(), var_iterator,
-        factory()->NewSmiLiteral(Parser::kNormalCompletion, nopos));
+        factory()->NewSmiLiteral(Parser::kNormalCompletion, nopos), type);
     then->statements()->Add(throw_call, zone());
     check_throw = factory()->NewIfStatement(
         condition, then, factory()->NewEmptyStatement(nopos), nopos);
   }
 
   // output = %_Call(iteratorThrow, iterator, input);
   Statement* call_throw;
   {
     auto args = new (zone()) ZoneList<Expression*>(3, zone());
     args->Add(factory()->NewVariableProxy(var_throw), zone());
     args->Add(factory()->NewVariableProxy(var_iterator), zone());
     args->Add(factory()->NewVariableProxy(var_input), zone());
     Expression* call =
         factory()->NewCallRuntime(Runtime::kInlineCall, args, nopos);
+    if (type == IteratorType::kAsync) {
+      call = RewriteAwaitExpression(call, nopos);
+    }
     Expression* assignment = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(var_output), call, nopos);
     call_throw = factory()->NewExpressionStatement(assignment, nopos);
   }
 
   // if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
   Statement* validate_throw_output;
   {
     Expression* is_receiver_call;
     {
@@ skipping 38 matching lines @@
         factory()->NewSmiLiteral(JSGeneratorObject::kReturn, nopos);
     Expression* assignment =
         factory()->NewAssignment(Token::ASSIGN, mode_proxy, kreturn, nopos);
     set_mode_return = factory()->NewExpressionStatement(assignment, nopos);
   }
 
   // Yield(output);
   Statement* yield_output;
   {
     Expression* output_proxy = factory()->NewVariableProxy(var_output);
-    Yield* yield = factory()->NewYield(generator, output_proxy, nopos,
-                                       Yield::kOnExceptionThrow);
+    Yield* yield =
+        factory()->NewYield(generator, output_proxy, nopos,
+                            Yield::kOnExceptionThrow, Yield::kDelegate);
     yield_output = factory()->NewExpressionStatement(yield, nopos);
   }
 
   // mode = kNext;
   Statement* set_mode_next;
   {
     Expression* mode_proxy = factory()->NewVariableProxy(var_mode);
     Expression* knext =
         factory()->NewSmiLiteral(JSGeneratorObject::kNext, nopos);
     Expression* assignment =
@@ skipping 92 matching lines @@
 
   // switch (mode) { ... }
   SwitchStatement* switch_mode = factory()->NewSwitchStatement(nullptr, nopos);
   {
     auto case_next = new (zone()) ZoneList<Statement*>(3, zone());
     case_next->Add(call_next, zone());
     case_next->Add(validate_next_output, zone());
     case_next->Add(factory()->NewBreakStatement(switch_mode, nopos), zone());
 
     auto case_return = new (zone()) ZoneList<Statement*>(5, zone());
-    BuildIteratorClose(case_return, var_iterator, var_input, var_output);
+    BuildIteratorClose(case_return, var_iterator, var_input, var_output, type);
     case_return->Add(factory()->NewBreakStatement(switch_mode, nopos), zone());
 
     auto case_throw = new (zone()) ZoneList<Statement*>(5, zone());
     case_throw->Add(get_throw, zone());
     case_throw->Add(check_throw, zone());
     case_throw->Add(call_throw, zone());
     case_throw->Add(validate_throw_output, zone());
     case_throw->Add(factory()->NewBreakStatement(switch_mode, nopos), zone());
 
     auto cases = new (zone()) ZoneList<CaseClause*>(3, zone());
@@ skipping 63 matching lines @@
     Statement* throw_call = factory()->NewExpressionStatement(error, pos);
 
     validate_var = factory()->NewIfStatement(
         condition, factory()->NewEmptyStatement(nopos), throw_call, nopos);
   }
   return validate_var;
 }
 
 void Parser::BuildIteratorClose(ZoneList<Statement*>* statements,
                                 Variable* iterator, Variable* input,
-                                Variable* var_output) {
+                                Variable* var_output, IteratorType type) {
   //
   // This function adds four statements to [statements], corresponding to the
   // following code:
   //
   //   let iteratorReturn = iterator.return;
   //   if (IS_NULL_OR_UNDEFINED(iteratorReturn) {
   //     return {value: input, done: true};
   //   }
   //   output = %_Call(iteratorReturn, iterator, input);
+  //   if (IteratorType == kAsync) {
+  //     output = Await(output)
+  //   }
   //   if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
-  //
+
+  // output = Await(%_Call(iteratorReturn, iterator, input));

[Dan Ehrenberg, 2017/01/13 19:41:09]

Comment nit: should be if (IteratorType == kAsync) { ... }

[caitp, 2017/01/13 20:11:52]

It kind of gives the impression that the desugaring conditionally Awaits based
on some runtime value, but it statically decides to Await or not depending on
whether it's an async iterator or not.

I haven't found a good way to word these yet, so I'll use whatever prose people
want here.

[Dan Ehrenberg, 2017/01/13 22:09:02]

I was just copying the way that you wrote the syntax above, which already seemed
fine to me, but good point about the compile time vs runtime mismatch. Anyway,
for a strawman way to do the syntax in these comments, what if we use something
traditional and conservative--IE conditional comments!
https://msdn.microsoft.com/en-us/library/ms537512(v=vs.85).aspx

[if IteratorType == kAsync]
  output = Await(output)
[endif]

Anyway, I don't think it's a big deal which syntax you use, but it's nicer if
some sort of conditionality is explicit.

 
   const int nopos = kNoSourcePosition;
 
   // let iteratorReturn = iterator.return;
   Variable* var_return = var_output;  // Reusing the output variable.
   Statement* get_return;
   {
     Expression* iterator_proxy = factory()->NewVariableProxy(iterator);
     Expression* literal = factory()->NewStringLiteral(
         ast_value_factory()->return_string(), nopos);
@@ skipping 26 matching lines @@
   // output = %_Call(iteratorReturn, iterator, input);
   Statement* call_return;
   {
     auto args = new (zone()) ZoneList<Expression*>(3, zone());
     args->Add(factory()->NewVariableProxy(var_return), zone());
     args->Add(factory()->NewVariableProxy(iterator), zone());
     args->Add(factory()->NewVariableProxy(input), zone());
 
     Expression* call =
         factory()->NewCallRuntime(Runtime::kInlineCall, args, nopos);
+    if (type == IteratorType::kAsync) {
+      call = RewriteAwaitExpression(call, nopos);
+    }
     Expression* output_proxy = factory()->NewVariableProxy(var_output);
     Expression* assignment =
         factory()->NewAssignment(Token::ASSIGN, output_proxy, call, nopos);
     call_return = factory()->NewExpressionStatement(assignment, nopos);
   }
 
   // if (!IS_RECEIVER(output)) %ThrowIteratorResultNotAnObject(output);
   Statement* validate_output;
   {
     Expression* is_receiver_call;
@@ skipping 19 matching lines @@
   }
 
   statements->Add(get_return, zone());
   statements->Add(check_return, zone());
   statements->Add(call_return, zone());
   statements->Add(validate_output, zone());
 }
 
 void Parser::FinalizeIteratorUse(Scope* use_scope, Variable* completion,
                                  Expression* condition, Variable* iter,
-                                 Block* iterator_use, Block* target) {
+                                 Block* iterator_use, Block* target,
+                                 IteratorType type) {
   //
   // This function adds two statements to [target], corresponding to the
   // following code:
   //
   //   completion = kNormalCompletion;
   //   try {
   //     try {
   //       iterator_use
   //     } catch(e) {
   //       if (completion === kAbruptCompletion) completion = kThrowCompletion;
@@ skipping 35 matching lines @@
         condition, statement, factory()->NewEmptyStatement(nopos), nopos);
   }
 
   // if (condition) {
   //   #BuildIteratorCloseForCompletion(iter, completion)
   // }
   Block* maybe_close;
   {
     Block* block = factory()->NewBlock(nullptr, 2, true, nopos);
     Expression* proxy = factory()->NewVariableProxy(completion);
-    BuildIteratorCloseForCompletion(use_scope, block->statements(), iter,
-                                    proxy);
+    BuildIteratorCloseForCompletion(use_scope, block->statements(), iter, proxy,
+                                    type);
     DCHECK(block->statements()->length() == 2);
 
     maybe_close = factory()->NewBlock(nullptr, 1, true, nopos);
     maybe_close->statements()->Add(
         factory()->NewIfStatement(condition, block,
                                   factory()->NewEmptyStatement(nopos), nopos),
         zone());
   }
 
   // try { #try_block }
@@ skipping 39 matching lines @@
         factory()->NewTryFinallyStatement(try_block, maybe_close, nopos);
   }
 
   target->statements()->Add(initialize_completion, zone());
   target->statements()->Add(try_finally, zone());
 }
 
 void Parser::BuildIteratorCloseForCompletion(Scope* scope,
                                              ZoneList<Statement*>* statements,
                                              Variable* iterator,
-                                             Expression* completion) {
+                                             Expression* completion,
+                                             IteratorType type) {
   //
   // This function adds two statements to [statements], corresponding to the
   // following code:
   //
   //   let iteratorReturn = iterator.return;
   //   if (!IS_NULL_OR_UNDEFINED(iteratorReturn)) {
   //     if (completion === kThrowCompletion) {
   //       if (!IS_CALLABLE(iteratorReturn)) {
   //         throw MakeTypeError(kReturnMethodNotCallable);
   //       }
@@ skipping 37 matching lines @@
   // try { %_Call(iteratorReturn, iterator) } catch (_) { }
   Statement* try_call_return;
   {
     auto args = new (zone()) ZoneList<Expression*>(2, zone());
     args->Add(factory()->NewVariableProxy(var_return), zone());
     args->Add(factory()->NewVariableProxy(iterator), zone());
 
     Expression* call =
         factory()->NewCallRuntime(Runtime::kInlineCall, args, nopos);
 
+    if (type == IteratorType::kAsync) {
+      call = RewriteAwaitExpression(call, nopos);
+    }
+
     Block* try_block = factory()->NewBlock(nullptr, 1, false, nopos);
     try_block->statements()->Add(factory()->NewExpressionStatement(call, nopos),
                                  zone());
 
     Block* catch_block = factory()->NewBlock(nullptr, 0, false, nopos);
 
     Scope* catch_scope = NewScopeWithParent(scope, CATCH_SCOPE);
     Variable* catch_variable =
         catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(), VAR,
                                   kCreatedInitialized, NORMAL_VARIABLE);
@@ skipping 80 matching lines @@
     maybe_call_return = factory()->NewIfStatement(
         condition, factory()->NewEmptyStatement(nopos), call_return_carefully,
         nopos);
   }
 
   statements->Add(get_return, zone());
   statements->Add(maybe_call_return, zone());
 }
 
 Statement* Parser::FinalizeForOfStatement(ForOfStatement* loop,
-                                          Variable* var_completion, int pos) {
+                                          Variable* var_completion,
+                                          IteratorType type, int pos) {
   //
   // This function replaces the loop with the following wrapping:
   //
   //   completion = kNormalCompletion;
   //   try {
   //     try {
   //       #loop;
   //     } catch(e) {
   //       if (completion === kAbruptCompletion) completion = kThrowCompletion;
   //       %ReThrow(e);
@@ skipping 23 matching lines @@
   {
     Block* try_block = factory()->NewBlock(nullptr, 1, false, nopos);
     try_block->statements()->Add(loop, zone());
 
     // The scope in which the parser creates this loop.
     Scope* loop_scope = scope()->outer_scope();
     DCHECK_EQ(loop_scope->scope_type(), BLOCK_SCOPE);
     DCHECK_EQ(scope()->scope_type(), BLOCK_SCOPE);
 
     FinalizeIteratorUse(loop_scope, var_completion, closing_condition,
-                        loop->iterator(), try_block, final_loop);
+                        loop->iterator(), try_block, final_loop, type);
   }
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8