Move generator-close on exception from the generator function to the GeneratorResume builtin.

src/parsing/parser-base.h

 // 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
@@ skipping 1370 matching lines @@
         scope->GetDeclarationScope()->RecordEvalCall();
       }
       return Call::IS_POSSIBLY_EVAL;
     }
     return Call::NOT_EVAL;
   }
 
   // Convenience method which determines the type of return statement to emit
   // depending on the current function type.
   inline StatementT BuildReturnStatement(ExpressionT expr, int pos) {
-    if (is_generator() && !is_async_generator()) {
-      expr = impl()->BuildIteratorResult(expr, true);
-    }
-
     if (is_async_function()) {
       return factory()->NewAsyncReturnStatement(expr, pos);
     }
     return factory()->NewReturnStatement(expr, pos);
   }
 
   inline SuspendExpressionT BuildSuspend(
       ExpressionT generator, ExpressionT expr, int pos,
       Suspend::OnAbruptResume on_abrupt_resume, SuspendFlags suspend_type) {
     DCHECK_EQ(0,
@@ skipping 1590 matching lines @@
         expression = ParseAssignmentExpression(accept_IN, CHECK_OK);
         impl()->RewriteNonPattern(CHECK_OK);
         break;
     }
   }
 
   if (delegating) {
     return impl()->RewriteYieldStar(generator_object, expression, pos);
   }
 
-  if (!is_async_generator()) {
-    // Async generator yield is rewritten in Ignition, and doesn't require
-    // producing an Iterator Result.
-    expression = impl()->BuildIteratorResult(expression, false);
-  }
-
   // Hackily disambiguate o from o.next and o [Symbol.iterator]().
   // TODO(verwaest): Come up with a better solution.
   ExpressionT yield =
       BuildSuspend(generator_object, expression, pos,
                    Suspend::kOnExceptionThrow, SuspendFlags::kYield);
   return yield;
 }
 
 // Precedence = 3
 template <typename Impl>
@@ skipping 1067 matching lines @@
     inner_scope = NewVarblockScope();
     inner_scope->set_start_position(scanner()->location().beg_pos);
     inner_block = factory()->NewBlock(NULL, 8, true, kNoSourcePosition);
     inner_block->set_scope(inner_scope);
     body = inner_block->statements();
   }
 
   {
     BlockState block_state(&scope_, inner_scope);
 
-    if (IsGeneratorFunction(kind)) {
+    if (IsAsyncGeneratorFunction(kind)) {
+      impl()->ParseAndRewriteAsyncGeneratorFunctionBody(pos, kind, body, ok);
+    } else if (IsGeneratorFunction(kind)) {
       impl()->ParseAndRewriteGeneratorFunctionBody(pos, kind, body, ok);
     } else if (IsAsyncFunction(kind)) {
       const bool accept_IN = true;
       ParseAsyncFunctionBody(inner_scope, body, kind, FunctionBodyType::kNormal,
                              accept_IN, pos, CHECK_OK_VOID);
     } else {
       ParseStatementList(body, Token::RBRACE, CHECK_OK_VOID);
     }
 
     if (IsDerivedConstructor(kind)) {
@@ skipping 1899 matching lines @@
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 #undef CHECK_OK_VOID
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H