Fix CI: clippy warnings and module-scope comprehension inlining

youknowone · youknowone · commit 0a1cb62b5156 · 2026-03-29T14:34:38.000+09:00
- Add #[allow(dead_code)] for combine_store_fast_load_fast placeholder
- Use Copy instead of clone for InstructionInfo
- Disable PEP 709 comprehension inlining at module/class scope:
  restore in_func() guard in is_inlined_comprehension_context,
  remove fast_hidden NAME→FAST override and module-scope fast_hidden
  population that caused for-loop variables to be invisible to lambdas
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -1039,8 +1039,9 @@ impl Compiler {
         if comprehension_type == ComprehensionType::Generator {
             return false;
         }
-        // CPython inlines comprehensions at ALL scopes (module, class, function, lambda)
-        // — only generator expressions and annotation scopes nested in class are excluded.
+        if !self.ctx.in_func() {
+            return false;
+        }
         self.symbol_table_stack
             .last()
             .and_then(|t| t.sub_tables.get(t.next_sub_table))
@@ -2113,20 +2114,6 @@ impl Compiler {
             SymbolScope::Unknown => NameOp::Name,
         };
 
-        // PEP 709: Override NAME → FAST for comprehension-local variables at non-function scope
-        let op_type = if matches!(op_type, NameOp::Name)
-            && self
-                .current_code_info()
-                .metadata
-                .fast_hidden
-                .get(name.as_ref())
-                .is_some_and(|&v| v)
-        {
-            NameOp::Fast
-        } else {
-            op_type
-        };
-
         // Generate appropriate instructions based on operation type
         match op_type {
             NameOp::Deref => {
@@ -7484,20 +7471,12 @@ impl Compiler {
                 left, op, right, ..
             }) => {
                 // optimize_format_str: 'format' % (args,) → f-string bytecode
-                if matches!(op, ast::Operator::Mod) {
-                    if let ast::Expr::StringLiteral(s) = left.as_ref() {
-                        if let ast::Expr::Tuple(ast::ExprTuple { elts, .. }) =
-                            right.as_ref()
-                        {
-                            if self.try_optimize_format_str(
-                                &s.value.to_str(),
-                                elts,
-                                range,
-                            )? {
-                                return Ok(());
-                            }
-                        }
-                    }
+                if matches!(op, ast::Operator::Mod)
+                    && let ast::Expr::StringLiteral(s) = left.as_ref()
+                    && let ast::Expr::Tuple(ast::ExprTuple { elts, .. }) = right.as_ref()
+                    && self.try_optimize_format_str(s.value.to_str(), elts, range)?
+                {
+                    return Ok(());
                 }
                 self.compile_expression(left)?;
                 self.compile_expression(right)?;
@@ -8626,20 +8605,6 @@ impl Compiler {
             }
         }
 
-        // PEP 709: For non-function scopes (module/class), mark comprehension-local
-        // variables in fast_hidden so compile_name uses FAST instead of NAME.
-        if !self.ctx.in_func() {
-            for (name, comp_sym) in &comp_table.symbols {
-                if comp_sym.flags.contains(SymbolFlags::PARAMETER) {
-                    continue;
-                }
-                if comp_sym.scope == SymbolScope::Local || comp_sym.scope == SymbolScope::Cell {
-                    let info = self.current_code_info();
-                    info.metadata.fast_hidden.insert(name.clone(), true);
-                }
-            }
-        }
-
         // Step 2: Save local variables that will be shadowed by the comprehension.
         // For each variable, we push the fast local value via LoadFastAndClear.
         // For merged CELL variables, LoadFastAndClear saves the cell object from
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
@@ -1480,6 +1480,7 @@ impl CodeInfo {
     /// Combine STORE_FAST + LOAD_FAST → STORE_FAST_LOAD_FAST.
     /// Must run AFTER optimize_load_fast_borrow so that STORE_FAST + LOAD_FAST_BORROW
     /// pairs are NOT combined (matching CPython's flowgraph.c behavior).
+    #[allow(dead_code)]
     fn combine_store_fast_load_fast(&mut self) {
         for block in &mut self.blocks {
             let mut i = 0;
