fix: pass previousRealm to AsyncGeneratorCompleteStep in AsyncGeneratorYield

Author: Elior Nguyen

core/engine/src/builtins/generator/mod.rs

@@ -100,6 +100,11 @@ impl GeneratorContext {
         resume_kind: GeneratorResumeKind,
         context: &mut Context,
     ) -> CompletionRecord {
+        // Capture the caller's realm before swapping stacks.
+        // This is used by AsyncGeneratorYield (spec step 8: "Let previousRealm be
+        // previousContext's Realm") to pass to AsyncGeneratorCompleteStep.
+        let caller_realm = Some(context.realm().clone());
+
         std::mem::swap(&mut context.vm.stack, &mut self.stack);
         let frame = self.call_frame.take().expect("should have a call frame");
         let fp = frame.fp;
@@ -109,6 +114,7 @@ impl GeneratorContext {
         let frame = context.vm.frame_mut();
         frame.fp = fp;
         frame.rp = rp;
+        frame.caller_realm = caller_realm;
         frame.set_exit_early(true);
 
         if let Some(value) = value {

core/engine/src/tests/async_generator.rs

@@ -1,5 +1,5 @@
 use crate::{
-    Context, JsValue, TestAction, builtins::promise::PromiseState, object::JsPromise,
+    Context, JsValue, Source, TestAction, builtins::promise::PromiseState, object::JsPromise,
     run_test_actions,
 };
 use boa_macros::js_str;
@@ -120,3 +120,82 @@ fn return_on_then_queue() {
         TestAction::assert_eq("count", JsValue::from(2)),
     ]);
 }
+
+#[test]
+fn cross_realm_yield_creates_iterator_result_in_caller_realm() {
+    // Verifies that an async generator created in one realm can be correctly
+    // consumed from another realm. This exercises the AsyncGeneratorYield
+    // spec steps 6-8 (previousRealm handling).
+    let mut context = Context::default();
+
+    // Create a second realm for the generator.
+    let generator_realm = context.create_realm().unwrap();
+
+    // Switch to the generator realm and create the async generator there.
+    let old_realm = context.enter_realm(generator_realm);
+    let generator = context
+        .eval(Source::from_bytes(
+            b"(async function* g() { yield 42; yield 99; })()",
+        ))
+        .unwrap();
+
+    // Switch back to the caller's (original) realm.
+    context.enter_realm(old_realm);
+
+    // Call .next() from the caller's realm.
+    let next_fn = generator
+        .as_object()
+        .unwrap()
+        .get(js_str!("next"), &mut context)
+        .unwrap();
+
+    // First yield: should produce {value: 42, done: false}
+    let result_promise = next_fn
+        .as_callable()
+        .unwrap()
+        .call(&generator, &[], &mut context)
+        .unwrap();
+
+    context.run_jobs().unwrap();
+
+    let promise = JsPromise::from_object(result_promise.as_object().unwrap().clone()).unwrap();
+    let PromiseState::Fulfilled(iter_result) = promise.state() else {
+        panic!("first yield: promise was not fulfilled");
+    };
+
+    let result_obj = iter_result.as_object().unwrap();
+    let value = result_obj.get(js_str!("value"), &mut context).unwrap();
+    let done = result_obj
+        .get(js_str!("done"), &mut context)
+        .unwrap()
+        .as_boolean()
+        .unwrap();
+
+    assert_eq!(value, JsValue::from(42));
+    assert!(!done);
+
+    // Second yield: should produce {value: 99, done: false}
+    let result_promise2 = next_fn
+        .as_callable()
+        .unwrap()
+        .call(&generator, &[], &mut context)
+        .unwrap();
+
+    context.run_jobs().unwrap();
+
+    let promise2 = JsPromise::from_object(result_promise2.as_object().unwrap().clone()).unwrap();
+    let PromiseState::Fulfilled(iter_result2) = promise2.state() else {
+        panic!("second yield: promise was not fulfilled");
+    };
+
+    let result_obj2 = iter_result2.as_object().unwrap();
+    let value2 = result_obj2.get(js_str!("value"), &mut context).unwrap();
+    let done2 = result_obj2
+        .get(js_str!("done"), &mut context)
+        .unwrap()
+        .as_boolean()
+        .unwrap();
+
+    assert_eq!(value2, JsValue::from(99));
+    assert!(!done2);
+}

core/engine/src/vm/call_frame/mod.rs

@@ -77,6 +77,10 @@ pub struct CallFrame {
     /// \[\[Realm\]\]
     pub(crate) realm: Realm,
 
+    /// The caller's realm, captured during generator resume.
+    /// Used by `AsyncGeneratorYield` to pass `previousRealm` to `AsyncGeneratorCompleteStep`.
+    pub(crate) caller_realm: Option<Realm>,
+
     // SAFETY: Nothing in `CallFrameFlags` requires tracing, so this is safe.
     #[unsafe_ignore_trace]
     pub(crate) flags: CallFrameFlags,
@@ -154,6 +158,7 @@ impl CallFrame {
             active_runnable,
             environments,
             realm,
+            caller_realm: None,
             flags: CallFrameFlags::empty(),
         }
     }

core/engine/src/vm/opcode/generator/yield_stm.rs

@@ -66,13 +66,21 @@ impl AsyncGeneratorYield {
         let value = context.vm.get_register(value.into());
         let completion = Ok(value.clone());
 
-        // TODO: 6. Assert: The execution context stack has at least two elements.
-        // TODO: 7. Let previousContext be the second to top element of the execution context stack.
-        // TODO: 8. Let previousRealm be previousContext's Realm.
+        // 6. Assert: The execution context stack has at least two elements.
+        //    (Guaranteed by Boa's stack-swap architecture — a caller context always exists.)
+        // 7. Let previousContext be the second to top element of the execution context stack.
+        // 8. Let previousRealm be previousContext's Realm.
+        //    (Captured in GeneratorContext::resume() before the stack swap and stored in the CallFrame.)
+        let previous_realm = context.vm.frame().caller_realm.clone();
+
         // 9. Perform AsyncGeneratorCompleteStep(generator, completion, false, previousRealm).
-        if let Err(err) =
-            AsyncGenerator::complete_step(&async_generator_object, completion, false, None, context)
-        {
+        if let Err(err) = AsyncGenerator::complete_step(
+            &async_generator_object,
+            completion,
+            false,
+            previous_realm,
+            context,
+        ) {
             return context.handle_error(err);
         }
 
@@ -114,8 +122,12 @@ impl AsyncGeneratorYield {
         //     a. Set generator.[[AsyncGeneratorState]] to suspended-yield.
         r#gen.data_mut().state = AsyncGeneratorState::SuspendedYield;
 
-        //     TODO: b. Remove genContext from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
-        //     TODO: c. Let callerContext be the running execution context.
+        //     b. Remove genContext from the execution context stack and restore the execution context
+        //        that is at the top of the execution context stack as the running execution context.
+        //        (Handled implicitly by Boa's stack-swap architecture: handle_yield() breaks out of
+        //         the run loop, and GeneratorContext::resume() swaps stacks back.)
+        //     c. Let callerContext be the running execution context.
+        //        (After the stack swap, the caller's context is automatically restored.)
         //     d. Resume callerContext passing undefined. If genContext is ever resumed again, let resumptionValue be the Completion Record with which it is resumed.
         //     e. Assert: If control reaches here, then genContext is the running execution context again.
         //     f. Return ? AsyncGeneratorUnwrapYieldResumption(resumptionValue).