[WIP] for-of iterator finalization

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 3318 matching lines @@
           result_proxy, value_literal, RelocInfo::kNoPosition);
       assign_each = factory()->NewAssignment(Token::ASSIGN, each, result_value,
                                              RelocInfo::kNoPosition);
       if (is_destructuring) {
         assign_each = PatternRewriter::RewriteDestructuringAssignment(
             this, assign_each->AsAssignment(), scope_);
       }
     }
 
     for_of->Initialize(each, subject, body,
+                       iterator,
                        assign_iterator,
                        next_result,
                        result_done,
                        assign_each);
   } else {
     if (is_destructuring) {
       Variable* temp =
           scope_->NewTemporary(ast_value_factory()->empty_string());
       VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
       Expression* assign_each = PatternRewriter::RewriteDestructuringAssignment(
@@ skipping 257 matching lines @@
     inner_block->set_scope(inner_scope);
   }
 
   outer_loop->Initialize(NULL, NULL, NULL, inner_block);
   return outer_block;
 }
 
 
 Statement* Parser::ParseForStatement(ZoneList<const AstRawString*>* labels,
                                      bool* ok) {
-  // ForStatement ::
-  //   'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement
-
   int stmt_pos = peek_position();
   Statement* init = NULL;
   ZoneList<const AstRawString*> lexical_bindings(1, zone());
 
   // Create an in-between scope for let-bound iteration variables.
   Scope* for_scope = NewScope(scope_, BLOCK_SCOPE);
 
   BlockState block_state(&scope_, for_scope);
   Expect(Token::FOR, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
@@ skipping 139 matching lines @@
               VariableProxy* tdz_proxy =
                   NewUnresolved(lexical_bindings[i], LET);
               Declaration* tdz_decl = factory()->NewVariableDeclaration(
                   tdz_proxy, LET, scope_, RelocInfo::kNoPosition);
               Variable* tdz_var = Declare(
                   tdz_decl, DeclarationDescriptor::NORMAL, true, CHECK_OK);
               tdz_var->set_initializer_position(position());
             }
           }
 
+        if (loop->IsForOfStatement()) {
+          FinalizeForOfStatement(
+              loop->AsForOfStatement(), RelocInfo::kNoPosition);
+        }
+
         for_scope->set_end_position(scanner()->location().end_pos);
         for_scope = for_scope->FinalizeBlockScope();
         // Parsed for-in loop w/ variable declarations.
         if (init_block != nullptr) {
           init_block->statements()->Add(loop, zone());
           init_block->set_scope(for_scope);
           return init_block;
         } else {
           DCHECK_NULL(for_scope);
           return loop;
@@ skipping 66 matching lines @@
         block->statements()->Add(body, zone());
         InitializeForEachStatement(loop, expression, enumerable, block,
                                    is_destructuring);
         body_scope->set_end_position(scanner()->location().end_pos);
         body_scope = body_scope->FinalizeBlockScope();
         block->set_scope(body_scope);
         for_scope->set_end_position(scanner()->location().end_pos);
         for_scope = for_scope->FinalizeBlockScope();
         DCHECK(for_scope == nullptr);
         // Parsed for-in loop.
+        if (loop->IsForOfStatement()) {
+          FinalizeForOfStatement(
+              loop->AsForOfStatement(), RelocInfo::kNoPosition);
+        }
         return loop;
 
       } else {
         init = factory()->NewExpressionStatement(expression, lhs_beg_pos);
       }
     }
   }
 
   // Standard 'for' loop
   ForStatement* loop = factory()->NewForStatement(labels, stmt_pos);
