@@ -4581,11 +4581,16 @@ impl Compiler {
                 _ => continue,
             };
             // Skip @staticmethod and @classmethod decorated functions
-            let dominated_by_special = f.decorator_list.iter().any(|d| {
+            let has_special_decorator = f.decorator_list.iter().any(|d| {
                 matches!(&d.expression, ast::Expr::Name(n)
                     if n.id.as_str() == "staticmethod" || n.id.as_str() == "classmethod")
             });
-            if dominated_by_special {
+            if has_special_decorator {
+                continue;
+            }
+            // Skip implicit classmethods (__init_subclass__, __class_getitem__)
+            let fname = f.name.as_str();
+            if fname == "__init_subclass__" || fname == "__class_getitem__" {
                 continue;
             }
             let first_param = f
@@ -4597,7 +4602,13 @@ impl Compiler {
             let Some(self_name) = first_param else {
                 continue;
             };
-            Self::scan_store_attrs(&f.body, self_name.as_str(), attrs);
+            // 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);
+            }
         }
     }
 
@@ -5460,8 +5471,7 @@ impl Compiler {
         // 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 !is_async
-            && let ast::Expr::List(ast::ExprList { elts, .. }) = iter
+        if let ast::Expr::List(ast::ExprList { elts, .. }) = iter
             && !elts.iter().any(|e| matches!(e, ast::Expr::Starred(_)))
         {
             for elt in elts {
@@ -7369,6 +7379,14 @@ impl Compiler {
                     Some(expression) => self.compile_expression(expression)?,
                     Option::None => self.emit_load_const(ConstantData::None),
                 };
+                if self.ctx.func == FunctionContext::AsyncFunction {
+                    emit!(
+                        self,
+                        Instruction::CallIntrinsic1 {
+                            func: bytecode::IntrinsicFunction1::AsyncGenWrap
+                        }
+                    );
+                }
                 // arg=0: direct yield (wrapped for async generators)
                 emit!(self, Instruction::YieldValue { arg: 0 });
                 emit!(
@@ -7889,6 +7907,22 @@ impl Compiler {
                 if let ast::Expr::Starred(ast::ExprStarred { value, .. }) = &arguments.args[0] {
                     self.compile_expression(value)?;
                 }
+            } else if !has_starred {
+                for arg in &arguments.args {
+                    self.compile_expression(arg)?;
+                }
+                self.set_source_range(call_range);
+                let positional_count = additional_positional + nelts.to_u32();
+                if positional_count == 0 {
+                    self.emit_load_const(ConstantData::Tuple { elements: vec![] });
+                } else {
+                    emit!(
+                        self,
+                        Instruction::BuildTuple {
+                            count: positional_count
+                        }
+                    );
+                }
             } else {
                 // Use starunpack_helper to build a list, then convert to tuple
                 self.starunpack_helper(
@@ -8234,7 +8268,6 @@ impl Compiler {
 
         // Create comprehension function with closure
         self.make_closure(code, bytecode::MakeFunctionFlags::new())?;
-        emit!(self, Instruction::PushNull);
 
         // Evaluate iterated item:
         self.compile_expression(&generators[0].iter)?;
@@ -8248,7 +8281,7 @@ impl Compiler {
         };
 
         // Call just created <listcomp> function:
-        emit!(self, Instruction::Call { argc: 1 });
+        emit!(self, Instruction::Call { argc: 0 });
         if is_async_list_set_dict_comprehension {
             emit!(self, Instruction::GetAwaitable { r#where: 0 });
             self.emit_load_const(ConstantData::None);
 
@@ -209,6 +209,9 @@ 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);
@@ -2023,6 +2026,17 @@ 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);
 
@@ -1290,22 +1290,30 @@ impl PyCode {
         let idx = usize::try_from(opcode).map_err(|_| idx_err(vm))?;
 
         let varnames_len = self.code.varnames.len();
-        let cellvars_len = self.code.cellvars.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()))
+            .collect();
+        let nonparam_len = nonparam_cellvars.len();
 
         let name = if idx < varnames_len {
-            // Index in varnames
+            // Index in varnames (includes parameter cells)
             self.code.varnames.get(idx).ok_or_else(|| idx_err(vm))?
-        } else if idx < varnames_len + cellvars_len {
-            // Index in cellvars
-            self.code
-                .cellvars
+        } else if idx < varnames_len + nonparam_len {
+            // Index in non-parameter cellvars
+            *nonparam_cellvars
                 .get(idx - varnames_len)
                 .ok_or_else(|| idx_err(vm))?
         } else {
             // Index in freevars
             self.code
                 .freevars
-                .get(idx - varnames_len - cellvars_len)
+                .get(idx - varnames_len - nonparam_len)
                 .ok_or_else(|| idx_err(vm))?
         };
         Ok(name.to_object())
 
@@ -298,7 +298,9 @@ impl PyObject {
     ) -> PyResult<Either<PyObjectRef, bool>> {
         let swapped = op.swapped();
         let call_cmp = |obj: &Self, other: &Self, op| {
-            let cmp = obj.class().slots.richcompare.load().unwrap();
+            let Some(cmp) = obj.class().slots.richcompare.load() else {
+                return Ok(PyArithmeticValue::NotImplemented);
+            };
             let r = match cmp(obj, other, op, vm)? {
                 Either::A(obj) => PyArithmeticValue::from_object(vm, obj).map(Either::A),
                 Either::B(arithmetic) => arithmetic.map(Either::B),