Implement iterator finalization in array destructuring.

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 6260 matching lines @@
     do_block->statements()->Add(get_value, zone);
 
     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;
 }
 
+
 // Desugaring of (lhs) instanceof (rhs)
 // ====================================
 //
 // We desugar instanceof into a load of property @@hasInstance on the rhs.
-// We end up with roughly the following code (O, C):
+// We end up with roughly the following code:
 //
 //   do {
 //     let O = lhs;
 //     let C = rhs;
 //     if (!IS_RECEIVER(C)) throw MakeTypeError(kNonObjectInInstanceOfCheck);
 //     let handler_result = C[Symbol.hasInstance];
 //     if (handler_result === undefined) {
 //       if (!IS_CALLABLE(C)) {
 //         throw MakeTypeError(kCalledNonCallableInstanceOf);
 //       }
@@ skipping 63 matching lines @@
     Expression* handler_proxy = factory->NewVariableProxy(var_handler_result);
     Expression* assignment =
         factory->NewAssignment(Token::ASSIGN, handler_proxy, prop, nopos);
     initialize_handler = factory->NewExpressionStatement(assignment, nopos);
   }
 
   // if (handler_result === undefined) {
   //   if (!IS_CALLABLE(C)) {
   //     throw MakeTypeError(kCalledNonCallableInstanceOf);
   //   }
-  //   result = %ordinary_has_instance(C, O);
+  //   handler_result = %ordinary_has_instance(C, O);
   // } else {
   //   handler_result = !!%_Call(handler_result, C, O);
   // }
   Statement* call_handler;
   {
     Expression* condition = factory->NewCompareOperation(
         Token::EQ_STRICT, factory->NewVariableProxy(var_handler_result),
         factory->NewUndefinedLiteral(nopos), nopos);
 
     Block* then_side = factory->NewBlock(nullptr, 2, false, nopos);
@@ skipping 50 matching lines @@
     block->statements()->Add(call_handler, zone);
 
     // Here is the desugared instanceof.
     instanceof = factory->NewDoExpression(block, var_handler_result, nopos);
     Rewriter::Rewrite(parser_, instanceof, avfactory);
   }
 
   return instanceof;
 }
 
+
 Statement* ParserTraits::CheckCallable(Variable* var, Expression* error) {
   auto factory = parser_->factory();
   auto avfactory = parser_->ast_value_factory();
   const int nopos = RelocInfo::kNoPosition;
   Statement* validate_var;
   {
     Expression* type_of = factory->NewUnaryOperation(
         Token::TYPEOF, factory->NewVariableProxy(var), nopos);
     Expression* function_literal =
         factory->NewStringLiteral(avfactory->function_string(), nopos);
     Expression* condition = factory->NewCompareOperation(
         Token::EQ_STRICT, type_of, function_literal, nopos);
 
     Statement* throw_call = factory->NewExpressionStatement(error, nopos);
 
     validate_var = factory->NewIfStatement(
         condition, factory->NewEmptyStatement(nopos), throw_call, nopos);
   }
   return validate_var;
 }
 
+
 void ParserTraits::BuildIteratorClose(ZoneList<Statement*>* statements,
                                       Variable* iterator,
                                       Maybe<Variable*> input,
                                       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|;
@@ skipping 85 matching lines @@
         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);
 }
 
 
