Fix behavior of return on yield*.

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 5991 matching lines @@
 //           mode = kNext;
 //         } catch (error) {
 //           mode = kThrow;
 //         }
 //       } finally {
 //         input = function.sent;
 //         continue;
 //       }
 //     }
 //
-//     output.value;
+//     if (mode === kReturn) {
+//       return {value: output.value, done: true};
+//     }
+//     output.value
 //   }
 //
 // IteratorClose(iterator) expands to the following:
 //
 //   let iteratorReturn = iterator.return;
 //   if (IS_NULL_OR_UNDEFINED(iteratorReturn)) return;
 //   let output = %_Call(iteratorReturn, iterator);
 //   if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
 //
 // IteratorClose(iterator, input, output) expands to the following:
@@ skipping 275 matching lines @@
   Statement* get_input;
   {
     Expression* function_sent = FunctionSentExpression(scope, factory, nopos);
     Expression* input_proxy = factory->NewVariableProxy(var_input);
     Expression* assignment = factory->NewAssignment(
         Token::ASSIGN, input_proxy, function_sent, nopos);
     get_input = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
-  // output.value;
+  // if (mode === kReturn) {
+  //   return {value: output.value, done: true};
+  // }
+  Statement* maybe_return_value;
+  {
+    Expression* mode_proxy = factory->NewVariableProxy(var_mode);
+    Expression* kreturn =
+        factory->NewSmiLiteral(JSGeneratorObject::kReturn, nopos);
+    Expression* condition = factory->NewCompareOperation(
+        Token::EQ_STRICT, mode_proxy, kreturn, nopos);
+
+    Expression* output_proxy = factory->NewVariableProxy(var_output);
+    Expression* literal =
+        factory->NewStringLiteral(avfactory->value_string(), nopos);
+    Expression* property = factory->NewProperty(output_proxy, literal, nopos);
+    Statement* return_value =
+        factory->NewReturnStatement(BuildIteratorResult(property, true), nopos);
+
+    maybe_return_value = factory->NewIfStatement(
+        condition, return_value, factory->NewEmptyStatement(nopos), nopos);
+  }
+
+
+  // output.value
   Statement* get_value;
   {
     Expression* output_proxy = factory->NewVariableProxy(var_output);
     Expression* literal =
         factory->NewStringLiteral(avfactory->value_string(), nopos);
     Expression* property = factory->NewProperty(output_proxy, literal, nopos);
     get_value = factory->NewExpressionStatement(property, nopos);
   }
 
 
@@ skipping 82 matching lines @@
     loop->Initialize(factory->NewBooleanLiteral(true, nopos), loop_body);
   }
 
 
   // do { ... }
   DoExpression* yield_star;
   {
     // The rewriter needs to process the get_value statement only, hence we
     // put the preceding statements into an init block.
 
-    Block* do_block_ = factory->NewBlock(nullptr, 6, true, nopos);
+    Block* do_block_ = factory->NewBlock(nullptr, 7, true, nopos);
     do_block_->statements()->Add(initialize_input, zone);
     do_block_->statements()->Add(initialize_mode, zone);
     do_block_->statements()->Add(initialize_output, zone);
     do_block_->statements()->Add(get_iterator, zone);
     do_block_->statements()->Add(validate_iterator, zone);
     do_block_->statements()->Add(loop, zone);
+    do_block_->statements()->Add(maybe_return_value, zone);
 
     Block* do_block = factory->NewBlock(nullptr, 2, false, nopos);
     do_block->statements()->Add(do_block_, zone);
     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);
   }
 
@@ skipping 548 matching lines @@
                         try_block, target);
     final_loop = target;
   }
 
   return final_loop;
 }
 
 
 }  // namespace internal
 }  // namespace v8