ZeroArg

youknowone · youknowone · commit 62d7e66e4fb0 · 2026-01-11T12:16:51.000+09:00
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -84,8 +84,6 @@ enum SuperCallType<'a> {
         self_arg: &'a Expr,
     },
     /// super() - implicit 0-argument form (uses __class__ cell)
-    /// TODO: Enable after fixing __class__ cell handling in nested classes
-    #[allow(dead_code)]
     ZeroArg,
 }
 
@@ -743,10 +741,26 @@ impl Compiler {
             }
             0 => {
                 // 0-arg: super() - need __class__ cell and first parameter
-                // TODO: 0-arg super() optimization is disabled due to __class__ cell issues
-                // The __class__ cell handling in nested class definitions needs more work.
-                // For now, fall back to regular super() call.
-                None
+                // Check if we're in a function with at least one parameter
+                let info = self.code_stack.last()?;
+                if info.metadata.varnames.is_empty() {
+                    return None;
+                }
+
+                // Check if __class__ is available as a cell/free variable
+                // The scope must be Free (from enclosing class) or have FREE_CLASS flag
+                if let Some(symbol) = table.lookup("__class__") {
+                    if symbol.scope != SymbolScope::Free
+                        && !symbol.flags.contains(SymbolFlags::FREE_CLASS)
+                    {
+                        return None;
+                    }
+                } else {
+                    // __class__ not in symbol table, optimization not possible
+                    return None;
+                }
+
+                Some(SuperCallType::ZeroArg)
             }
             _ => None, // 1 or 3+ args - not optimizable
         }
@@ -3494,12 +3508,14 @@ impl Compiler {
     /// Determines if a variable should be CELL or FREE type
     // = get_ref_type
     fn get_ref_type(&self, name: &str) -> Result<SymbolScope, CodegenErrorType> {
+        let table = self.symbol_table_stack.last().unwrap();
+
         // Special handling for __class__ and __classdict__ in class scope
-        if self.ctx.in_class && (name == "__class__" || name == "__classdict__") {
+        // This should only apply when we're actually IN a class body,
+        // not when we're in a method nested inside a class.
+        if table.typ == CompilerScope::Class && (name == "__class__" || name == "__classdict__") {
             return Ok(SymbolScope::Cell);
         }
-
-        let table = self.symbol_table_stack.last().unwrap();
         match table.lookup(name) {
             Some(symbol) => match symbol.scope {
                 SymbolScope::Cell => Ok(SymbolScope::Cell),