-// Runtime encoding of different completion modes.
-enum ForOfLoopBodyCompletion { BODY_COMPLETED, BODY_ABORTED, BODY_THREW };
+void ParserTraits::FinalizeIteratorUse(
+    Variable* completion, Expression* condition, Variable* iter,
+    Block* iterator_use, Block* target) {
+  if (!FLAG_harmony_iterator_close) return;
+
+  //
+  // This function adds two statements to [target], corresponding to the
+  // following code:

[adamk, 2016/03/08 01:57:07]

It's somewhat confusing that this code contains a single try/catch/finally but
that the desugaring below creates a TryCatch and a TryFinally. I realize that
has to do with how those AST nodes work, but I think it might make reading the
desugaring easier if the block below matched up precisely with the code
generated as part of the desugaring.

[neis, 2016/03/08 13:40:10]

Done.

+  //
+  //   completion = NORMAL;
+  //   try {
+  //     iterator_use
+  //   } catch(e) {
+  //     if (completion === ABRUPT) completion = THROW;
+  //     throw e;
+  //   } finally {
+  //     if (condition) {
+  //       #BuildIteratorCloseForCompletion(iter, completion)
+  //     }
+  //   }
+  //
+
+  const int nopos = RelocInfo::kNoPosition;
+  auto factory = parser_->factory();

[adamk, 2016/03/08 01:57:07]

If you put this function in Parser instead of ParserTraits, you wouldn't need
this or the other shorthands below (though I guess you might run into trouble
since BuildIteratorCloseForCompletion is itself in ParserTraits).

Maybe something to keep in mind for a cleanup.

+  auto avfactory = parser_->ast_value_factory();
+  auto scope = parser_->scope_;
+  auto zone = parser_->zone();
+
+  // completion = NORMAL;
+  Statement* initialize_completion;
+  {
+    Expression* proxy = factory->NewVariableProxy(completion);
+    Expression* assignment = factory->NewAssignment(
+        Token::ASSIGN, proxy,
+        factory->NewSmiLiteral(Parser::NORMAL, nopos), nopos);
+    initialize_completion =
+        factory->NewExpressionStatement(assignment, nopos);
+  }
+
+  // if (completion === ABRUPT) completion = THROW;
+  Statement* set_completion_throw;
+  {
+    Expression* condition = factory->NewCompareOperation(
+        Token::EQ_STRICT, factory->NewVariableProxy(completion),
+        factory->NewSmiLiteral(Parser::ABRUPT, nopos), nopos);
+
+    Expression* proxy = factory->NewVariableProxy(completion);
+    Expression* assignment = factory->NewAssignment(
+        Token::ASSIGN, proxy, factory->NewSmiLiteral(Parser::THROW, nopos),
+        nopos);
+    Statement* statement = factory->NewExpressionStatement(assignment, nopos);
+    set_completion_throw = factory->NewIfStatement(
+        condition, statement, factory->NewEmptyStatement(nopos), nopos);
+  }
+
+  // if (condition) {
+  //   #BuildIteratorCloseForCompletion(iter, completion)
+  // }
+  Block* maybe_close;
+  {
+    Block* block = factory->NewBlock(nullptr, 2, true, nopos);
+    parser_->BuildIteratorCloseForCompletion(
+        block->statements(), iter, completion);
+    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 }
+  // catch(e) {
+  //   #set_completion_throw;
+  //   throw e;
+  // }
+  Statement* try_catch;
+  {
+    Scope* catch_scope = parser_->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);
+    }
+
+    Block* 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(
+        iterator_use, 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);
+  }
+
+  target->statements()->Add(initialize_completion, zone);
+  target->statements()->Add(try_finally, zone);
+}
+
 
 void ParserTraits::BuildIteratorCloseForCompletion(
     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)) {
-  //     if (completion === BODY_THREW) {
+  //     if (completion === THROW) {
   //       if (!IS_CALLABLE(iteratorReturn)) {
   //         throw MakeTypeError(kReturnMethodNotCallable);
   //       }
   //       try { %_Call(iteratorReturn, iterator) } catch (_) { }
   //     } else {
   //       let output = %_Call(iteratorReturn, iterator);
   //       if (!IS_RECEIVER(output)) {
   //         %ThrowIterResultNotAnObject(output);
   //       }
   //     }
@@ skipping 97 matching lines @@
     }
 
     Statement* check_return = factory->NewIfStatement(
         is_receiver_call, factory->NewEmptyStatement(nopos), throw_call, nopos);
 
     validate_return = factory->NewBlock(nullptr, 2, false, nopos);
     validate_return->statements()->Add(call_return, zone);
     validate_return->statements()->Add(check_return, zone);
   }
 
-  // if (completion === BODY_THREW) {
+  // if (completion === THROW) {
   //   #check_return_callable;
   //   #try_call_return;
   // } else {
   //   #validate_return;
   // }
   Statement* call_return_carefully;
   {
     Expression* condition = factory->NewCompareOperation(
         Token::EQ_STRICT, factory->NewVariableProxy(completion),
-        factory->NewSmiLiteral(BODY_THREW, nopos), nopos);
+        factory->NewSmiLiteral(Parser::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, validate_return, nopos);
   }
 
   // if (!IS_NULL_OR_UNDEFINED(iteratorReturn)) { ... }
