[generators] Implement Generator.prototype.return.

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 5851 matching lines @@
 
   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);
 
-  enum { kNext, kReturn, kThrow };
-  // TODO(neis): Use JSGenerator::ResumeMode once extended with RETURN.
-
   // 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(
         Token::ASSIGN, input_proxy, factory->NewUndefinedLiteral(nopos), nopos);
     initialize_input = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
   // let mode = kNext;
   Variable* var_mode = scope->NewTemporary(avfactory->empty_string());
   Statement* initialize_mode;
   {
     Expression* mode_proxy = factory->NewVariableProxy(var_mode);
-    Expression* knext = factory->NewSmiLiteral(kNext, nopos);
+    Expression* knext = factory->NewSmiLiteral(JSGeneratorObject::NEXT, nopos);
     Expression* assignment =
         factory->NewAssignment(Token::ASSIGN, mode_proxy, knext, nopos);
     initialize_mode = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
   // let output = undefined;
   Variable* var_output = scope->NewTemporary(avfactory->empty_string());
   Statement* initialize_output;
   {
@@ skipping 174 matching lines @@
     Expression* property = factory->NewProperty(output_proxy, literal, nopos);
     BreakStatement* break_loop = factory->NewBreakStatement(loop, nopos);
     if_done = factory->NewIfStatement(property, break_loop, skip, nopos);
   }
 
 
   // mode = kReturn;
   Statement* set_mode_return;
   {
     Expression* mode_proxy = factory->NewVariableProxy(var_mode);
-    Expression* kreturn = factory->NewSmiLiteral(kReturn, nopos);
+    Expression* kreturn =
+        factory->NewSmiLiteral(JSGeneratorObject::RETURN, nopos);
     Expression* assignment =
         factory->NewAssignment(Token::ASSIGN, mode_proxy, kreturn, nopos);
     set_mode_return = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
   // RawYield(output);
   Statement* yield_output;
   {
     Expression* output_proxy = factory->NewVariableProxy(var_output);
     Yield* yield = factory->NewYield(
         generator, output_proxy, Yield::kInitial, nopos);
     yield_output = factory->NewExpressionStatement(yield, nopos);
   }
 
 
   // mode = kNext;
   Statement* set_mode_next;
   {
     Expression* mode_proxy = factory->NewVariableProxy(var_mode);
-    Expression* knext = factory->NewSmiLiteral(kNext, nopos);
+    Expression* knext = factory->NewSmiLiteral(JSGeneratorObject::NEXT, nopos);
     Expression* assignment =
         factory->NewAssignment(Token::ASSIGN, mode_proxy, knext, nopos);
     set_mode_next = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
   // mode = kThrow;
   Statement* set_mode_throw;
   {
     Expression* mode_proxy = factory->NewVariableProxy(var_mode);
-    Expression* kthrow = factory->NewSmiLiteral(kThrow, nopos);
+    Expression* kthrow =
+        factory->NewSmiLiteral(JSGeneratorObject::THROW, nopos);
     Expression* assignment =
         factory->NewAssignment(Token::ASSIGN, mode_proxy, kthrow, nopos);
     set_mode_throw = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
   // input = function.sent;
   Statement* get_input;
   {
     Expression* function_sent = FunctionSentExpression(scope, factory, nopos);
@@ skipping 68 matching lines @@
     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);
-    Expression* knext = factory->NewSmiLiteral(kNext, nopos);
-    Expression* kreturn = factory->NewSmiLiteral(kReturn, nopos);
-    Expression* kthrow = factory->NewSmiLiteral(kThrow, nopos);
+    Expression* knext = factory->NewSmiLiteral(JSGeneratorObject::NEXT, nopos);
+    Expression* kreturn =
+        factory->NewSmiLiteral(JSGeneratorObject::RETURN, nopos);
+    Expression* kthrow =
+        factory->NewSmiLiteral(JSGeneratorObject::THROW, nopos);
     cases->Add(factory->NewCaseClause(knext, case_next, nopos), zone);
     cases->Add(factory->NewCaseClause(kreturn, case_return, nopos), zone);
     cases->Add(factory->NewCaseClause(kthrow, case_throw, nopos), zone);
 
     switch_mode->Initialize(factory->NewVariableProxy(var_mode), cases);
   }
 
 
   // while (true) { ... }
   // Already defined earlier: WhileStatement* loop = ...
@@ skipping 125 matching lines @@
 
   statements->Add(get_return, zone);
   statements->Add(check_return, zone);
   statements->Add(call_return, zone);
   statements->Add(validate_output, zone);
 }
 
 
 }  // namespace internal
 }  // namespace v8