Reland "[async-iteration] implement spec-change to `yield` in async generators"

Per https://github.com/tc39/proposal-async-iteration/pull/102/files:

AsyncGeneratorResolve no longer unwraps a value component. Instead, the value is
unwrapped before the builtin call via Await, allowing Promise rejections to
affect the generator control flow.

Thus, all `yield <expr>` implicitly become `yield await <expr>`.

Additionally, `return <expr>` becomes `return await <expr>`. Finally, when the
generator is resumed with `.return()`, the parameter passed to .return() is
awaited before generator execution properly continues).

BUG=v8:6187, v8:5855
R=littledan@chromium.org, neis@chromium.org, adamk@chromium.org
TBR=rmcilroy@chromium.org, neis@chromium.org

Cq-Include-Trybots: master.tryserver.v8:v8_linux_noi18n_rel_ng
Change-Id: Id7718028fd555481f9f4ca0dbecfa788e3057c48
Reviewed-on: https://chromium-review.googlesource.com/594500Reviewed-by: Caitlin Potter <caitp@igalia.com>
Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Commit-Queue: Caitlin Potter <caitp@igalia.com>
Cr-Commit-Position: refs/heads/master@{#47058}

src/ast/ast-numbering.cc

@@ -95,6 +95,7 @@ class AstNumberingVisitor final : public AstVisitor<AstNumberingVisitor> {
   int suspend_count_;
   AstProperties properties_;
   LanguageMode language_mode_;
+  FunctionKind function_kind_;
   // The slot cache allows us to reuse certain feedback slots.
   FeedbackSlotCache slot_cache_;
   BailoutReason disable_fullcodegen_reason_;
@@ -218,7 +219,13 @@ void AstNumberingVisitor::VisitSuspend(Suspend* node) {
   Visit(node->expression());
 }
 
-void AstNumberingVisitor::VisitYield(Yield* node) { VisitSuspend(node); }
+void AstNumberingVisitor::VisitYield(Yield* node) {
+  node->set_suspend_id(suspend_count_++);
+  if (IsAsyncGeneratorFunction(function_kind_)) {
+    node->set_await_return_value_suspend_id(suspend_count_++);
+  }
+  Visit(node->expression());
+}
 
 void AstNumberingVisitor::VisitYieldStar(YieldStar* node) {
   VisitSuspend(node);
@@ -581,6 +588,7 @@ bool AstNumberingVisitor::Renumber(FunctionLiteral* node) {
     DisableFullCodegen(kClassConstructorFunction);
   }
 
+  function_kind_ = node->kind();
   LanguageModeScope language_mode_scope(this, node->language_mode());
 
   if (collect_type_profile_) {

src/ast/ast.h

@@ -2275,10 +2275,24 @@ class Suspend : public Expression {
 };
 
 class Yield final : public Suspend {
+ public:
+  inline int await_return_value_suspend_id() const {
+    DCHECK_NE(await_return_value_suspend_id_, -1);
+    return await_return_value_suspend_id_;
+  }
+  void set_await_return_value_suspend_id(int id) {
+    await_return_value_suspend_id_ = id;
+  }
+
  private:
   friend class AstNodeFactory;
   Yield(Expression* expression, int pos, OnAbruptResume on_abrupt_resume)
-      : Suspend(kYield, expression, pos, on_abrupt_resume) {}
+      : Suspend(kYield, expression, pos, on_abrupt_resume),
+        await_return_value_suspend_id_(-1) {}
+
+  // TODO(caitp): remove from class once `await` handled by AsyncGeneratorReturn
+  // stub.
+  int await_return_value_suspend_id_;
 };
 
 class YieldStar final : public Suspend {

src/bootstrapper.cc

@@ -1487,6 +1487,18 @@ void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object,
     info->set_internal_formal_parameter_count(1);
     info->set_length(1);
     native_context()->set_async_generator_await_reject_shared_fun(*info);
+
+    code = BUILTIN_CODE(isolate, AsyncGeneratorReturnResolveClosure);
+    info = factory->NewSharedFunctionInfo(factory->empty_string(), code, false);
+    info->set_internal_formal_parameter_count(1);
+    info->set_length(1);
+    native_context()->set_async_generator_return_resolve_shared_fun(*info);
+
+    code = BUILTIN_CODE(isolate, AsyncGeneratorReturnRejectClosure);
+    info = factory->NewSharedFunctionInfo(factory->empty_string(), code, false);
+    info->set_internal_formal_parameter_count(1);
+    info->set_length(1);
+    native_context()->set_async_generator_return_reject_shared_fun(*info);
   }
 
   {  // --- A r r a y ---

src/builtins/builtins-async-generator-gen.cc

@@ -418,8 +418,8 @@ TF_BUILTIN(AsyncGeneratorResumeNext, AsyncGeneratorBuiltinsAssembler) {
            LoadGeneratorState(generator));
   VARIABLE(var_next, MachineRepresentation::kTagged,
            LoadFirstAsyncGeneratorRequestFromQueue(generator));
-  Variable* labels[] = {&var_state, &var_next};
-  Label start(this, 2, labels);
+  Variable* loop_variables[] = {&var_state, &var_next};
+  Label start(this, 2, loop_variables);
   Goto(&start);
   BIND(&start);
 
@@ -453,10 +453,10 @@ TF_BUILTIN(AsyncGeneratorResumeNext, AsyncGeneratorBuiltinsAssembler) {
            &fulfill_promise, &reject_promise);
 
     BIND(&fulfill_promise);
-    CallBuiltin(Builtins::kAsyncGeneratorResolve, context, generator,
-                LoadValueFromAsyncGeneratorRequest(next), TrueConstant());
-    var_next.Bind(LoadFirstAsyncGeneratorRequestFromQueue(generator));
-    Goto(&start);
+    // Unwrap Promise values for "return" in state "suspendedStart".
+    // This simulates `return await request.[[Completion]].[[Value]]`
+    TailCallBuiltin(Builtins::kAsyncGeneratorReturnProcessor, context,
+                    generator);
 
     BIND(&reject_promise);
     CallBuiltin(Builtins::kAsyncGeneratorReject, context, generator,
@@ -495,19 +495,35 @@ TF_BUILTIN(AsyncGeneratorResolve, AsyncGeneratorBuiltinsAssembler) {
                   HasInstanceType(generator, JS_ASYNC_GENERATOR_OBJECT_TYPE));
   CSA_ASSERT(this, IsGeneratorNotSuspendedForAwait(generator));
 
+  // If this assertion fails, the `value` component was not Awaited as it should
+  // have been, per https://github.com/tc39/proposal-async-iteration/pull/102/.
+  CSA_SLOW_ASSERT(this, TaggedDoesntHaveInstanceType(value, JS_PROMISE_TYPE));
+
   Node* const next = TakeFirstAsyncGeneratorRequestFromQueue(generator);
   Node* const promise = LoadPromiseFromAsyncGeneratorRequest(next);
 
-  Node* const wrapper = AllocateAndInitJSPromise(context);
-  CallBuiltin(Builtins::kResolveNativePromise, context, wrapper, value);
+  // Let iteratorResult be CreateIterResultObject(value, done).
+  Node* const iter_result = Allocate(JSIteratorResult::kSize);
+  {
+    Node* map = LoadContextElement(LoadNativeContext(context),
+                                   Context::ITERATOR_RESULT_MAP_INDEX);
+    StoreMapNoWriteBarrier(iter_result, map);
+    StoreObjectFieldRoot(iter_result, JSIteratorResult::kPropertiesOrHashOffset,
+                         Heap::kEmptyFixedArrayRootIndex);
+    StoreObjectFieldRoot(iter_result, JSIteratorResult::kElementsOffset,
+                         Heap::kEmptyFixedArrayRootIndex);
+    StoreObjectFieldNoWriteBarrier(iter_result, JSIteratorResult::kValueOffset,
+                                   value);
+    StoreObjectFieldNoWriteBarrier(iter_result, JSIteratorResult::kDoneOffset,
+                                   done);
+  }
 
-  Node* const on_fulfilled =
-      CreateUnwrapClosure(LoadNativeContext(context), done);
+  // Perform Call(promiseCapability.[[Resolve]], undefined, «iteratorResult»).
+  CallBuiltin(Builtins::kResolveNativePromise, context, promise, iter_result);
 
   // Per spec, AsyncGeneratorResolve() returns undefined. However, for the
   // benefit of %TraceExit(), return the Promise.
-  Return(CallBuiltin(Builtins::kPerformNativePromiseThen, context, wrapper,
-                     on_fulfilled, UndefinedConstant(), promise));
+  Return(promise);
 }
 
 TF_BUILTIN(AsyncGeneratorReject, AsyncGeneratorBuiltinsAssembler) {
@@ -523,5 +539,65 @@ TF_BUILTIN(AsyncGeneratorReject, AsyncGeneratorBuiltinsAssembler) {
                      TrueConstant()));
 }
 
+TF_BUILTIN(AsyncGeneratorReturnProcessor, AsyncGeneratorBuiltinsAssembler) {
+  Node* const generator = Parameter(Descriptor::kGenerator);
+  Node* const req = LoadFirstAsyncGeneratorRequestFromQueue(generator);
+
+  CSA_SLOW_ASSERT(this, SmiEqual(LoadResumeTypeFromAsyncGeneratorRequest(req),
+                                 SmiConstant(JSGeneratorObject::kReturn)));
+
+  ContextInitializer init_closure_context = [&](Node* context) {
+    StoreContextElementNoWriteBarrier(context, AwaitContext::kGeneratorSlot,
+                                      generator);
+  };
+
+  const bool kIsPredictedAsCaught = false;
+
+  Node* const context = Parameter(Descriptor::kContext);
+  Node* const outer_promise = LoadPromiseFromAsyncGeneratorRequest(req);
+  Node* const value = LoadValueFromAsyncGeneratorRequest(req);
+  Node* const promise = Await(
+      context, generator, value, outer_promise, AwaitContext::kLength,
+      init_closure_context, Context::ASYNC_GENERATOR_RETURN_RESOLVE_SHARED_FUN,
+      Context::ASYNC_GENERATOR_RETURN_REJECT_SHARED_FUN, kIsPredictedAsCaught);
+
+  CSA_SLOW_ASSERT(this, IsGeneratorNotSuspendedForAwait(generator));
+  StoreObjectField(generator, JSAsyncGeneratorObject::kAwaitedPromiseOffset,
+                   promise);
+  Return(UndefinedConstant());
+}
+
+TF_BUILTIN(AsyncGeneratorReturnResolveClosure,
+           AsyncGeneratorBuiltinsAssembler) {
+  Node* const context = Parameter(Descriptor::kContext);
+  Node* const value = Parameter(Descriptor::kValue);
+  Node* const generator =
+      LoadContextElement(context, AwaitContext::kGeneratorSlot);
+
+  CSA_SLOW_ASSERT(this, IsGeneratorSuspendedForAwait(generator));
+  ClearAwaitedPromise(generator);
+
+  //  Return ! AsyncGeneratorResolve(_F_.[[Generator]], _value_, *true*).
+  CallBuiltin(Builtins::kAsyncGeneratorResolve, context, generator, value,
+              TrueConstant());
+
+  TailCallBuiltin(Builtins::kAsyncGeneratorResumeNext, context, generator);
+}
+
+TF_BUILTIN(AsyncGeneratorReturnRejectClosure, AsyncGeneratorBuiltinsAssembler) {
+  Node* const context = Parameter(Descriptor::kContext);
+  Node* const value = Parameter(Descriptor::kValue);
+  Node* const generator =
+      LoadContextElement(context, AwaitContext::kGeneratorSlot);
+
+  CSA_SLOW_ASSERT(this, IsGeneratorSuspendedForAwait(generator));
+  ClearAwaitedPromise(generator);
+
+  // Return ! AsyncGeneratorReject(_F_.[[Generator]], _reason_).
+  CallBuiltin(Builtins::kAsyncGeneratorReject, context, generator, value);
+
+  TailCallBuiltin(Builtins::kAsyncGeneratorResumeNext, context, generator);
+}
+
 }  // namespace internal
 }  // namespace v8

src/builtins/builtins-definitions.h

@@ -1050,6 +1050,7 @@ namespace internal {
                                                                                \
   TFS(AsyncGeneratorResolve, kGenerator, kValue, kDone)                        \
   TFS(AsyncGeneratorReject, kGenerator, kValue)                                \
+  TFS(AsyncGeneratorReturnProcessor, kGenerator)                               \
   TFS(AsyncGeneratorResumeNext, kGenerator)                                    \
                                                                                \
   /* AsyncGeneratorFunction( p1, p2, ... pn, body ) */                         \
@@ -1074,6 +1075,8 @@ namespace internal {
   TFJ(AsyncGeneratorAwaitUncaught, 1, kAwaited)                                \
   TFJ(AsyncGeneratorAwaitResolveClosure, 1, kValue)                            \
   TFJ(AsyncGeneratorAwaitRejectClosure, 1, kValue)                             \
+  TFJ(AsyncGeneratorReturnResolveClosure, 1, kValue)                           \
+  TFJ(AsyncGeneratorReturnRejectClosure, 1, kValue)                            \
                                                                                \
   /* Async-from-Sync Iterator */                                               \
                                                                                \

src/code-stub-assembler.cc

@@ -1128,6 +1128,15 @@ Node* CodeStubAssembler::DoesntHaveInstanceType(Node* object,
   return Word32NotEqual(LoadInstanceType(object), Int32Constant(instance_type));
 }
 
+Node* CodeStubAssembler::TaggedDoesntHaveInstanceType(Node* any_tagged,
+                                                      InstanceType type) {
+  /* return Phi <TaggedIsSmi(val), DoesntHaveInstanceType(val, type)> */
+  Node* tagged_is_smi = TaggedIsSmi(any_tagged);
+  return Select(tagged_is_smi, [=]() { return tagged_is_smi; },
+                [=]() { return DoesntHaveInstanceType(any_tagged, type); },
+                MachineRepresentation::kBit);
+}
+
 Node* CodeStubAssembler::LoadProperties(Node* object) {
   return LoadObjectField(object, JSObject::kPropertiesOrHashOffset);
 }

src/code-stub-assembler.h

@@ -393,6 +393,7 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
   // Compare the instance the type of the object against the provided one.
   Node* HasInstanceType(Node* object, InstanceType type);
   Node* DoesntHaveInstanceType(Node* object, InstanceType type);
+  Node* TaggedDoesntHaveInstanceType(Node* any_tagged, InstanceType type);
   // Load the properties backing store of a JSObject.
   Node* LoadProperties(Node* object);
   // Load the elements backing store of a JSObject.

src/contexts.h

@@ -217,6 +217,10 @@ enum ContextLookupFlags {
     async_generator_await_reject_shared_fun)                                   \
   V(ASYNC_GENERATOR_AWAIT_RESOLVE_SHARED_FUN, SharedFunctionInfo,              \
     async_generator_await_resolve_shared_fun)                                  \
+  V(ASYNC_GENERATOR_RETURN_RESOLVE_SHARED_FUN, SharedFunctionInfo,             \
+    async_generator_return_resolve_shared_fun)                                 \
+  V(ASYNC_GENERATOR_RETURN_REJECT_SHARED_FUN, SharedFunctionInfo,              \
+    async_generator_return_reject_shared_fun)                                  \
   V(ATOMICS_OBJECT, JSObject, atomics_object)                                  \
   V(BOOLEAN_FUNCTION_INDEX, JSFunction, boolean_function)                      \
   V(BOUND_FUNCTION_WITH_CONSTRUCTOR_MAP_INDEX, Map,                            \

src/interpreter/bytecode-generator.cc

@@ -1579,7 +1579,7 @@ void BytecodeGenerator::VisitTryCatchStatement(TryCatchStatement* stmt) {
 
 void BytecodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
   // We can't know whether the finally block will override ("catch") an
-  // exception thrown in the try bblock, so we just adopt the outer prediction.
+  // exception thrown in the try block, so we just adopt the outer prediction.
   TryFinallyBuilder try_control_builder(builder(), catch_prediction());
 
   // We keep a record of all paths that enter the finally-block to be able to
@@ -2662,6 +2662,7 @@ void BytecodeGenerator::VisitYield(Yield* expr) {
     builder()->LoadAccumulatorWithRegister(input);
     if (IsAsyncGeneratorFunction(function_kind())) {
       // Async generator methods will produce the iter result object.
+      BuildAwait(expr->await_return_value_suspend_id());
       execution_control()->AsyncReturnAccumulator();
     } else {
       execution_control()->ReturnAccumulator();
@@ -2912,7 +2913,7 @@ void BytecodeGenerator::VisitYieldStar(YieldStar* expr) {
   builder()->LoadAccumulatorWithRegister(output_value);
 }
 
-void BytecodeGenerator::VisitAwait(Await* expr) {
+void BytecodeGenerator::BuildAwait(int suspend_id) {
   // Rather than HandlerTable::UNCAUGHT, async functions use
   // HandlerTable::ASYNC_AWAIT to communicate that top-level exceptions are
   // transformed into promise rejections. This is necessary to prevent emitting
@@ -2921,8 +2922,6 @@ void BytecodeGenerator::VisitAwait(Await* expr) {
   // HandlerTable::UNCAUGHT.
   DCHECK(catch_prediction() != HandlerTable::UNCAUGHT);
 
-  builder()->SetExpressionPosition(expr);
-  VisitForAccumulatorValue(expr->expression());
   {
     // Await(operand) and suspend.
     RegisterAllocationScope register_scope(this);
@@ -2959,7 +2958,7 @@ void BytecodeGenerator::VisitAwait(Await* expr) {
     builder()->CallJSRuntime(await_builtin_context_index, args);
   }
 
-  BuildSuspendPoint(expr->suspend_id());
+  BuildSuspendPoint(suspend_id);
 
   Register input = register_allocator()->NewRegister();
   Register resume_mode = register_allocator()->NewRegister();
@@ -2977,14 +2976,19 @@ void BytecodeGenerator::VisitAwait(Await* expr) {
   // Resume with "throw" completion (rethrow the received value).
   // TODO(leszeks): Add a debug-only check that the accumulator is
   // JSGeneratorObject::kThrow.
-  builder()->SetExpressionPosition(expr);
   builder()->LoadAccumulatorWithRegister(input).ReThrow();
 
   // Resume with next.
   builder()->Bind(&resume_next);
+  builder()->LoadAccumulatorWithRegister(input);
+}
+
+void BytecodeGenerator::VisitAwait(Await* expr) {
+  builder()->SetExpressionPosition(expr);
+  VisitForAccumulatorValue(expr->expression());
+  BuildAwait(expr->suspend_id());
   BuildIncrementBlockCoverageCounterIfEnabled(expr,
                                               SourceRangeKind::kContinuation);
-  builder()->LoadAccumulatorWithRegister(input);
 }
 
 void BytecodeGenerator::VisitThrow(Throw* expr) {

src/interpreter/bytecode-generator.h

@@ -140,7 +140,8 @@ class BytecodeGenerator final : public AstVisitor<BytecodeGenerator> {
   void BuildGeneratorPrologue();
   void BuildSuspendPoint(int suspend_id);
 
-  void BuildAbruptResume(Suspend* expr);
+  void BuildAwait(int suspend_id);
+
   void BuildGetIterator(Expression* iterable, IteratorType hint,
                         FeedbackSlot load_slot, FeedbackSlot call_slot,
                         FeedbackSlot async_load_slot,

src/parsing/parser-base.h

@@ -1341,9 +1341,17 @@ class ParserBase {
   // depending on the current function type.
   inline StatementT BuildReturnStatement(ExpressionT expr, int pos,
                                          int end_pos = kNoSourcePosition) {
-    return is_async_function()
-               ? factory()->NewAsyncReturnStatement(expr, pos, end_pos)
-               : factory()->NewReturnStatement(expr, pos, end_pos);
+    if (impl()->IsEmptyExpression(expr)) {
+      expr = impl()->GetLiteralUndefined(kNoSourcePosition);
+    } else if (is_async_generator()) {
+      // In async generators, if there is an explicit operand to the return
+      // statement, await the operand.
+      expr = factory()->NewAwait(expr, kNoSourcePosition);
+    }
+    if (is_async_function()) {
+      return factory()->NewAsyncReturnStatement(expr, pos, end_pos);
+    }
+    return factory()->NewReturnStatement(expr, pos, end_pos);
   }
 
   // Validation per ES6 object literals.
@@ -2943,6 +2951,12 @@ typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseYieldExpression(
     return impl()->RewriteYieldStar(expression, pos);
   }
 
+  if (is_async_generator()) {
+    // Per https://github.com/tc39/proposal-async-iteration/pull/102, the yield
+    // operand must be Await-ed in async generators.
+    expression = factory()->NewAwait(expression, pos);
+  }
+
   // Hackily disambiguate o from o.next and o [Symbol.iterator]().
   // TODO(verwaest): Come up with a better solution.
   ExpressionT yield =
@@ -5221,8 +5235,6 @@ typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseReturnStatement(
       tok == Token::RBRACE || tok == Token::EOS) {
     if (IsDerivedConstructor(function_state_->kind())) {
       return_value = impl()->ThisExpression(loc.beg_pos);
-    } else {
-      return_value = impl()->GetLiteralUndefined(position());
     }
   } else {
     return_value = ParseExpression(true, CHECK_OK);

src/parsing/parser.cc

@@ -4526,11 +4526,14 @@ Expression* Parser::RewriteYieldStar(Expression* iterable, int pos) {
       VariableProxy* output_proxy = factory()->NewVariableProxy(var_output);
       Expression* literal = factory()->NewStringLiteral(
           ast_value_factory()->value_string(), nopos);
-      Assignment* assign = factory()->NewAssignment(
-          Token::ASSIGN, output_proxy,
+
+      Expression* value = factory()->NewAwait(
           factory()->NewProperty(factory()->NewVariableProxy(var_output),
                                  literal, nopos),
           nopos);
+
+      Assignment* assign =
+          factory()->NewAssignment(Token::ASSIGN, output_proxy, value, nopos);
       loop_body->statements()->Add(
           factory()->NewExpressionStatement(assign, nopos), zone());
     }

test/cctest/interpreter/bytecode_expectations/AsyncGenerators.golden

@@ -14,7 +14,7 @@ snippet: "
 "
 frame size: 10
 parameter count: 1
-bytecode array length: 216
+bytecode array length: 304
 bytecodes: [
                 B(Mov), R(new_target), R(1),
                 B(Ldar), R(new_target),
@@ -23,7 +23,7 @@ bytecodes: [
                 B(PushContext), R(3),
                 B(RestoreGeneratorState), R(1),
                 B(Star), R(2),
-                B(SwitchOnSmiNoFeedback), U8(0), U8(1), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(0), U8(3), I8(0),
                 B(LdaSmi), I8(81),
                 B(Star), R(3),
                 B(CallRuntime), U16(Runtime::kAbort), R(3), U8(1),
@@ -46,22 +46,56 @@ bytecodes: [
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(1), U8(1),
                 B(Star), R(7),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(1), U8(1),
-                B(SwitchOnSmiNoFeedback), U8(1), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(3), U8(2), I8(0),
                 B(Ldar), R(7),
   /*   17 E> */ B(Throw),
+                B(Mov), R(1), R(8),
+                B(Mov), R(7), R(9),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(8), U8(2),
+                B(SuspendGenerator), R(1), R(0), U8(8), U8(1),
+  /*   22 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(1), R(0), U8(8),
+                B(LdaSmi), I8(-2),
+                B(Star), R(2),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(1), U8(1),
+                B(Star), R(8),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(1), U8(1),
+                B(Star), R(9),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(9),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(8),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(3),
-                B(Mov), R(7), R(4),
-                B(Jump), U8(61),
+                B(Mov), R(8), R(4),
+                B(Jump), U8(105),
                 B(LdaUndefined),
-                B(Star), R(4),
+                B(Star), R(8),
+                B(Mov), R(1), R(7),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(7), U8(2),
+                B(SuspendGenerator), R(1), R(0), U8(7), U8(2),
+  /*   22 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(1), R(0), U8(7),
+                B(LdaSmi), I8(-2),
+                B(Star), R(2),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(1), U8(1),
+                B(Star), R(7),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(1), U8(1),
+                B(Star), R(8),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(8),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(7),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(3),
+                B(Mov), R(7), R(4),
                 B(Jump), U8(53),
                 B(Jump), U8(39),
                 B(Star), R(7),
                 B(Ldar), R(closure),
-                B(CreateCatchContext), R(7), U8(3), U8(4),
+                B(CreateCatchContext), R(7), U8(5), U8(6),
                 B(Star), R(6),
                 B(LdaTheHole),
                 B(SetPendingMessage),
@@ -89,7 +123,7 @@ bytecodes: [
                 B(Ldar), R(5),
                 B(SetPendingMessage),
                 B(Ldar), R(3),
-                B(SwitchOnSmiNoFeedback), U8(5), U8(3), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(7), U8(3), I8(0),
                 B(Jump), U8(34),
                 B(LdaTrue),
                 B(Star), R(8),
@@ -113,7 +147,9 @@ bytecodes: [
 ]
 constant pool: [
   Smi [46],
-  Smi [15],
+  Smi [87],
+  Smi [139],
+  Smi [59],
   Smi [7],
   ONE_BYTE_INTERNALIZED_STRING_TYPE [".catch"],
   FIXED_ARRAY_TYPE,
@@ -122,8 +158,8 @@ constant pool: [
   Smi [35],
 ]
 handlers: [
-  [52, 143, 149],
-  [55, 104, 106],
+  [52, 231, 237],
+  [55, 192, 194],
 ]
 
 ---
@@ -133,7 +169,7 @@ snippet: "
 "
 frame size: 10
 parameter count: 1
-bytecode array length: 269
+bytecode array length: 446
 bytecodes: [
                 B(Mov), R(new_target), R(1),
                 B(Ldar), R(new_target),
@@ -142,7 +178,7 @@ bytecodes: [
                 B(PushContext), R(3),
                 B(RestoreGeneratorState), R(1),
                 B(Star), R(2),
-                B(SwitchOnSmiNoFeedback), U8(0), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(0), U8(6), I8(0),
                 B(LdaSmi), I8(81),
                 B(Star), R(3),
                 B(CallRuntime), U16(Runtime::kAbort), R(3), U8(1),
@@ -165,20 +201,55 @@ bytecodes: [
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(1), U8(1),
                 B(Star), R(7),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(1), U8(1),
-                B(SwitchOnSmiNoFeedback), U8(2), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(6), U8(2), I8(0),
                 B(Ldar), R(7),
   /*   17 E> */ B(Throw),
+                B(Mov), R(1), R(8),
+                B(Mov), R(7), R(9),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(8), U8(2),
+                B(SuspendGenerator), R(1), R(0), U8(8), U8(1),
+  /*   31 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(1), R(0), U8(8),
+                B(LdaSmi), I8(-2),
+                B(Star), R(2),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(1), U8(1),
+                B(Star), R(8),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(1), U8(1),
+                B(Star), R(9),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(9),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(8),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(3),
-                B(Mov), R(7), R(4),
-                B(Jump), U8(114),
+                B(Mov), R(8), R(4),
+                B(Jump), U8(247),
   /*   22 S> */ B(LdaSmi), I8(42),
+                B(Star), R(8),
+                B(Mov), R(1), R(7),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(7), U8(2),
+                B(SuspendGenerator), R(1), R(0), U8(7), U8(4),
+  /*   31 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(1), R(0), U8(7),
+                B(LdaSmi), I8(-2),
+                B(Star), R(2),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(1), U8(1),
+                B(Star), R(7),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(1), U8(1),
+                B(Star), R(8),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(8),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(7),
+                B(ReThrow),
+                B(Ldar), R(7),
                 B(Star), R(8),
                 B(LdaFalse),
                 B(Star), R(9),
                 B(Mov), R(1), R(7),
                 B(InvokeIntrinsic), U8(Runtime::k_AsyncGeneratorResolve), R(7), U8(3),
-                B(SuspendGenerator), R(1), R(0), U8(7), U8(1),
+                B(SuspendGenerator), R(1), R(0), U8(7), U8(2),
   /*   31 S> */ B(Return),
                 B(RestoreGeneratorRegisters), R(1), R(0), U8(7),
                 B(LdaSmi), I8(-2),
@@ -186,22 +257,56 @@ bytecodes: [
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(1), U8(1),
                 B(Star), R(7),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(1), U8(1),
-                B(SwitchOnSmiNoFeedback), U8(4), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(8), U8(2), I8(0),
                 B(Ldar), R(7),
   /*   22 E> */ B(Throw),
+                B(Mov), R(1), R(8),
+                B(Mov), R(7), R(9),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(8), U8(2),
+                B(SuspendGenerator), R(1), R(0), U8(8), U8(3),
+  /*   31 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(1), R(0), U8(8),
+                B(LdaSmi), I8(-2),
+                B(Star), R(2),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(1), U8(1),
+                B(Star), R(8),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(1), U8(1),
+                B(Star), R(9),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(9),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(8),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(3),
-                B(Mov), R(7), R(4),
-                B(Jump), U8(61),
+                B(Mov), R(8), R(4),
+                B(Jump), U8(105),
                 B(LdaUndefined),
-                B(Star), R(4),
+                B(Star), R(8),
+                B(Mov), R(1), R(7),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(7), U8(2),
+                B(SuspendGenerator), R(1), R(0), U8(7), U8(5),
+  /*   31 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(1), R(0), U8(7),
+                B(LdaSmi), I8(-2),
+                B(Star), R(2),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(1), U8(1),
+                B(Star), R(7),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(1), U8(1),
+                B(Star), R(8),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(8),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(7),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(3),
+                B(Mov), R(7), R(4),
                 B(Jump), U8(53),
                 B(Jump), U8(39),
                 B(Star), R(7),
                 B(Ldar), R(closure),
-                B(CreateCatchContext), R(7), U8(6), U8(7),
+                B(CreateCatchContext), R(7), U8(10), U8(11),
                 B(Star), R(6),
                 B(LdaTheHole),
                 B(SetPendingMessage),
@@ -229,7 +334,7 @@ bytecodes: [
                 B(Ldar), R(5),
                 B(SetPendingMessage),
                 B(Ldar), R(3),
-                B(SwitchOnSmiNoFeedback), U8(8), U8(3), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(12), U8(3), I8(0),
                 B(Jump), U8(34),
                 B(LdaTrue),
                 B(Star), R(8),
@@ -253,10 +358,14 @@ bytecodes: [
 ]
 constant pool: [
   Smi [46],
-  Smi [99],
-  Smi [15],
+  Smi [87],
+  Smi [188],
+  Smi [229],
+  Smi [140],
+  Smi [281],
+  Smi [59],
   Smi [7],
-  Smi [15],
+  Smi [59],
   Smi [7],
   ONE_BYTE_INTERNALIZED_STRING_TYPE [".catch"],
   FIXED_ARRAY_TYPE,
@@ -265,8 +374,8 @@ constant pool: [
   Smi [35],
 ]
 handlers: [
-  [52, 196, 202],
-  [55, 157, 159],
+  [52, 373, 379],
+  [55, 334, 336],
 ]
 
 ---
@@ -276,7 +385,7 @@ snippet: "
 "
 frame size: 23
 parameter count: 1
-bytecode array length: 565
+bytecode array length: 742
 bytecodes: [
                 B(Mov), R(new_target), R(10),
                 B(Ldar), R(new_target),
@@ -285,7 +394,7 @@ bytecodes: [
                 B(PushContext), R(12),
                 B(RestoreGeneratorState), R(10),
                 B(Star), R(11),
-                B(SwitchOnSmiNoFeedback), U8(0), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(0), U8(6), I8(0),
                 B(LdaSmi), I8(81),
                 B(Star), R(12),
                 B(CallRuntime), U16(Runtime::kAbort), R(12), U8(1),
@@ -308,36 +417,53 @@ bytecodes: [
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(10), U8(1),
                 B(Star), R(16),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(10), U8(1),
-                B(SwitchOnSmiNoFeedback), U8(2), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(6), U8(2), I8(0),
                 B(Ldar), R(16),
   /*   17 E> */ B(Throw),
+                B(Mov), R(10), R(17),
+                B(Mov), R(16), R(18),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(17), U8(2),
+                B(SuspendGenerator), R(10), R(0), U8(17), U8(1),
+  /*   50 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(10), R(0), U8(17),
+                B(LdaSmi), I8(-2),
+                B(Star), R(11),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(10), U8(1),
+                B(Star), R(17),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(10), U8(1),
+                B(Star), R(18),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(18),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(17),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(12),
-                B(Mov), R(16), R(13),
-                B(JumpConstant), U8(20),
+                B(Mov), R(17), R(13),
+                B(JumpConstant), U8(26),
                 B(LdaTheHole),
                 B(Star), R(1),
                 B(LdaZero),
                 B(Star), R(6),
                 B(Mov), R(context), R(18),
                 B(Mov), R(context), R(19),
-  /*   36 S> */ B(CreateArrayLiteral), U8(4), U8(0), U8(37),
+  /*   36 S> */ B(CreateArrayLiteral), U8(8), U8(0), U8(37),
                 B(Star), R(20),
-                B(LdaNamedProperty), R(20), U8(5), U8(1),
+                B(LdaNamedProperty), R(20), U8(9), U8(1),
                 B(Star), R(21),
                 B(CallProperty0), R(21), R(20), U8(3),
                 B(JumpIfJSReceiver), U8(7),
                 B(CallRuntime), U16(Runtime::kThrowSymbolIteratorInvalid), R(0), U8(0),
                 B(Star), R(4),
                 B(Ldar), R(11),
-                B(SwitchOnSmiNoFeedback), U8(6), U8(1), I8(1),
+                B(SwitchOnSmiNoFeedback), U8(10), U8(3), I8(2),
                 B(LdaSmi), I8(-2),
   /*   36 E> */ B(TestEqualStrictNoFeedback), R(11),
                 B(JumpIfTrue), U8(11),
                 B(LdaSmi), I8(81),
                 B(Star), R(20),
                 B(CallRuntime), U16(Runtime::kAbort), R(20), U8(1),
-  /*   31 S> */ B(LdaNamedProperty), R(4), U8(7), U8(7),
+  /*   31 S> */ B(LdaNamedProperty), R(4), U8(13), U8(7),
                 B(Star), R(20),
                 B(CallProperty0), R(20), R(4), U8(5),
                 B(Star), R(5),
@@ -345,21 +471,39 @@ bytecodes: [
                 B(ToBooleanLogicalNot),
                 B(JumpIfFalse), U8(7),
                 B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(5), U8(1),
-                B(LdaNamedProperty), R(5), U8(8), U8(9),
-                B(JumpIfToBooleanTrue), U8(77),
-                B(LdaNamedProperty), R(5), U8(9), U8(11),
+                B(LdaNamedProperty), R(5), U8(14), U8(9),
+                B(JumpIfToBooleanTrue), U8(166),
+                B(LdaNamedProperty), R(5), U8(15), U8(11),
                 B(Star), R(7),
                 B(LdaSmi), I8(2),
                 B(Star), R(6),
                 B(Mov), R(7), R(3),
   /*   22 E> */ B(StackCheck),
                 B(Mov), R(3), R(0),
-  /*   42 S> */ B(LdaFalse),
+  /*   42 S> */ B(Mov), R(10), R(20),
+                B(Mov), R(0), R(21),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(20), U8(2),
+                B(SuspendGenerator), R(10), R(0), U8(20), U8(4),
+  /*   50 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(10), R(0), U8(20),
+                B(LdaSmi), I8(-2),
+                B(Star), R(11),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(10), U8(1),
+                B(Star), R(20),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(10), U8(1),
+                B(Star), R(21),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(21),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(20),
+                B(ReThrow),
+                B(Ldar), R(20),
+                B(Star), R(21),
+                B(LdaFalse),
                 B(Star), R(22),
                 B(Mov), R(10), R(20),
-                B(Mov), R(0), R(21),
                 B(InvokeIntrinsic), U8(Runtime::k_AsyncGeneratorResolve), R(20), U8(3),
-                B(SuspendGenerator), R(10), R(0), U8(20), U8(1),
+                B(SuspendGenerator), R(10), R(0), U8(20), U8(2),
   /*   50 S> */ B(Return),
                 B(RestoreGeneratorRegisters), R(10), R(0), U8(20),
                 B(LdaSmi), I8(-2),
@@ -367,20 +511,37 @@ bytecodes: [
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(10), U8(1),
                 B(Star), R(20),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(10), U8(1),
-                B(SwitchOnSmiNoFeedback), U8(10), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(16), U8(2), I8(0),
                 B(Ldar), R(20),
   /*   42 E> */ B(Throw),
+                B(Mov), R(10), R(21),
+                B(Mov), R(20), R(22),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(21), U8(2),
+                B(SuspendGenerator), R(10), R(0), U8(21), U8(3),
+  /*   50 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(10), R(0), U8(21),
+                B(LdaSmi), I8(-2),
+                B(Star), R(11),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(10), U8(1),
+                B(Star), R(21),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(10), U8(1),
+                B(Star), R(22),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(22),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(21),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(16),
-                B(Mov), R(20), R(17),
+                B(Mov), R(21), R(17),
                 B(Jump), U8(60),
                 B(LdaZero),
                 B(Star), R(6),
-                B(JumpLoop), U8(123), I8(0),
+                B(JumpLoop), U8(212), I8(0),
                 B(Jump), U8(40),
                 B(Star), R(20),
                 B(Ldar), R(closure),
-                B(CreateCatchContext), R(20), U8(12), U8(13),
+                B(CreateCatchContext), R(20), U8(18), U8(19),
                 B(Star), R(19),
                 B(LdaTheHole),
                 B(SetPendingMessage),
@@ -407,7 +568,7 @@ bytecodes: [
                 B(LdaZero),
                 B(TestEqualStrict), R(6), U8(14),
                 B(JumpIfTrue), U8(104),
-                B(LdaNamedProperty), R(4), U8(14), U8(15),
+                B(LdaNamedProperty), R(4), U8(20), U8(15),
                 B(Star), R(8),
                 B(TestUndetectable),
                 B(JumpIfFalse), U8(4),
@@ -421,7 +582,7 @@ bytecodes: [
                 B(Jump), U8(18),
                 B(Wide), B(LdaSmi), I16(134),
                 B(Star), R(19),
-                B(LdaConstant), U8(15),
+                B(LdaConstant), U8(21),
                 B(Star), R(20),
                 B(CallRuntime), U16(Runtime::kNewTypeError), R(19), U8(2),
                 B(Throw),
@@ -432,7 +593,7 @@ bytecodes: [
                 B(Jump), U8(20),
                 B(Star), R(20),
                 B(Ldar), R(closure),
-                B(CreateCatchContext), R(20), U8(12), U8(16),
+                B(CreateCatchContext), R(20), U8(18), U8(22),
                 B(Star), R(19),
                 B(LdaTheHole),
                 B(SetPendingMessage),
@@ -451,23 +612,40 @@ bytecodes: [
                 B(Ldar), R(18),
                 B(SetPendingMessage),
                 B(Ldar), R(16),
-                B(SwitchOnSmiNoFeedback), U8(17), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(23), U8(2), I8(0),
                 B(Jump), U8(13),
                 B(LdaZero),
                 B(Star), R(12),
                 B(Mov), R(17), R(13),
-                B(Jump), U8(64),
+                B(Jump), U8(108),
                 B(Ldar), R(17),
                 B(ReThrow),
                 B(LdaUndefined),
-                B(Star), R(13),
+                B(Star), R(17),
+                B(Mov), R(10), R(16),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(16), U8(2),
+                B(SuspendGenerator), R(10), R(0), U8(16), U8(5),
+  /*   50 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(10), R(0), U8(16),
+                B(LdaSmi), I8(-2),
+                B(Star), R(11),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(10), U8(1),
+                B(Star), R(16),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(10), U8(1),
+                B(Star), R(17),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(17),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(16),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(12),
+                B(Mov), R(16), R(13),
                 B(Jump), U8(53),
                 B(Jump), U8(39),
                 B(Star), R(16),
                 B(Ldar), R(closure),
-                B(CreateCatchContext), R(16), U8(12), U8(19),
+                B(CreateCatchContext), R(16), U8(18), U8(25),
                 B(Star), R(15),
                 B(LdaTheHole),
                 B(SetPendingMessage),
@@ -495,7 +673,7 @@ bytecodes: [
                 B(Ldar), R(14),
                 B(SetPendingMessage),
                 B(Ldar), R(12),
-                B(SwitchOnSmiNoFeedback), U8(21), U8(3), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(27), U8(3), I8(0),
                 B(Jump), U8(34),
                 B(LdaTrue),
                 B(Star), R(17),
@@ -519,16 +697,22 @@ bytecodes: [
 ]
 constant pool: [
   Smi [46],
-  Smi [116],
-  Smi [15],
+  Smi [87],
+  Smi [160],
+  Smi [160],
+  Smi [160],
+  Smi [577],
+  Smi [59],
   Smi [7],
   TUPLE2_TYPE,
   SYMBOL_TYPE,
-  Smi [85],
+  Smi [130],
+  Smi [171],
+  Smi [82],
   ONE_BYTE_INTERNALIZED_STRING_TYPE ["next"],
   ONE_BYTE_INTERNALIZED_STRING_TYPE ["done"],
   ONE_BYTE_INTERNALIZED_STRING_TYPE ["value"],
-  Smi [15],
+  Smi [59],
   Smi [7],
   ONE_BYTE_INTERNALIZED_STRING_TYPE [".catch"],
   FIXED_ARRAY_TYPE,
@@ -538,17 +722,17 @@ constant pool: [
   Smi [6],
   Smi [14],
   FIXED_ARRAY_TYPE,
-  Smi [410],
+  Smi [543],
   Smi [6],
   Smi [28],
   Smi [35],
 ]
 handlers: [
-  [52, 492, 498],
-  [55, 453, 455],
-  [105, 299, 305],
-  [108, 259, 261],
-  [366, 376, 378],
+  [52, 669, 675],
+  [55, 630, 632],
+  [149, 432, 438],
+  [152, 392, 394],
+  [499, 509, 511],
 ]
 
 ---
@@ -559,7 +743,7 @@ snippet: "
 "
 frame size: 19
 parameter count: 1
-bytecode array length: 864
+bytecode array length: 1084
 bytecodes: [
                 B(Mov), R(new_target), R(9),
                 B(Ldar), R(new_target),
@@ -568,7 +752,7 @@ bytecodes: [
                 B(PushContext), R(11),
                 B(RestoreGeneratorState), R(9),
                 B(Star), R(10),
-                B(SwitchOnSmiNoFeedback), U8(0), U8(7), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(0), U8(13), I8(0),
                 B(LdaSmi), I8(81),
                 B(Star), R(11),
                 B(CallRuntime), U16(Runtime::kAbort), R(11), U8(1),
@@ -591,38 +775,55 @@ bytecodes: [
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(9), U8(1),
                 B(Star), R(15),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(9), U8(1),
-                B(SwitchOnSmiNoFeedback), U8(7), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(13), U8(2), I8(0),
                 B(Ldar), R(15),
   /*   44 E> */ B(Throw),
+                B(Mov), R(9), R(16),
+                B(Mov), R(15), R(17),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(16), U8(2),
+                B(SuspendGenerator), R(9), R(0), U8(16), U8(1),
+  /*   60 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(9), R(0), U8(16),
+                B(LdaSmi), I8(-2),
+                B(Star), R(10),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(9), U8(1),
+                B(Star), R(16),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(9), U8(1),
+                B(Star), R(17),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(17),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(16),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(11),
-                B(Mov), R(15), R(12),
-                B(JumpConstant), U8(30),
+                B(Mov), R(16), R(12),
+                B(JumpConstant), U8(39),
   /*   49 S> */ B(LdaUndefined),
                 B(Star), R(1),
                 B(LdaZero),
                 B(Star), R(2),
                 B(LdaUndefined),
                 B(Star), R(3),
-                B(LdaGlobal), U8(9), U8(2),
+                B(LdaGlobal), U8(15), U8(2),
                 B(Star), R(17),
   /*   56 E> */ B(CallUndefinedReceiver0), R(17), U8(0),
                 B(Star), R(15),
-                B(LdaNamedProperty), R(15), U8(10), U8(8),
+                B(LdaNamedProperty), R(15), U8(16), U8(8),
                 B(JumpIfUndefined), U8(17),
                 B(JumpIfNull), U8(15),
                 B(Star), R(16),
                 B(CallProperty0), R(16), R(15), U8(10),
                 B(JumpIfJSReceiver), U8(23),
                 B(CallRuntime), U16(Runtime::kThrowSymbolAsyncIteratorInvalid), R(0), U8(0),
-                B(LdaNamedProperty), R(15), U8(11), U8(4),
+                B(LdaNamedProperty), R(15), U8(17), U8(4),
                 B(Star), R(16),
                 B(CallProperty0), R(16), R(15), U8(6),
                 B(Star), R(16),
                 B(InvokeIntrinsic), U8(Runtime::k_CreateAsyncFromSyncIterator), R(16), U8(1),
                 B(Star), R(4),
                 B(Ldar), R(10),
-                B(SwitchOnSmiNoFeedback), U8(12), U8(6), I8(1),
+                B(SwitchOnSmiNoFeedback), U8(18), U8(9), I8(2),
                 B(LdaSmi), I8(-2),
                 B(TestEqualStrictNoFeedback), R(10),
                 B(JumpIfTrue), U8(11),
@@ -639,15 +840,15 @@ bytecodes: [
                 B(JumpIfTrue), U8(83),
                 B(LdaSmi), I8(2),
                 B(TestEqualStrict), R(15), U8(29),
-                B(JumpIfTrue), U8(167),
-                B(JumpConstant), U8(24),
-                B(LdaNamedProperty), R(4), U8(18), U8(14),
+                B(JumpIfTrue), U8(211),
+                B(JumpConstant), U8(33),
+                B(LdaNamedProperty), R(4), U8(27), U8(14),
                 B(Star), R(16),
                 B(CallProperty1), R(16), R(4), R(1), U8(12),
                 B(Star), R(17),
                 B(Mov), R(9), R(16),
                 B(CallJSRuntime), U8(%async_generator_await_uncaught), R(16), U8(2),
-                B(SuspendGenerator), R(9), R(0), U8(16), U8(1),
+                B(SuspendGenerator), R(9), R(0), U8(16), U8(2),
   /*   60 S> */ B(Return),
                 B(RestoreGeneratorRegisters), R(9), R(0), U8(16),
                 B(LdaSmi), I8(-2),
@@ -666,15 +867,32 @@ bytecodes: [
                 B(JumpIfToBooleanFalse), U8(4),
                 B(Jump), U8(7),
                 B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(3), U8(1),
-                B(JumpConstant), U8(25),
-                B(LdaNamedProperty), R(4), U8(19), U8(17),
+                B(JumpConstant), U8(34),
+                B(LdaNamedProperty), R(4), U8(28), U8(17),
                 B(Star), R(3),
                 B(TestUndetectable),
-                B(JumpIfFalse), U8(10),
+                B(JumpIfFalse), U8(54),
+                B(Mov), R(9), R(16),
+                B(Mov), R(1), R(17),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(16), U8(2),
+                B(SuspendGenerator), R(9), R(0), U8(16), U8(3),
+  /*   60 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(9), R(0), U8(16),
+                B(LdaSmi), I8(-2),
+                B(Star), R(10),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(9), U8(1),
+                B(Star), R(16),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(9), U8(1),
+                B(Star), R(17),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(17),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(16),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(11),
-                B(Mov), R(1), R(12),
-                B(JumpConstant), U8(31),
+                B(Mov), R(16), R(12),
+                B(JumpConstant), U8(40),
                 B(Mov), R(3), R(16),
                 B(Mov), R(4), R(17),
                 B(Mov), R(1), R(18),
@@ -682,7 +900,7 @@ bytecodes: [
                 B(Star), R(17),
                 B(Mov), R(9), R(16),
                 B(CallJSRuntime), U8(%async_generator_await_uncaught), R(16), U8(2),
-                B(SuspendGenerator), R(9), R(0), U8(16), U8(2),
+                B(SuspendGenerator), R(9), R(0), U8(16), U8(4),
   /*   60 S> */ B(Return),
                 B(RestoreGeneratorRegisters), R(9), R(0), U8(16),
                 B(LdaSmi), I8(-2),
@@ -701,12 +919,12 @@ bytecodes: [
                 B(JumpIfToBooleanFalse), U8(4),
                 B(Jump), U8(7),
                 B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(3), U8(1),
-                B(JumpConstant), U8(26),
-                B(LdaNamedProperty), R(4), U8(20), U8(21),
+                B(JumpConstant), U8(35),
+                B(LdaNamedProperty), R(4), U8(29), U8(21),
                 B(Star), R(5),
                 B(TestUndetectable),
                 B(JumpIfFalse), U8(212),
-                B(LdaNamedProperty), R(4), U8(19), U8(24),
+                B(LdaNamedProperty), R(4), U8(28), U8(24),
                 B(Star), R(6),
                 B(TestUndetectable),
                 B(JumpIfFalse), U8(4),
@@ -722,7 +940,7 @@ bytecodes: [
                 B(Jump), U8(18),
                 B(Wide), B(LdaSmi), I16(134),
                 B(Star), R(16),
-                B(LdaConstant), U8(21),
+                B(LdaConstant), U8(30),
                 B(Star), R(17),
                 B(CallRuntime), U16(Runtime::kNewTypeError), R(16), U8(2),
                 B(Throw),
@@ -733,7 +951,7 @@ bytecodes: [
                 B(Star), R(18),
                 B(Mov), R(9), R(17),
                 B(CallJSRuntime), U8(%async_generator_await_caught), R(17), U8(2),
-                B(SuspendGenerator), R(9), R(0), U8(17), U8(3),
+                B(SuspendGenerator), R(9), R(0), U8(17), U8(5),
   /*   60 S> */ B(Return),
                 B(RestoreGeneratorRegisters), R(9), R(0), U8(17),
                 B(LdaSmi), I8(-2),
@@ -751,7 +969,7 @@ bytecodes: [
                 B(Jump), U8(20),
                 B(Star), R(17),
                 B(Ldar), R(closure),
-                B(CreateCatchContext), R(17), U8(22), U8(23),
+                B(CreateCatchContext), R(17), U8(31), U8(32),
                 B(Star), R(16),
                 B(LdaTheHole),
                 B(SetPendingMessage),
@@ -765,7 +983,7 @@ bytecodes: [
                 B(Star), R(17),
                 B(Mov), R(9), R(16),
                 B(CallJSRuntime), U8(%async_generator_await_uncaught), R(16), U8(2),
-                B(SuspendGenerator), R(9), R(0), U8(16), U8(4),
+                B(SuspendGenerator), R(9), R(0), U8(16), U8(6),
   /*   60 S> */ B(Return),
                 B(RestoreGeneratorRegisters), R(9), R(0), U8(16),
                 B(LdaSmi), I8(-2),
@@ -786,7 +1004,7 @@ bytecodes: [
                 B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(7), U8(1),
                 B(Wide), B(LdaSmi), I16(148),
                 B(Star), R(16),
-                B(LdaConstant), U8(21),
+                B(LdaConstant), U8(30),
                 B(Star), R(17),
                 B(CallRuntime), U16(Runtime::kNewTypeError), R(16), U8(2),
                 B(Throw),
@@ -797,7 +1015,7 @@ bytecodes: [
                 B(Star), R(17),
                 B(Mov), R(9), R(16),
                 B(CallJSRuntime), U8(%async_generator_await_uncaught), R(16), U8(2),
-                B(SuspendGenerator), R(9), R(0), U8(16), U8(5),
+                B(SuspendGenerator), R(9), R(0), U8(16), U8(7),
   /*   60 S> */ B(Return),
                 B(RestoreGeneratorRegisters), R(9), R(0), U8(16),
                 B(LdaSmi), I8(-2),
@@ -817,17 +1035,34 @@ bytecodes: [
                 B(Jump), U8(7),
                 B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(3), U8(1),
                 B(Jump), U8(2),
-                B(LdaNamedProperty), R(3), U8(27), U8(30),
+                B(LdaNamedProperty), R(3), U8(36), U8(30),
                 B(JumpIfToBooleanFalse), U8(4),
-                B(Jump), U8(57),
-                B(LdaNamedProperty), R(3), U8(28), U8(32),
-                B(Star), R(3),
+                B(Jump), U8(101),
+                B(LdaNamedProperty), R(3), U8(37), U8(32),
+                B(Star), R(16),
+                B(Mov), R(9), R(15),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(15), U8(2),
+                B(SuspendGenerator), R(9), R(0), U8(15), U8(8),
+  /*   60 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(9), R(0), U8(15),
+                B(LdaSmi), I8(-2),
+                B(Star), R(10),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(9), U8(1),
+                B(Star), R(15),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(9), U8(1),
+                B(Star), R(16),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(16),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(15),
+                B(ReThrow),
+                B(Mov), R(15), R(3),
                 B(LdaFalse),
                 B(Star), R(17),
                 B(Mov), R(9), R(15),
                 B(Mov), R(3), R(16),
                 B(InvokeIntrinsic), U8(Runtime::k_AsyncGeneratorResolve), R(15), U8(3),
-                B(SuspendGenerator), R(9), R(0), U8(15), U8(6),
+                B(SuspendGenerator), R(9), R(0), U8(15), U8(9),
   /*   60 S> */ B(Return),
                 B(RestoreGeneratorRegisters), R(9), R(0), U8(15),
                 B(LdaSmi), I8(-2),
@@ -837,26 +1072,60 @@ bytecodes: [
                 B(Star), R(1),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), U8(1),
                 B(Star), R(2),
-                B(Wide), B(JumpLoop), U16(561), I16(0),
+                B(Wide), B(JumpLoop), U16(649), I16(0),
                 B(LdaSmi), I8(1),
                 B(TestEqualStrict), R(2), U8(34),
-                B(JumpIfFalse), U8(13),
-                B(LdaNamedProperty), R(3), U8(28), U8(35),
-                B(Star), R(12),
+                B(JumpIfFalse), U8(57),
+                B(LdaNamedProperty), R(3), U8(37), U8(35),
+                B(Star), R(16),
+                B(Mov), R(9), R(15),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(15), U8(2),
+                B(SuspendGenerator), R(9), R(0), U8(15), U8(11),
+  /*   60 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(9), R(0), U8(15),
+                B(LdaSmi), I8(-2),
+                B(Star), R(10),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(9), U8(1),
+                B(Star), R(15),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(9), U8(1),
+                B(Star), R(16),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(16),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(15),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(11),
-                B(Jump), U8(67),
-                B(LdaNamedProperty), R(3), U8(28), U8(37),
+                B(Mov), R(15), R(12),
+                B(Jump), U8(111),
+                B(LdaNamedProperty), R(3), U8(37), U8(37),
                 B(Star), R(8),
                 B(LdaUndefined),
-                B(Star), R(12),
+                B(Star), R(16),
+                B(Mov), R(9), R(15),
+                B(CallJSRuntime), U8(%async_generator_await_uncaught), R(15), U8(2),
+                B(SuspendGenerator), R(9), R(0), U8(15), U8(12),
+  /*   60 S> */ B(Return),
+                B(RestoreGeneratorRegisters), R(9), R(0), U8(15),
+                B(LdaSmi), I8(-2),
+                B(Star), R(10),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetInputOrDebugPos), R(9), U8(1),
+                B(Star), R(15),
+                B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(9), U8(1),
+                B(Star), R(16),
+                B(LdaZero),
+                B(TestEqualStrictNoFeedback), R(16),
+                B(JumpIfTrue), U8(5),
+                B(Ldar), R(15),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(11),
+                B(Mov), R(15), R(12),
                 B(Jump), U8(53),
                 B(Jump), U8(39),
                 B(Star), R(15),
                 B(Ldar), R(closure),
-                B(CreateCatchContext), R(15), U8(22), U8(29),
+                B(CreateCatchContext), R(15), U8(31), U8(38),
                 B(Star), R(14),
                 B(LdaTheHole),
                 B(SetPendingMessage),
@@ -884,7 +1153,7 @@ bytecodes: [
                 B(Ldar), R(13),
                 B(SetPendingMessage),
                 B(Ldar), R(11),
-                B(SwitchOnSmiNoFeedback), U8(32), U8(3), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(41), U8(3), I8(0),
                 B(Jump), U8(34),
                 B(LdaTrue),
                 B(Star), R(16),
@@ -908,44 +1177,53 @@ bytecodes: [
 ]
 constant pool: [
   Smi [46],
-  Smi [137],
-  Smi [137],
-  Smi [137],
-  Smi [137],
-  Smi [137],
-  Smi [137],
-  Smi [15],
+  Smi [87],
+  Smi [181],
+  Smi [181],
+  Smi [181],
+  Smi [181],
+  Smi [181],
+  Smi [181],
+  Smi [181],
+  Smi [181],
+  Smi [181],
+  Smi [861],
+  Smi [919],
+  Smi [59],
   Smi [7],
   ONE_BYTE_INTERNALIZED_STRING_TYPE ["g"],
   SYMBOL_TYPE,
   SYMBOL_TYPE,
   Smi [71],
-  Smi [162],
-  Smi [290],
-  Smi [367],
-  Smi [455],
-  Smi [534],
+  Smi [142],
+  Smi [206],
+  Smi [334],
+  Smi [411],
+  Smi [499],
+  Smi [572],
+  Smi [622],
+  ODDBALL_TYPE,
   ONE_BYTE_INTERNALIZED_STRING_TYPE ["next"],
   ONE_BYTE_INTERNALIZED_STRING_TYPE ["return"],
   ONE_BYTE_INTERNALIZED_STRING_TYPE ["throw"],
   ONE_BYTE_INTERNALIZED_STRING_TYPE [""],
   ONE_BYTE_INTERNALIZED_STRING_TYPE [".catch"],
   FIXED_ARRAY_TYPE,
-  Smi [458],
-  Smi [386],
+  Smi [502],
+  Smi [430],
   Smi [295],
   ONE_BYTE_INTERNALIZED_STRING_TYPE ["done"],
   ONE_BYTE_INTERNALIZED_STRING_TYPE ["value"],
   FIXED_ARRAY_TYPE,
-  Smi [709],
-  Smi [515],
+  Smi [885],
+  Smi [647],
   Smi [6],
   Smi [28],
   Smi [35],
 ]
 handlers: [
-  [52, 791, 797],
-  [55, 752, 754],
-  [421, 476, 478],
+  [52, 1011, 1017],
+  [55, 972, 974],
+  [509, 564, 566],
 ]
 

test/cctest/interpreter/bytecode_expectations/ForAwaitOf.golden

@@ -92,7 +92,7 @@ bytecodes: [
                 B(TestEqualStrictNoFeedback), R(22),
                 B(JumpIfTrue), U8(5),
                 B(Ldar), R(21),
-  /*   40 E> */ B(ReThrow),
+                B(ReThrow),
                 B(Mov), R(21), R(5),
   /*   40 E> */ B(InvokeIntrinsic), U8(Runtime::k_IsJSReceiver), R(21), U8(1),
                 B(ToBooleanLogicalNot),
@@ -395,7 +395,7 @@ bytecodes: [
                 B(TestEqualStrictNoFeedback), R(22),
                 B(JumpIfTrue), U8(5),
                 B(Ldar), R(21),
-  /*   40 E> */ B(ReThrow),
+                B(ReThrow),
                 B(Mov), R(21), R(5),
   /*   40 E> */ B(InvokeIntrinsic), U8(Runtime::k_IsJSReceiver), R(21), U8(1),
                 B(ToBooleanLogicalNot),
@@ -716,7 +716,7 @@ bytecodes: [
                 B(TestEqualStrictNoFeedback), R(22),
                 B(JumpIfTrue), U8(5),
                 B(Ldar), R(21),
-  /*   40 E> */ B(ReThrow),
+                B(ReThrow),
                 B(Mov), R(21), R(5),
   /*   40 E> */ B(InvokeIntrinsic), U8(Runtime::k_IsJSReceiver), R(21), U8(1),
                 B(ToBooleanLogicalNot),

test/cctest/interpreter/bytecode_expectations/ForOfLoop.golden

@@ -1346,7 +1346,7 @@ bytecodes: [
                 B(TestEqualStrictNoFeedback), R(23),
                 B(JumpIfTrue), U8(5),
                 B(Ldar), R(22),
-  /*   45 E> */ B(ReThrow),
+                B(ReThrow),
                 B(LdaZero),
                 B(Star), R(6),
                 B(JumpLoop), U8(118), I8(0),

test/cctest/interpreter/bytecode_expectations/StandardForLoop.golden

@@ -585,7 +585,7 @@ bytecodes: [
                 B(TestEqualStrictNoFeedback), R(10),
                 B(JumpIfTrue), U8(5),
                 B(Ldar), R(9),
-  /*   52 E> */ B(ReThrow),
+                B(ReThrow),
   /*   49 S> */ B(Ldar), R(0),
                 B(Inc), U8(1),
                 B(Star), R(0),

test/mjsunit/harmony/async-generators-resume-return.js

+// Copyright 2017 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.
+
+// Flags: --harmony-async-iteration --allow-natives-syntax
+
+// .return() from state suspendedStart with undefined
+testAsync(test => {
+  test.plan(3);
+
+  async function* gen() {
+    test.unreachable();
+  }
+
+  let didResolvePromise = false;
+  let g = gen();
+  g.return(undefined).then(
+      (iterResult) => {
+        test.equals(true, didResolvePromise);
+        test.equals({ value: undefined, done: true }, iterResult);
+      },
+      test.unexpectedRejection());
+
+  g.next().then(
+      (iterResult) => {
+        test.equals({ value: undefined, done: true }, iterResult);
+      },
+      test.unexpectedRejection());
+
+  // Race: generator request's promise should resolve after this Promise.
+  Promise.resolve("already-resolved").then(
+      _ => { didResolvePromise = true },
+      test.unexpectedRejection());
+
+}, "AsyncGenerator.return(undefined) / suspendStart");
+
+// .return() from state suspendedStart with thenable
+testAsync(test => {
+  test.plan(3);
+
+  async function* gen() {
+    test.unreachable();
+  }
+
+  let didResolvePromise = false;
+  let g = gen();
+
+  let resolve;
+  let awaitedThenable = { then(resolveFn) { resolve = resolveFn; } };
+
+  g.return(awaitedThenable).then(
+      (iterResult) => {
+        test.equals(true, didResolvePromise);
+        test.equals({ value: "resolvedPromise", done: true }, iterResult);
+      },
+      test.unexpectedRejection());
+
+  g.next().then(
+      (iterResult) => {
+        test.equals({ value: undefined, done: true }, iterResult);
+      },
+      test.unexpectedRejection());
+
+  test.drainMicrotasks();
+  resolve("resolvedPromise");
+
+  // Race: generator request's promise should resolve after this Promise.
+  Promise.resolve("already-resolved").then(
+      _ => { didResolvePromise = true },
+      test.unexpectedRejection());
+
+}, "AsyncGenerator.return(thenable) / suspendStart");
+
+// .return() from state suspendedYield with undefined
+testAsync(test => {
+  test.plan(4);
+
+  async function* gen() {
+    yield;
+    test.unreachable();
+  }
+
+  let didResolvePromise = false;
+  let g = gen();
+  g.next().then(
+      (iterResult) => {
+        test.equals({ value: undefined, done: false }, iterResult);
+      },
+      test.unexpectedRejection());
+  g.return(undefined).then(
+      (iterResult) => {
+        test.equals(true, didResolvePromise);
+        test.equals({ value: undefined, done: true }, iterResult);
+      },
+      test.unexpectedRejection());
+  g.next().then(
+      (iterResult) => {
+        test.equals({ value: undefined, done: true }, iterResult);
+      },
+      test.unexpectedRejection());
+
+  // Race: generator request's promise should resolve after this Promise.
+  Promise.resolve("already-resolved").then(
+      _ => { didResolvePromise = true },
+      test.unexpectedRejection());
+
+}, "AsyncGenerator.return(undefined) / suspendedYield");
+
+// .return() from state suspendedYield with thenable
+testAsync(test => {
+  test.plan(4);
+
+  async function* gen() {
+    yield;
+    test.unreachable();
+  }
+
+  let didResolvePromise = false;
+  let g = gen();
+
+  let resolve;
+  let awaitedThenable = { then(resolveFn) { resolve = resolveFn; } };
+
+  g.next().then(
+      (iterResult) => {
+        test.equals({ value: undefined, done: false }, iterResult);
+      },
+      test.unexpectedRejection());
+  g.return(awaitedThenable).then(
+      (iterResult) => {
+        test.equals(true, didResolvePromise);
+        test.equals({ value: "resolvedPromise", done: true }, iterResult);
+      },
+      test.unexpectedRejection());
+
+  g.next().then(
+      (iterResult) => {
+        test.equals({ value: undefined, done: true }, iterResult);
+      },
+      test.unexpectedRejection());
+
+  test.drainMicrotasks();
+  resolve("resolvedPromise");
+
+  // Race: generator request's promise should resolve after this Promise.
+  Promise.resolve("already-resolved").then(
+      _ => { didResolvePromise = true },
+      test.unexpectedRejection());
+
+}, "AsyncGenerator.return(thenable) / suspendYield");

test/mjsunit/harmony/async-generators-return.js

+// Copyright 2017 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.
+
+// Flags: --harmony-async-iteration --allow-natives-syntax
+
+testAsync(test => {
+  test.plan(2);
+
+  async function* gen() {
+    return;
+    test.unreachable();
+  }
+
+  let didResolvePromise = false;
+  gen().next().then(
+      (iterResult) => {
+        test.equals(false, didResolvePromise);
+        test.equals({ value: undefined, done: true }, iterResult);
+      },
+      test.unexpectedRejection());
+
+  // Race: generator request's promise should resolve before this Promise.
+  Promise.resolve("already-resolved").then(
+      _ => { didResolvePromise = true },
+      test.unexpectedRejection());
+
+}, "return-race-no-operand");
+
+testAsync(test => {
+  test.plan(2);
+
+  async function* gen() {
+    return undefined;
+    test.unreachable();
+  }
+
+  let didResolvePromise = false;
+  gen().next().then(
+      (iterResult) => {
+        test.equals(true, didResolvePromise);
+        test.equals({ value: undefined, done: true }, iterResult);
+      },
+      test.unexpectedRejection());
+
+  // Race: generator request's promise should resolve after this Promise.
+  Promise.resolve("already-resolved").then(
+      _ => { didResolvePromise = true },
+      test.unexpectedRejection());
+
+}, "return-race-with-operand");
+
+// Return a thenable which is never settled
+testAsync(test => {
+  test.plan(0);
+
+  let promise = { then() { } };
+
+  async function* gen() {
+    return promise;
+    test.unreachable();
+  }
+
+  gen().next().then(
+      (iterResult) => test.unreachable(),
+      test.unexpectedRejection());
+}, "return-await-thenable-pending");
+
+// Return a thenable which is fulfilled later
+testAsync(test => {
+  test.plan(2);
+
+  let resolve;
+  let awaitedThenable = { then(resolveFn) { resolve = resolveFn; } };
+  let finallyEvaluated = false;
+
+  async function* gen() {
+    try {
+      return awaitedThenable;
+    } finally {
+      finallyEvaluated = true;
+    }
+  }
+
+  gen().next().then(
+      (iterResult) => {
+        test.equals({ value: "resolvedPromise", done: true }, iterResult);
+        test.equals(true, finallyEvaluated);
+      },
+      test.unexpectedRejection());
+
+  test.drainMicrotasks();
+  resolve("resolvedPromise");
+}, "yield-await-thenable-resolved");
+
+// Return a thenable which is rejected later
+testAsync(test => {
+  test.plan(2);
+
+  let reject;
+  let awaitedThenable = { then(resolveFn, rejectFn) { reject = rejectFn; } };
+  async function* gen() {
+    try {
+      yield awaitedThenable;
+    } catch (e) {
+      test.equals("rejection", e);
+      return e;
+    }
+  }
+
+  gen().next().then(
+      (iterResult) => {
+        test.equals({ value: "rejection", done: true }, iterResult);
+      },
+      test.unexpectedRejection());
+
+  test.drainMicrotasks();
+  reject("rejection");
+}, "yield-await-thenable-rejected");

test/mjsunit/harmony/async-generators-yield.js

+// Copyright 2017 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.
+
+// Flags: --harmony-async-iteration --allow-natives-syntax
+
+// Yield a thenable which is never settled
+testAsync(test => {
+  test.plan(0);
+
+  let awaitedThenable = { then() { } };
+
+  async function* gen() {
+    yield awaitedThenable;
+    test.unreachable();
+  }
+
+  gen().next().then(
+      (iterResult) => test.unreachable(),
+      test.unexpectedRejection());
+}, "yield-await-thenable-pending");
+
+// Yield a thenable which is fulfilled later
+testAsync(test => {
+  test.plan(1);
+
+  let resolve;
+  let awaitedThenable = { then(resolveFn) { resolve = resolveFn; } };
+
+  async function* gen() {
+    let input = yield awaitedThenable;
+    test.equals("resolvedPromise", input);
+  }
+
+  gen().next().then(
+      (iterResult) => {
+        test.equals({ value: "resolvedPromise", done: false }, iterResult);
+      },
+      test.unexpectedRejection());
+
+  test.drainMicrotasks();
+  resolve("resolvedPromise");
+}, "yield-await-thenable-resolved");
+
+// Yield a thenable which is rejected later
+testAsync(test => {
+  test.plan(2);
+
+  let reject;
+  let awaitedThenable = { then(resolveFn, rejectFn) { reject = rejectFn; } };
+  async function* gen() {
+    try {
+      yield awaitedThenable;
+    } catch (e) {
+      test.equals("rejection", e);
+      return e;
+    }
+  }
+
+  gen().next().then(
+      (iterResult) => {
+        test.equals({ value: "rejection", done: true }, iterResult);
+      },
+      test.unexpectedRejection());
+
+  test.drainMicrotasks();
+  reject("rejection");
+}, "yield-await-thenable-rejected");

test/mjsunit/mjsunit.js

@@ -754,7 +754,7 @@ var failWithMessage;
     }
 
     fail(expectedText, found) {
-      message = formatFailureText(expectedText, found);
+      let message = formatFailureText(expectedText, found);
       message += "\nin test:" + this.name_
       message += "\n" + Function.prototype.toString.apply(this.test_);
       eval("%AbortJS(message)");
@@ -773,6 +773,25 @@ var failWithMessage;
       eval("%AbortJS(message)");
     }
 
+    unexpectedRejection(details) {
+      return (error) => {
+        let message =
+            "Failure: unexpected Promise rejection in test: " + this.name_;
+        if (details) message += "\n    @" + details;
+        if (error instanceof Error) {
+          message += "\n" + String(error.stack);
+        } else {
+          message += "\n" + String(error);
+        }
+        message += "\n\n" + Function.prototype.toString.apply(this.test_);
+        eval("%AbortJS(message)");
+      };
+    }
+
+    drainMicrotasks() {
+      eval("%RunMicrotasks()");
+    }
+
     done_() {
       if (this.expectedAsserts_ === -1) {
         let message = "Please call t.plan(count) to initialize test harness " +

test/test262/test262.status

@@ -504,36 +504,6 @@
   'built-ins/Array/prototype/splice/create-species-length-exceeding-integer-limit': [FAIL],
   'built-ins/Array/prototype/splice/throws-if-integer-limit-exceeded': [SKIP],
 
-  # https://bugs.chromium.org/p/v8/issues/detail?id=5855
-  'language/expressions/async-generator/named-yield-promise-reject-next': [FAIL],
-  'language/expressions/async-generator/named-yield-promise-reject-next-catch': [FAIL],
-  'language/expressions/async-generator/yield-promise-reject-next': [FAIL],
-  'language/expressions/async-generator/yield-promise-reject-next-catch': [FAIL],
-  'language/expressions/class/async-gen-method-static-yield-promise-reject-next': [FAIL],
-  'language/expressions/class/async-gen-method-static-yield-promise-reject-next-catch': [FAIL],
-  'language/expressions/class/async-gen-method-yield-promise-reject-next': [FAIL],
-  'language/expressions/class/async-gen-method-yield-promise-reject-next-catch': [FAIL],
-  'language/expressions/object/method-definition/async-gen-yield-promise-reject-next': [FAIL],
-  'language/expressions/object/method-definition/async-gen-yield-promise-reject-next-catch': [FAIL],
-  'language/statements/async-generator/yield-promise-reject-next': [FAIL],
-  'language/statements/async-generator/yield-promise-reject-next-catch': [FAIL],
-  'language/statements/class/async-gen-method-static-yield-promise-reject-next': [FAIL],
-  'language/statements/class/async-gen-method-static-yield-promise-reject-next-catch': [FAIL],
-  'language/statements/class/async-gen-method-yield-promise-reject-next': [FAIL],
-  'language/statements/class/async-gen-method-yield-promise-reject-next-catch': [FAIL],
-  'language/statements/for-await-of/async-func-decl-dstr-array-elem-init-let': [FAIL],
-  'language/statements/for-await-of/async-func-decl-dstr-array-elem-put-let': [FAIL],
-  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-let': [FAIL],
-  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-let': [FAIL],
-  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-abpt': [FAIL],
-  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-get-err': [FAIL],
-  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close-null': [FAIL],
-  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close': [FAIL],
-  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close-err': [FAIL],
-  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close-null': [FAIL],
-  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-rtrn-close-err': [PASS, FAIL],
-  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-rtrn-close-null': [FAIL],
-
   # https://bugs.chromium.org/p/v8/issues/detail?id=6541
   'language/export/escaped-as-export-specifier': [FAIL],
   'language/export/escaped-from': [FAIL],
@@ -633,6 +603,20 @@
   'language/statements/for-await-of/async-gen-dstr-const-obj-ptrn-rest-nested-obj': [FAIL],
   'language/statements/for-await-of/async-func-dstr-const-obj-ptrn-rest-obj-own-property': [FAIL],
 
+  # Async Iteration https://github.com/tc39/test262/issues/1154
+  'language/statements/for-await-of/async-func-decl-dstr-array-elem-init-let': [FAIL],
+  'language/statements/for-await-of/async-func-decl-dstr-array-elem-put-let': [FAIL],
+  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-let': [FAIL],
+  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-let': [FAIL],
+  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-abpt': [FAIL],
+  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-get-err': [FAIL],
+  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close-null': [FAIL],
+  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close-err': [FAIL],
+  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close-null': [FAIL],
+  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-rtrn-close-null': [FAIL],
+  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close': [FAIL],
+  'language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-rtrn-close-err': [PASS, FAIL],
+
   ############################ SKIPPED TESTS #############################
 
   # These tests take a looong time to run.