Align CFG line marker cleanup with CPython

RustPython · youknowone · May 12, 2026 · Apr 28, 2026 · Apr 30, 2026 · May 5, 2026
commit 555e8fca93bab4d9fbdcaa162395896bef4a799b
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -12126,6 +12126,43 @@ mod tests {
         stack_top.debug_late_cfg_trace().unwrap()
     }
 
+    #[test]
+    #[ignore = "debug helper"]
+    fn debug_trace_nested_continue_after_optional_body() {
+        let trace = compile_single_function_late_cfg_trace(
+            "\
+def f(names, show_empty, keywords, args_buffer, args, cls, object, level):
+    for name in names:
+        value = getattr(cls, name)
+        if not show_empty:
+            if value == []:
+                field_type = cls._field_types.get(name, object)
+                if getattr(field_type, '__origin__', ...) is list:
+                    if not keywords:
+                        args_buffer.append(repr(value))
+                    continue
+            if not keywords:
+                args.extend(args_buffer)
+                args_buffer = []
+        value, simple = _format(value, level)
+        if keywords:
+            args.append('%s=%s' % (name, value))
+        else:
+            args.append(value)
+",
+            "f",
+        );
+        for (label, dump) in trace {
+            if label == "after_reorder"
+                || label == "after_remove_redundant_nops_and_jumps"
+                || label == "after_final_cfg_cleanup"
+                || label == "after_borrow_deopts"
+            {
+                eprintln!("=== {label} ===\n{dump}");
+            }
+        }
+    }
+
     #[test]
     #[ignore = "debug helper"]
     fn debug_trace_make_dataclass_borrow_tail() {
@@ -23576,6 +23613,72 @@ def f(done=False):
         );
     }
 
+    #[test]
+    fn test_for_else_pass_keeps_line_marker_after_pop_iter() {
+        let code = compile_exec(
+            "\
+def f():
+    for item in ():
+        pass
+    else:
+        pass
+    marker = 1
+    return marker
+",
+        );
+        let f = find_code(&code, "f").expect("missing f code");
+        let instructions: Vec<_> = f
+            .instructions
+            .iter()
+            .filter(|unit| !matches!(unit.op, Instruction::Cache))
+            .collect();
+
+        assert!(
+            instructions.windows(2).any(|window| matches!(
+                window,
+                [
+                    CodeUnit {
+                        op: Instruction::PopIter,
+                        ..
+                    },
+                    CodeUnit {
+                        op: Instruction::Nop,
+                        ..
+                    }
+                ]
+            )),
+            "for-else pass should keep CPython-style else-line NOP after POP_ITER, got instructions={instructions:?}"
+        );
+    }
+
+    #[test]
+    fn test_folded_if_chain_after_previous_chain_keeps_final_elif_line_marker() {
+        let code = compile_exec(
+            "\
+def f():
+    if 0: pass
+    elif 0: pass
+    if 0: pass
+    elif 0: pass
+    elif 0: pass
+    elif 0: pass
+    else: pass
+",
+        );
+        let f = find_code(&code, "f").expect("missing f code");
+        let nop_count = f
+            .instructions
+            .iter()
+            .filter(|unit| matches!(unit.op, Instruction::Nop))
+            .count();
+
+        assert_eq!(
+            nop_count, 6,
+            "folded if chains should preserve CPython-style line-marker NOPs, got instructions={:?}",
+            f.instructions
+        );
+    }
+
     #[test]
     fn test_handler_resume_before_later_loop_keeps_borrowed_tail_loads() {
         let code = compile_exec(

diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
@@ -498,14 +498,7 @@ impl CodeInfo {
                 if matches!(instr.instr.real(), Some(Instruction::Nop)) {
                     if instr.preserve_redundant_jump_as_nop {
                         remove = false;
-                    } else if lineno < 0
-                        || prev_lineno == lineno
-                        || (src > 0
-                            && matches!(
-                                src_instructions[src - 1].instr.real(),
-                                Some(Instruction::PopIter)
-                            ))
-                    {
+                    } else if lineno < 0 || prev_lineno == lineno {
                         remove = true;
                     } else if src < src_instructions.len() - 1 {
                         if src_instructions[src + 1].instr.is_block_push() {
@@ -15700,7 +15693,9 @@ fn duplicate_end_returns(blocks: &mut Vec<Block>, metadata: &CodeUnitMetadata) {
             .last()
             .map(|instr| (instr.location, instr.end_location));
         let mut cloned_return = return_insts.clone();
-        if let Some((location, end_location)) = propagated_location {
+        if !instruction_has_lineno(&cloned_return[0])
+            && let Some((location, end_location)) = propagated_location
+        {
             for instr in &mut cloned_return {
                 overwrite_location(instr, location, end_location);
             }