@@ skipping 1860 matching lines @@
             factory()->NewCallRuntime(Runtime::kAppendElement,
                                       append_element_args,
                                       RelocInfo::kNoPosition),
             RelocInfo::kNoPosition);
       }
       // for (each of spread) %AppendElement($R, each)
       ForEachStatement* loop = factory()->NewForEachStatement(
           ForEachStatement::ITERATE, nullptr, RelocInfo::kNoPosition);
       ForOfStatement* for_of = loop->AsForOfStatement();
       for_of->Initialize(factory()->NewVariableProxy(each), subject,
-                         append_body, assign_iterator, next_element,
+                         append_body, iterator, assign_iterator, next_element,
                          element_done, assign_each);
       do_block->statements()->Add(for_of, zone());
     }
   }
   // Now, rewind the original array literal to truncate everything from the
   // first spread (included) until the end. This fixes $R's initialization.
   lit->RewindSpreads();
   return factory()->NewDoExpression(do_block, result, lit->position());
 }
 
@@ skipping 137 matching lines @@
 Expression* ParserTraits::RewriteYieldStar(
     Expression* generator, Expression* iterable, int pos) {
 
   const int nopos = RelocInfo::kNoPosition;
 
   auto factory = parser_->factory();
   auto avfactory = parser_->ast_value_factory();
   auto scope = parser_->scope_;
   auto zone = parser_->zone();
 
-  Statement* skip = factory->NewEmptyStatement(nopos);
 

[neis, 2016/02/12 12:30:13]

The changes to RewriteYieldStar are unrelated.

   // Forward definition for break/continue statements.
   WhileStatement* loop = factory->NewWhileStatement(nullptr, nopos);
 
 
   // let input = undefined;
   Variable* var_input = scope->NewTemporary(avfactory->empty_string());
   Statement* initialize_input;
   {
     Expression* input_proxy = factory->NewVariableProxy(var_input);
     Expression* assignment = factory->NewAssignment(
@@ skipping 50 matching lines @@
     }
 
     Statement* throw_call;
     {
       Expression* call = NewThrowTypeError(
           MessageTemplate::kSymbolIteratorInvalid, avfactory->empty_string(),
           nopos);
       throw_call = factory->NewExpressionStatement(call, nopos);
     }
 
-    validate_iterator =
-        factory->NewIfStatement(is_receiver_call, skip, throw_call, nopos);
+    validate_iterator = factory->NewIfStatement(
+        is_receiver_call, factory->NewEmptyStatement(nopos), throw_call, nopos);
   }
 
 
   // output = iterator.next(input);
   Statement* call_next;
   {
     Expression* iterator_proxy = factory->NewVariableProxy(var_iterator);
     Expression* literal =
         factory->NewStringLiteral(avfactory->next_string(), nopos);
     Expression* next_property =
@@ skipping 22 matching lines @@
 
     Statement* throw_call;
     {
       auto args = new (zone) ZoneList<Expression*>(1, zone);
       args->Add(factory->NewVariableProxy(var_output), zone);
       Expression* call = factory->NewCallRuntime(
           Runtime::kThrowIteratorResultNotAnObject, args, nopos);
       throw_call = factory->NewExpressionStatement(call, nopos);
     }
 
-    validate_next_output =
-        factory->NewIfStatement(is_receiver_call, skip, throw_call, nopos);
+    validate_next_output = factory->NewIfStatement(
+        is_receiver_call, factory->NewEmptyStatement(nopos), throw_call, nopos);
   }
 
 
   // let iteratorThrow = iterator.throw;
   Variable* var_throw = scope->NewTemporary(avfactory->empty_string());
   Statement* get_throw;
   {
     Expression* iterator_proxy = factory->NewVariableProxy(var_iterator);
     Expression* literal =
         factory->NewStringLiteral(avfactory->throw_string(), nopos);
@@ skipping 15 matching lines @@
     Expression* condition = factory->NewCompareOperation(
         Token::EQ, factory->NewVariableProxy(var_throw),
         factory->NewNullLiteral(nopos), nopos);
 
     Expression* call = NewThrowTypeError(
         MessageTemplate::kThrowMethodMissing,
         avfactory->empty_string(), nopos);
     Statement* throw_call = factory->NewExpressionStatement(call, nopos);
 
     Block* then = factory->NewBlock(nullptr, 4+1, false, nopos);
-    BuildIteratorClose(then->statements(), var_iterator, Nothing<Variable*>(),
-                       Nothing<Variable*>());
+    Variable* var_tmp = scope->NewTemporary(avfactory->empty_string());
+    BuildIteratorClose(
+        then->statements(), var_iterator, Nothing<Variable*>(), var_tmp);
     then->statements()->Add(throw_call, zone);
-    check_throw =
-        factory->NewIfStatement(condition, then, skip, nopos);
+    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);
@@ skipping 18 matching lines @@
 
     Statement* throw_call;
     {
       auto args = new (zone) ZoneList<Expression*>(1, zone);
       args->Add(factory->NewVariableProxy(var_output), zone);
       Expression* call = factory->NewCallRuntime(
           Runtime::kThrowIteratorResultNotAnObject, args, nopos);
       throw_call = factory->NewExpressionStatement(call, nopos);
     }
 
-    validate_throw_output =
-        factory->NewIfStatement(is_receiver_call, skip, throw_call, nopos);
+    validate_throw_output = factory->NewIfStatement(
+        is_receiver_call, factory->NewEmptyStatement(nopos), throw_call, nopos);
   }
 
 
   // if (output.done) break;
   Statement* if_done;
   {
     Expression* output_proxy = factory->NewVariableProxy(var_output);
     Expression* literal =
         factory->NewStringLiteral(avfactory->done_string(), nopos);
     Expression* property = factory->NewProperty(output_proxy, literal, nopos);
     BreakStatement* break_loop = factory->NewBreakStatement(loop, nopos);
-    if_done = factory->NewIfStatement(property, break_loop, skip, nopos);
+    if_done = factory->NewIfStatement(
+        property, break_loop, factory->NewEmptyStatement(nopos), nopos);
   }
 
 
   // mode = kReturn;
   Statement* set_mode_return;
   {
     Expression* mode_proxy = factory->NewVariableProxy(var_mode);
     Expression* kreturn =
         factory->NewSmiLiteral(JSGeneratorObject::RETURN, nopos);
     Expression* assignment =
@@ skipping 98 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, Just(var_input), Just(var_output));
+    BuildIteratorClose(case_return, var_iterator, Just(var_input), var_output);
     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 43 matching lines @@
 
     Variable* dot_result = scope->NewTemporary(avfactory->dot_result_string());
     yield_star = factory->NewDoExpression(do_block, dot_result, nopos);
     Rewriter::Rewrite(parser_, yield_star, avfactory);
   }
 
   return yield_star;
 }
 
 
 void ParserTraits::BuildIteratorClose(ZoneList<Statement*>* statements,

[neis, 2016/02/12 12:30:13]

The changes to this BuildIteratorClose are unrelated too.  There is a separate
BuildIteratorClose further below that is used in the for-of rewriting.  I had
hoped to have only one function but merging them seems to make things look too
obfuscated.

                                       Variable* iterator,
                                       Maybe<Variable*> input,
-                                      Maybe<Variable*> output) {
+                                      Variable* var_output) {
+  //
+  // This function adds four statements to [statements], corresponding to the
+  // following code:
+  //
+  //   let iteratorReturn = iterator.return;
+  //   if (IS_NULL_OR_UNDEFINED(iteratorReturn) return |input|;
+  //   output = %_Call(iteratorReturn, iterator|, input|);
+  //   if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
+  //
+  // Here, |...| denotes optional parts, depending on the presence of the
+  // input variable.
+  //
+
   const int nopos = RelocInfo::kNoPosition;
   auto factory = parser_->factory();
   auto avfactory = parser_->ast_value_factory();
-  auto scope = parser_->scope_;
   auto zone = parser_->zone();
-  Statement* skip = factory->NewEmptyStatement(nopos);
+
 
   // let iteratorReturn = iterator.return;
-  Variable* var = scope->NewTemporary(avfactory->empty_string());
+  Variable* var_return = var_output;  // Reusing the output variable.
   Statement* get_return;
   {
     Expression* iterator_proxy = factory->NewVariableProxy(iterator);
     Expression* literal =
         factory->NewStringLiteral(avfactory->return_string(), nopos);
     Expression* property =
         factory->NewProperty(iterator_proxy, literal, nopos);
-    Expression* return_proxy = factory->NewVariableProxy(var);
+    Expression* return_proxy = factory->NewVariableProxy(var_return);
     Expression* assignment = factory->NewAssignment(
         Token::ASSIGN, return_proxy, property, nopos);
     get_return = factory->NewExpressionStatement(assignment, nopos);
   }
 
-  // if (IS_NULL_OR_UNDEFINED(iteratorReturn) return;  OR
-  // if (IS_NULL_OR_UNDEFINED(iteratorReturn) return input;
+
+  // if (IS_NULL_OR_UNDEFINED(iteratorReturn) return |input|;
   Statement* check_return;
   {
     Expression* condition = factory->NewCompareOperation(
-        Token::EQ, factory->NewVariableProxy(var),
+        Token::EQ, factory->NewVariableProxy(var_return),
         factory->NewNullLiteral(nopos), nopos);
 
     Expression* value = input.IsJust() ?
         static_cast<Expression*>(factory->NewVariableProxy(input.FromJust())) :
         factory->NewUndefinedLiteral(nopos);
 
     Statement* return_undefined = factory->NewReturnStatement(value, nopos);
 
-    check_return =
-        factory->NewIfStatement(condition, return_undefined, skip, nopos);
+    check_return = factory->NewIfStatement(
+        condition, return_undefined, factory->NewEmptyStatement(nopos), nopos);
   }
 
-  // let output = %_Call(iteratorReturn, iterator);  OR
-  // output = %_Call(iteratorReturn, iterator, input);
+
+  // output = %_Call(iteratorReturn, iterator|, input|);
   Statement* call_return;
   {
     auto args = new (zone) ZoneList<Expression*>(3, zone);
-    args->Add(factory->NewVariableProxy(var), zone);
+    args->Add(factory->NewVariableProxy(var_return), zone);
     args->Add(factory->NewVariableProxy(iterator), zone);
     if (input.IsJust()) {
       args->Add(factory->NewVariableProxy(input.FromJust()), zone);
     }
 
     Expression* call =
         factory->NewCallRuntime(Runtime::kInlineCall, args, nopos);
-    Expression* output_proxy = factory->NewVariableProxy(
-        output.IsJust() ? output.FromJust() : var);
+    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)) %ThrowIterResultNotAnObject(output);
+
+  // if (!IS_RECEIVER(output)) %ThrowIteratorResultNotAnObject(output);
   Statement* validate_output;
   {
     Expression* is_receiver_call;
     {
       auto args = new (zone) ZoneList<Expression*>(1, zone);
-      args->Add(factory->NewVariableProxy(var), zone);
+      args->Add(factory->NewVariableProxy(var_output), zone);
       is_receiver_call =
           factory->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
     }
 
     Statement* throw_call;
     {
       auto args = new (zone) ZoneList<Expression*>(1, zone);
-      args->Add(factory->NewVariableProxy(var), zone);
+      args->Add(factory->NewVariableProxy(var_output), zone);
       Expression* call = factory->NewCallRuntime(
           Runtime::kThrowIteratorResultNotAnObject, args, nopos);
       throw_call = factory->NewExpressionStatement(call, nopos);
     }
 
-    validate_output =
-        factory->NewIfStatement(is_receiver_call, skip, throw_call, nopos);
+    validate_output = factory->NewIfStatement(
+        is_receiver_call, factory->NewEmptyStatement(nopos), throw_call, nopos);
   }
 
