Bytecode parity

Author: youknowone

crates/codegen/src/compile.rs

@@ -4593,6 +4593,11 @@ impl Compiler {
             if fname == "__init_subclass__" || fname == "__class_getitem__" {
                 continue;
             }
+            // For __new__, scan for "self" (not the first param "cls")
+            if fname == "__new__" {
+                Self::scan_store_attrs(&f.body, "self", attrs);
+                continue;
+            }
             let first_param = f
                 .parameters
                 .posonlyargs
@@ -4602,13 +4607,7 @@ impl Compiler {
             let Some(self_name) = first_param else {
                 continue;
             };
-            // For __new__, first param is cls → scan for "self" instead
-            // (CPython scans for the literal name "self" in __new__ bodies)
-            if fname == "__new__" {
-                Self::scan_store_attrs(&f.body, "self", attrs);
-            } else {
-                Self::scan_store_attrs(&f.body, self_name.as_str(), attrs);
-            }
+            Self::scan_store_attrs(&f.body, self_name.as_str(), attrs);
         }
     }
 
@@ -5469,9 +5468,9 @@ impl Compiler {
 
         // The thing iterated:
         // Optimize: `for x in [a, b, c]` → use tuple instead of list
-        // (list creation is wasteful for iteration)
-        // Skip optimization if any element is starred (e.g., `[a, *b, c]`)
-        if let ast::Expr::List(ast::ExprList { elts, .. }) = iter
+        // Skip for async-for (GET_AITER expects the original type)
+        if !is_async
+            && let ast::Expr::List(ast::ExprList { elts, .. }) = iter
             && !elts.iter().any(|e| matches!(e, ast::Expr::Starred(_)))
         {
             for elt in elts {
@@ -7609,6 +7608,14 @@ impl Compiler {
                         compiler.compile_comprehension_element(elt)?;
 
                         compiler.mark_generator();
+                        if compiler.ctx.func == FunctionContext::AsyncFunction {
+                            emit!(
+                                compiler,
+                                Instruction::CallIntrinsic1 {
+                                    func: bytecode::IntrinsicFunction1::AsyncGenWrap
+                                }
+                            );
+                        }
                         // arg=0: direct yield (wrapped for async generators)
                         emit!(compiler, Instruction::YieldValue { arg: 0 });
                         emit!(

crates/codegen/src/ir.rs

@@ -209,9 +209,6 @@ impl CodeInfo {
         // Always apply LOAD_FAST_BORROW optimization
         self.optimize_load_fast_borrow();
 
-        // Add StopIteration handler for generators/coroutines (before label_exception_targets)
-        add_generator_stop_handler(self.flags, &mut self.blocks);
-
         // Post-codegen CFG analysis passes (flowgraph.c pipeline)
         mark_except_handlers(&mut self.blocks);
         label_exception_targets(&mut self.blocks);
@@ -2026,17 +2023,6 @@ fn normalize_jumps(blocks: &mut [Block]) {
 /// to the final return block. Matches CPython's behavior of ensuring every
 /// code path that reaches the end of a function/module has its own explicit
 /// return instruction.
-/// Add a StopIteration → RuntimeError handler for generators/coroutines.
-/// CPython: flowgraph.c add_stopiteration_handler()
-/// Appends a handler block that wraps the entire generator body.
-fn add_generator_stop_handler(_flags: CodeFlags, _blocks: &mut Vec<Block>) {
-    // TODO: Implement generator StopIteration handler.
-    // CPython adds PUSH_EXC_INFO + CALL_INTRINSIC_1(STOPITERATION_ERROR) + RERAISE 1
-    // as a handler wrapping the entire generator body.
-    // Currently disabled: the handler breaks async comprehension execution paths
-    // because it interferes with the exception table ordering.
-}
-
 fn duplicate_end_returns(blocks: &mut [Block]) {
     // Walk the block chain to find the last block
     let mut last_block = BlockIdx(0);

crates/vm/src/builtins/code.rs

@@ -1291,13 +1291,17 @@ impl PyCode {
 
         let varnames_len = self.code.varnames.len();
         // Non-parameter cells: cellvars that are NOT also in varnames
-        let varnames_set: std::collections::HashSet<String> =
-            self.code.varnames.iter().map(|s| s.to_string()).collect();
         let nonparam_cellvars: Vec<_> = self
             .code
             .cellvars
             .iter()
-            .filter(|s| !varnames_set.contains(&s.to_string()))
+            .filter(|s| {
+                let s_str: &str = s.as_ref();
+                !self.code.varnames.iter().any(|v| {
+                    let v_str: &str = v.as_ref();
+                    v_str == s_str
+                })
+            })
             .collect();
         let nonparam_len = nonparam_cellvars.len();
 

crates/vm/src/frame.rs

@@ -10,7 +10,6 @@ use crate::{
         PyBaseException, PyBaseExceptionRef, PyBaseObject, PyCode, PyCoroutine, PyDict, PyDictRef,
         PyFloat, PyFrozenSet, PyGenerator, PyInt, PyInterpolation, PyList, PyModule, PyProperty,
         PySet, PySlice, PyStr, PyStrInterned, PyTemplate, PyTraceback, PyType, PyUtf8Str,
-        asyncgenerator::PyAsyncGenWrappedValue,
         builtin_func::PyNativeFunction,
         descriptor::{MemberGetter, PyMemberDescriptor, PyMethodDescriptor},
         frame::stack_analysis,
@@ -3548,7 +3547,7 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            Instruction::YieldValue { arg: oparg } => {
+            Instruction::YieldValue { .. } => {
                 debug_assert!(
                     self.localsplus
                         .stack_as_slice()
@@ -3557,16 +3556,7 @@ impl ExecutingFrame<'_> {
                         .all(|sr| !sr.is_borrowed()),
                     "borrowed refs on stack at yield point"
                 );
-                let value = self.pop_value();
-                // arg=0: direct yield (wrapped for async generators)
-                // arg=1: yield from await/yield-from (NOT wrapped)
-                let wrap = oparg.get(arg) == 0;
-                let value = if wrap && self.code.flags.contains(bytecode::CodeFlags::COROUTINE) {
-                    PyAsyncGenWrappedValue(value).into_pyobject(vm)
-                } else {
-                    value
-                };
-                Ok(Some(ExecutionResult::Yield(value)))
+                Ok(Some(ExecutionResult::Yield(self.pop_value())))
             }
             Instruction::Send { .. } => {
                 // (receiver, v -- receiver, retval)
@@ -5800,13 +5790,6 @@ impl ExecutingFrame<'_> {
                     let offset = (self.lasti() - 1) * 2;
                     monitoring::fire_py_yield(vm, self.code, offset, &value)?;
                 }
-                let oparg = u32::from(arg);
-                let wrap = oparg == 0;
-                let value = if wrap && self.code.flags.contains(bytecode::CodeFlags::COROUTINE) {
-                    PyAsyncGenWrappedValue(value).into_pyobject(vm)
-                } else {
-                    value
-                };
                 Ok(Some(ExecutionResult::Yield(value)))
             }
             Instruction::InstrumentedCall => {