Fix embarrassing bug in last-minute-change to yield* CL.

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 5791 matching lines @@
 //
 //     while (true) {
 //       // From the generator to the iterator:
 //       // Forward input according to resume mode and obtain output.
 //       switch (mode) {
 //         case kNext:
 //           output = iterator.next(input);
 //           if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
 //           break;
 //         case kReturn:
-//           IteratorClose(iterator, input);  // See below.
+//           IteratorClose(iterator, input, output);  // See below.
 //           break;
 //         case kThrow:
 //           let iteratorThrow = iterator.throw;
 //           if (IS_NULL_OR_UNDEFINED(iteratorThrow)) {
 //             IteratorClose(iterator);  // See below.
 //             throw MakeTypeError(kThrowMethodMissing);
 //           }
 //           output = %_Call(iteratorThrow, iterator, input);
 //           if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
 //           break;
@@ skipping 16 matching lines @@
 //       }
 //     }
 //
 //     output.value;
 //   }
 //
 // IteratorClose(iterator) expands to the following:
 //
 //   let iteratorReturn = iterator.return;
 //   if (IS_NULL_OR_UNDEFINED(iteratorReturn)) return;
-//   let result = %_Call(iteratorReturn, iterator);
-//   if (!IS_RECEIVER(result)) %ThrowIterResultNotAnObject(result);
+//   let output = %_Call(iteratorReturn, iterator);
+//   if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
 //
-// IteratorClose(iterator, input) expands to the following:
+// IteratorClose(iterator, input, output) expands to the following:
 //
 //   let iteratorReturn = iterator.return;
 //   if (IS_NULL_OR_UNDEFINED(iteratorReturn)) return input;
-//   let result = %_Call(iteratorReturn, iterator, input);
-//   if (!IS_RECEIVER(result)) %ThrowIterResultNotAnObject(result);
+//   output = %_Call(iteratorReturn, iterator, input);
+//   if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
 
 
 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_;
@@ skipping 148 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*>());
+    BuildIteratorClose(then->statements(), var_iterator, Nothing<Variable*>(),
+                       Nothing<Variable*>());
     then->statements()->Add(throw_call, zone);
     check_throw =
         factory->NewIfStatement(condition, then, skip, nopos);
   }
 
 
   // output = %_Call(iteratorThrow, iterator, input);
   Statement* call_throw;
   {
     auto args = new (zone) ZoneList<Expression*>(3, zone);
@@ skipping 151 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));
+    BuildIteratorClose(
+        case_return, var_iterator, Just(var_input), Just(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 @@
     yield_star = factory->NewDoExpression(do_block, dot_result, nopos);
     Rewriter::Rewrite(parser_, yield_star, avfactory);
   }
 
   return yield_star;
 }
 
 
 void ParserTraits::BuildIteratorClose(ZoneList<Statement*>* statements,
                                       Variable* iterator,
-                                      Maybe<Variable*> input) {
+                                      Maybe<Variable*> input,
+                                      Maybe<Variable*> output) {
   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());
   Statement* get_return;
@@ skipping 20 matching lines @@
     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);
   }
 
-  // let result = %_Call(iteratorReturn, iterator);  OR
-  // let result = %_Call(iteratorReturn, iterator, input);
+  // let output = %_Call(iteratorReturn, iterator);  OR
+  // 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(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* assignment = factory->NewAssignment(
-        Token::ASSIGN, factory->NewVariableProxy(var), call, nopos);
+        Token::ASSIGN, output_proxy, call, nopos);
     call_return = factory->NewExpressionStatement(assignment, nopos);
   }
 
-  // if (!IS_RECEIVER(result)) %ThrowIterResultNotAnObject(result);
-  Statement* validate_result;
+  // if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
+  Statement* validate_output;
   {
     Expression* is_receiver_call;
     {
       auto args = new (zone) ZoneList<Expression*>(1, zone);
       args->Add(factory->NewVariableProxy(var), 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);
       Expression* call = factory->NewCallRuntime(
           Runtime::kThrowIteratorResultNotAnObject, args, nopos);
       throw_call = factory->NewExpressionStatement(call, nopos);
     }
 
-    validate_result =
+    validate_output =
         factory->NewIfStatement(is_receiver_call, skip, throw_call, nopos);
   }
 
   statements->Add(get_return, zone);
   statements->Add(check_return, zone);
   statements->Add(call_return, zone);
-  statements->Add(validate_result, zone);
+  statements->Add(validate_output, zone);
 }
 
 
 }  // namespace internal
 }  // namespace v8