+
   statements->Add(get_return, zone);
   statements->Add(check_return, zone);
   statements->Add(call_return, zone);
   statements->Add(validate_output, zone);
 }
 
 
+
+
+
+
+
+
+
+
+
+enum { THROW, RETURN_OR_BREAK, NORMAL };
+
+
+void ParserTraits::BuildIteratorClose(ZoneList<Statement*>* statements,
+                                      Variable* iterator,
+                                      Variable* completion) {
+  //
+  // This function adds two statements to [statements], corresponding to the
+  // following code:
+  //
+  //   let iteratorReturn = iterator.return;
+  //   if (!IS_NULL_OR_UNDEFINED(iteratorReturn)) {
+  //     let output;
+  //     if (completion === THROW) {
+  //       if (!IS_CALLABLE(iteratorReturn)) {
+  //         throw MakeTypeError(kReturnMethodNotCallable);
+  //       }
+  //       try { output = %_Call(iteratorReturn, iterator) } catch (_) { }
+  //     } else {
+  //       output = %_Call(iteratorReturn, iterator);
+  //     }
+  //     if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
+  //   }
+  //
+
+  const int nopos = RelocInfo::kNoPosition;
+  auto factory = parser_->factory();
+  auto avfactory = parser_->ast_value_factory();
+  auto scope = parser_->scope_;
+  auto zone = parser_->zone();
+
+
+  // let output;
+  Variable* var_output = scope->NewTemporary(avfactory->empty_string());
+
+
+  // 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(avfactory->return_string(), nopos);
+    Expression* property =
+        factory->NewProperty(iterator_proxy, literal, nopos);
+    Expression* return_proxy = factory->NewVariableProxy(var_return);
+    Expression* assignment = factory->NewAssignment(
+        Token::ASSIGN, return_proxy, property, nopos);
+    get_return = factory->NewExpressionStatement(assignment, nopos);
+  }
+
+
+  // if (!IS_CALLABLE(iteratorReturn)) {
+  //   throw MakeTypeError(kReturnMethodNotCallable);
+  // }
+  Statement* check_return_callable;
+  {
+    Expression* type_of = factory->NewUnaryOperation(
+        Token::TYPEOF, factory->NewVariableProxy(var_return), nopos);
+    Expression* function_literal = factory->NewStringLiteral(
+        avfactory->function_string(), nopos);
+    Expression* condition = factory->NewCompareOperation(
+        Token::EQ_STRICT, type_of, function_literal, nopos);
+
+    Expression* call = NewThrowTypeError(
+        MessageTemplate::kReturnMethodNotCallable,
+        avfactory->empty_string(), nopos);
+    Statement* throw_call = factory->NewExpressionStatement(call, nopos);
+
+    check_return_callable = factory->NewIfStatement(
+        condition, factory->NewEmptyStatement(nopos), throw_call, nopos);
+  }
+
+
+  // output = %_Call(iteratorReturn, iterator);
+  Statement* 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);
+
+    Expression* output_proxy = factory->NewVariableProxy(var_output);
+    Expression* assignment = factory->NewAssignment(
+        Token::ASSIGN, output_proxy, call, nopos);
+    call_return = factory->NewExpressionStatement(assignment, nopos);
+  }
+
+
+  // try { output = %_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);
+    Expression* assignment = factory->NewAssignment(
+        Token::ASSIGN, factory->NewVariableProxy(var_output), call, nopos);
+
+    Block* try_block = factory->NewBlock(nullptr, 1, false, nopos);
+    try_block->statements()->Add(
+        factory->NewExpressionStatement(assignment, nopos), zone);
+
+    Block* catch_block = factory->NewBlock(nullptr, 0, false, nopos);
+
+    Scope* catch_scope = NewScope(scope, CATCH_SCOPE);
+    Variable* catch_variable = catch_scope->DeclareLocal(
+        avfactory->dot_catch_string(), VAR, kCreatedInitialized,
+        Variable::NORMAL);
+
+    try_call_return = factory->NewTryCatchStatement(
+        try_block, catch_scope, catch_variable, catch_block, nopos);
+  }
+
+
+  // if (completion === THROW) {
+  //   #check_return_callable;
+  //   #try_call_return;
+  // } else {
+  //   #call_return;
+  // }
+  Statement* call_return_carefully;
+  {
+    Expression* condition = factory->NewCompareOperation(
+        Token::EQ_STRICT, factory->NewVariableProxy(completion),
+        factory->NewSmiLiteral(THROW, nopos), nopos);
+
+    Block* then_block = factory->NewBlock(nullptr, 2, false, nopos);
+    then_block->statements()->Add(check_return_callable, zone);
+    then_block->statements()->Add(try_call_return, zone);
+
+    call_return_carefully =
+        factory->NewIfStatement(condition, then_block, call_return, nopos);
+  }
+
+
+  // if (!IS_RECEIVER(output)) %ThrowIteratorResultNotAnObject(output);
+  Statement* validate_output;
+  {
+    Expression* is_receiver_call;
+    {
+      auto args = new (zone) ZoneList<Expression*>(1, zone);
+      args->Add(factory->NewVariableProxy(var_output), zone);
+      is_receiver_call =
+          factory->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
+    }
+
+    Statement* throw_call;
+    {
+      auto args = new (zone) ZoneList<Expression*>(1, zone);
+      args->Add(factory->NewVariableProxy(var_output), zone);
+      Expression* call = factory->NewCallRuntime(
+          Runtime::kThrowIteratorResultNotAnObject, args, nopos);
+      throw_call = factory->NewExpressionStatement(call, nopos);
+    }
+
+    validate_output = factory->NewIfStatement(
+        is_receiver_call, factory->NewEmptyStatement(nopos), throw_call, nopos);
+  }
+
+
+  // if (!IS_NULL_OR_UNDEFINED(iteratorReturn)) { ... }
+  Statement* maybe_call_return;
+  {
+    Expression* condition = factory->NewCompareOperation(
+        Token::EQ, factory->NewVariableProxy(var_return),
+        factory->NewNullLiteral(nopos), nopos);
+
+    Block* block = factory->NewBlock(nullptr, 2, false, nopos);
+    block->statements()->Add(call_return_carefully, zone);
+    block->statements()->Add(validate_output, zone);  // GAGA
+
+    maybe_call_return = factory->NewIfStatement(
+        condition, factory->NewEmptyStatement(nopos), block, nopos);
+  }
+
+
+  statements->Add(get_return, zone);
+  statements->Add(maybe_call_return, zone);
+}
+
+
+void ParserTraits::FinalizeForOfStatement(ForOfStatement* loop, int pos) {
+  //
+  // This function replaces the loop's body with the following wrapping:
+  //
+  //   let completion = RETURN_OR_BREAK;
+  //   try {
+  //     #body;
+  //     {{completion = NORMAL}};
+  //   } catch(e) {
+  //     completion = THROW;
+  //     throw e;
+  //   } finally {
+  //     if (completion !== NORMAL) {
+  //       #BuildIteratorClose(iterator, completion)  // See above.
+  //     }
+  //   }
+  //
+
+  const int nopos = RelocInfo::kNoPosition;
+  auto factory = parser_->factory();
+  auto avfactory = parser_->ast_value_factory();
+  auto scope = parser_->scope_;
+  auto zone = parser_->zone();
+
+
+  // let completion = RETURN_OR_BREAK;
+  Variable* var_completion = scope->NewTemporary(avfactory->empty_string());
+  Statement* initialize_completion;
+  {
+    Expression* proxy = factory->NewVariableProxy(var_completion);
+    Expression* assignment = factory->NewAssignment(
+        Token::ASSIGN, proxy,
+        factory->NewSmiLiteral(RETURN_OR_BREAK, nopos), nopos);
+    initialize_completion =
+      factory->NewExpressionStatement(assignment, nopos);
+  }
+
+
+  // {{completion = NORMAL}}
+  Statement* set_completion_normal;
+  {
+    Expression* proxy = factory->NewVariableProxy(var_completion);
+    Expression* assignment = factory->NewAssignment(
+        Token::ASSIGN, proxy, factory->NewSmiLiteral(NORMAL, nopos), nopos);
+
+    Block* block = factory->NewBlock(nullptr, 1, true, nopos);
+    block->statements()->Add(
+        factory->NewExpressionStatement(assignment, nopos), zone);
+    set_completion_normal = block;
+  }
+
+
+  // completion = THROW;
+  Statement* set_completion_throw;
+  {
+    Expression* proxy = factory->NewVariableProxy(var_completion);
+    Expression* assignment = factory->NewAssignment(
+        Token::ASSIGN, proxy, factory->NewSmiLiteral(THROW, nopos), nopos);
+    set_completion_throw = factory->NewExpressionStatement(assignment, nopos);
+  }
+
+
+  // #body;
+  // #set_completion_normal;
+  Block* try_block;
+  {
+    try_block = factory->NewBlock(nullptr, 2, false, nopos);
+    try_block->statements()->Add(loop->body(), zone);
+    try_block->statements()->Add(set_completion_normal, zone);
+  }
+
+
+  // if (completion !== NORMAL) {
+  //   #BuildIteratorClose
+  // }
+  Block* maybe_close;
+  {
+    Expression* condition = factory->NewCompareOperation(
+        Token::EQ_STRICT, factory->NewVariableProxy(var_completion),
+        factory->NewSmiLiteral(NORMAL, nopos), nopos);
+
+    Block* block = factory->NewBlock(nullptr, 2, false, nopos);
+    BuildIteratorClose(
+        block->statements(), loop->iterator(), var_completion);
+    DCHECK(block->statements()->length() == 2);
+
+    maybe_close = factory->NewBlock(nullptr, 1, false, nopos);
+    maybe_close->statements()->Add(factory->NewIfStatement(
+        condition, factory->NewEmptyStatement(nopos), block, nopos), zone);
+  }
+
+
+  // try { #try_block }
+  // catch(e) {
+  //   #set_completion_throw;
+  //   throw e;
+  // }
+  Statement* try_catch;
+  {
+    Block* catch_block;
+    Scope* catch_scope = NewScope(scope, CATCH_SCOPE);
+    Variable* catch_variable = catch_scope->DeclareLocal(
+        avfactory->dot_catch_string(), VAR, kCreatedInitialized,
+        Variable::NORMAL);
+
+    Statement* rethrow;
+    {
+      Expression* proxy = factory->NewVariableProxy(catch_variable);
+      rethrow = factory->NewExpressionStatement(
+          factory->NewThrow(proxy, nopos), nopos);
+    }
+
+    catch_block = factory->NewBlock(nullptr, 2, false, nopos);
+    catch_block->statements()->Add(set_completion_throw, zone);
+    catch_block->statements()->Add(rethrow, zone);
+
+    try_catch = factory->NewTryCatchStatement(
+        try_block, catch_scope, catch_variable, catch_block, nopos);
+  }
+
+
+  // try { #try_catch } finally { #maybe_close }
+  Statement* try_finally;
+  {
+    Block* try_block = factory->NewBlock(nullptr, 1, false, nopos);
+    try_block->statements()->Add(try_catch, zone);
+
+    try_finally =
+        factory->NewTryFinallyStatement(try_block, maybe_close, nopos);
+  }
+
+
+  // #initialize_completion;
+  // #try_finally;
+  Statement* new_body;
+  {
+    Block* block = factory->NewBlock(nullptr, 2, false, nopos);
+    block->statements()->Add(initialize_completion, zone);
+    block->statements()->Add(try_finally, zone);
+    new_body = block;
+  }
+
+
+  loop->set_body(new_body);
+}
+
+
 }  // namespace internal
 }  // namespace v8