@@ skipping 13 matching lines @@
   statements->Add(maybe_call_return, zone);
 }
 
 
 Statement* ParserTraits::FinalizeForOfStatement(ForOfStatement* loop, int pos) {
   if (!FLAG_harmony_iterator_close) return loop;
 
   //
   // This function replaces the loop with the following wrapping:
   //
-  //   let completion = BODY_COMPLETED;
   //   let each;
+  //   let completion = NORMAL;
   //   try {
   //     #loop;
   //   } catch(e) {
-  //     if (completion === BODY_ABORTED) completion = BODY_THREW;
+  //     if (completion === ABRUPT) completion = THROW;
   //     throw e;
   //   } finally {
-  //     if (!(completion === BODY_COMPLETED || IS_UNDEFINED(#iterator))) {
+  //     if (!(completion === NORMAL || IS_UNDEFINED(#iterator))) {
   //       #BuildIteratorCloseForCompletion(#iterator, completion)
   //     }
   //   }
   //
   // where the loop's body is wrapped as follows:
   //
   //   {
   //     #loop-body
-  //     {{completion = BODY_COMPLETED;}}
+  //     {{completion = NORMAL;}}
   //   }
   //
-  // and assign_each is wrapped as follows
+  // and the loop's assign_each is wrapped as follows
   //
   //   do {
-  //     {{completion = BODY_ABORTED;}}
+  //     {{completion = ABRUPT;}}
   //     #assign-each
-  //   } into each
+  //   }
+  //
 
   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 = BODY_COMPLETED;
   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(BODY_COMPLETED, nopos), nopos);
-    initialize_completion =
-        factory->NewExpressionStatement(assignment, nopos);
-  }
 
   // let each;
   Variable* var_each = scope->NewTemporary(avfactory->empty_string());
   Statement* initialize_each;
   {
     Expression* proxy = factory->NewVariableProxy(var_each);
     Expression* assignment = factory->NewAssignment(
         Token::ASSIGN, proxy,
         factory->NewUndefinedLiteral(nopos), nopos);
     initialize_each =
         factory->NewExpressionStatement(assignment, nopos);
   }
 
-  // if (completion === BODY_ABORTED) completion = BODY_THREW;
-  Statement* set_completion_throw;
+  // !(completion === NORMAL || IS_UNDEFINED(#iterator))
+  Expression* condition;

[adamk, 2016/03/07 20:28:05]

Can you give this a better name? Maybe "iterator_close_condition"?

[neis, 2016/03/08 13:40:10]

