@@ -720,9 +720,11 @@ impl Compiler {
         {
             return None;
         }
-        // Also check top-level scope to detect module-level shadowing
+        // Also check top-level scope to detect module-level shadowing.
+        // Only block if super is actually *bound* at module level (not just used).
         if let Some(top_table) = self.symbol_table_stack.first()
-            && top_table.lookup("super").is_some()
+            && let Some(sym) = top_table.lookup("super")
+            && sym.scope != SymbolScope::GlobalImplicit
         {
             return None;
         }
 
@@ -245,16 +245,21 @@ pub enum Instruction {
         arg: Arg<u32>,
     } = 149,
     // ===== LOAD_SUPER_* Pseudo Opcodes (136-138) =====
-    // These are converted to LoadSuperAttr during bytecode finalization
+    // These are converted to LoadSuperAttr during bytecode finalization.
+    // "Zero" variants are for 0-arg super() calls (has_class=false).
+    // Non-"Zero" variants are for 2-arg super(cls, self) calls (has_class=true).
+    /// 2-arg super(cls, self).method() - has_class=true, load_method=true
     LoadSuperMethod {
         idx: Arg<NameIdx>,
-    } = 136, // CPython uses pseudo-op 260
+    } = 136,
+    /// 0-arg super().attr - has_class=false, load_method=false
     LoadZeroSuperAttr {
         idx: Arg<NameIdx>,
-    } = 137, // CPython uses pseudo-op 261
+    } = 137,
+    /// 0-arg super().method() - has_class=false, load_method=true
     LoadZeroSuperMethod {
         idx: Arg<NameIdx>,
-    } = 138, // CPython uses pseudo-op 262
+    } = 138,
     // ==================== RustPython-only instructions (119-135) ====================
     // Ideally, we want to be fully aligned with CPython opcodes, but we still have some leftovers.
     // So we assign random IDs to these opcodes.
Original file line number	Diff line number	Diff line change
`@@ -720,9 +720,11 @@ impl Compiler {`
`720`	`720`	`{`
`721`	`721`	`return None;`
`722`	`722`	`}`
`723`		`- // Also check top-level scope to detect module-level shadowing`
	`723`	`+ // Also check top-level scope to detect module-level shadowing.`
	`724`	`+ // Only block if super is actually bound at module level (not just used).`
`724`	`725`	`if let Some(top_table) = self.symbol_table_stack.first()`
`725`		`- && top_table.lookup("super").is_some()`
	`726`	`+ && let Some(sym) = top_table.lookup("super")`
	`727`	`+ && sym.scope != SymbolScope::GlobalImplicit`
`726`	`728`	`{`
`727`	`729`	`return None;`
`728`	`730`	`}`