Done.

   {
-    Expression* condition = factory->NewCompareOperation(
+    Expression* lhs = factory->NewCompareOperation(
         Token::EQ_STRICT, factory->NewVariableProxy(var_completion),
-        factory->NewSmiLiteral(BODY_ABORTED, nopos), nopos);
-
-    Expression* proxy = factory->NewVariableProxy(var_completion);
-    Expression* assignment = factory->NewAssignment(
-        Token::ASSIGN, proxy, factory->NewSmiLiteral(BODY_THREW, nopos),
+        factory->NewSmiLiteral(Parser::NORMAL, nopos), nopos);
+    Expression* rhs = factory->NewCompareOperation(
+        Token::EQ_STRICT, factory->NewVariableProxy(loop->iterator()),
+        factory->NewUndefinedLiteral(nopos), nopos);
+    condition = factory->NewUnaryOperation(
+        Token::NOT,
+        factory->NewBinaryOperation(Token::OR, lhs, rhs, nopos),
         nopos);
-    Statement* statement = factory->NewExpressionStatement(assignment, nopos);
-    set_completion_throw = factory->NewIfStatement(
-        condition, statement, factory->NewEmptyStatement(nopos), nopos);
   }
 
-  // if (!(completion === BODY_COMPLETED || IS_UNDEFINED(#iterator))) {
-  //   #BuildIteratorCloseForCompletion(#iterator, completion)
-  // }
-  Block* maybe_close;
-  {
-    Expression* condition1 = factory->NewCompareOperation(
-        Token::EQ_STRICT, factory->NewVariableProxy(var_completion),
-        factory->NewSmiLiteral(BODY_COMPLETED, nopos), nopos);
-    Expression* condition2 = factory->NewCompareOperation(
-        Token::EQ_STRICT, factory->NewVariableProxy(loop->iterator()),
-        factory->NewUndefinedLiteral(nopos), nopos);
-    Expression* condition = factory->NewBinaryOperation(
-        Token::OR, condition1, condition2, nopos);
-
-    Block* block = factory->NewBlock(nullptr, 2, false, nopos);
-    BuildIteratorCloseForCompletion(
-        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;
-  {
-    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);
-    }
-
-    Block* try_block = factory->NewBlock(nullptr, 1, false, nopos);
-    try_block->statements()->Add(loop, zone);
-
-    Block* 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;
-  // #initialize_each;
-  // #try_finally;
-  Statement* final_loop;
-  {
-    Block* block = factory->NewBlock(nullptr, 2, false, nopos);
-    block->statements()->Add(initialize_completion, zone);
-    block->statements()->Add(initialize_each, zone);
-    block->statements()->Add(try_finally, zone);
-    final_loop = block;
-  }
-
-  // {{completion = BODY_COMPLETED;}}
+  // {{completion = NORMAL;}}
   Statement* set_completion_normal;
   {
     Expression* proxy = factory->NewVariableProxy(var_completion);
     Expression* assignment = factory->NewAssignment(
-        Token::ASSIGN, proxy, factory->NewSmiLiteral(BODY_COMPLETED, nopos),
+        Token::ASSIGN, proxy, factory->NewSmiLiteral(Parser::NORMAL, 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 }
-  Block* new_body = factory->NewBlock(nullptr, 2, false, nopos);
-  new_body->statements()->Add(loop->body(), zone);
-  new_body->statements()->Add(set_completion_normal, zone);
-
-  loop->set_body(new_body);
-
-  // {{completion = BODY_ABORTED;}}
-  Statement* set_completion_break;
+  // {{completion = ABRUPT;}}
+  Statement* set_completion_abrupt;
   {
     Expression* proxy = factory->NewVariableProxy(var_completion);
     Expression* assignment = factory->NewAssignment(
-        Token::ASSIGN, proxy, factory->NewSmiLiteral(BODY_ABORTED, nopos),
+        Token::ASSIGN, proxy, factory->NewSmiLiteral(Parser::ABRUPT, nopos),
         nopos);
 
     Block* block = factory->NewBlock(nullptr, 1, true, nopos);
     block->statements()->Add(factory->NewExpressionStatement(assignment, nopos),
                              zone);
-    set_completion_break = block;
+    set_completion_abrupt = block;
   }
 
-  // { #set_completion_break; #assign-each }
+  // { #loop-body; #set_completion_normal }
+  Block* new_body = factory->NewBlock(nullptr, 2, false, nopos);
+  {
+    new_body->statements()->Add(loop->body(), zone);
+    new_body->statements()->Add(set_completion_normal, zone);
+  }
+
+  // { #set_completion_abrupt; #assign-each }
   Block* new_assign_each = factory->NewBlock(nullptr, 2, false, nopos);
-  new_assign_each->statements()->Add(set_completion_break, zone);
-  new_assign_each->statements()->Add(
-      factory->NewExpressionStatement(loop->assign_each(), nopos), zone);
+  {
+    new_assign_each->statements()->Add(set_completion_abrupt, zone);
+    new_assign_each->statements()->Add(
+        factory->NewExpressionStatement(loop->assign_each(), nopos), zone);
+  }
 
-  Expression* do_each =
-      factory->NewDoExpression(new_assign_each, var_each, nopos);
-  loop->set_assign_each(do_each);
+  // Now put things together.
+
+  loop->set_body(new_body);
+  loop->set_assign_each(
+      factory->NewDoExpression(new_assign_each, var_each, nopos));
+
+  Statement* final_loop;
+  {
+    Block* target = factory->NewBlock(nullptr, 3, false, nopos);
+    target->statements()->Add(initialize_each, zone);
+
+    Block* try_block = factory->NewBlock(nullptr, 1, false, nopos);
+    try_block->statements()->Add(loop, zone);
+
+    FinalizeIteratorUse(
+        var_completion, condition, loop->iterator(), try_block, target);
+    final_loop = target;
+  }
 
   return final_loop;
 }
 
 
 }  // namespace internal
 }  // namespace v8