Align loop CFG fallthrough with CPython

RustPython · youknowone · May 12, 2026 · Apr 28, 2026 · Apr 30, 2026 · May 5, 2026
commit 8abe32a9a890a87cbb5b3e62e1891e9ccaee9640
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -20929,6 +20929,69 @@ def f(obj, flags, writer, value, Error):
         );
     }
 
+    #[test]
+    fn test_nested_continue_shares_backedge_with_fallthrough_body() {
+        let code = compile_exec(
+            "\
+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)
+",
+        );
+        let f = find_code(&code, "f").expect("missing f code");
+        let ops: Vec<_> = f
+            .instructions
+            .iter()
+            .map(|unit| unit.op)
+            .filter(|op| !matches!(op, Instruction::Cache | Instruction::NotTaken))
+            .collect();
+
+        assert!(
+            ops.windows(4).any(|window| {
+                matches!(
+                    window,
+                    [
+                        Instruction::PopTop,
+                        Instruction::JumpBackward { .. }
+                            | Instruction::JumpBackwardNoInterrupt { .. },
+                        Instruction::LoadFastBorrow { .. } | Instruction::LoadFast { .. },
+                        Instruction::ToBool,
+                    ]
+                )
+            }),
+            "expected CPython-style shared continue backedge before outer condition, got ops={ops:?}"
+        );
+        assert!(
+            !ops.windows(2).any(|window| {
+                matches!(
+                    window,
+                    [
+                        Instruction::JumpBackward { .. }
+                            | Instruction::JumpBackwardNoInterrupt { .. },
+                        Instruction::JumpBackward { .. }
+                            | Instruction::JumpBackwardNoInterrupt { .. },
+                    ]
+                )
+            }),
+            "unexpected duplicated continue/backedge jumps, got ops={ops:?}"
+        );
+    }
+
     #[test]
     fn test_line_bearing_loop_if_false_backedge_keeps_body_before_jump_back() {
         let code = compile_exec(
@@ -21189,6 +21252,72 @@ def f(keys, parse_int, d, ampm, AM, PM):
         );
     }
 
+    #[test]
+    fn test_loop_nested_if_before_elif_keeps_body_before_false_backedge() {
+        let code = compile_exec(
+            "\
+def f(keys, parse_int, found_dict, locale_time):
+    hour = minute = 0
+    for group_key in keys:
+        if group_key == 'I':
+            hour = parse_int(found_dict['I'])
+            ampm = found_dict.get('p', '').lower()
+            if ampm in ('', locale_time.am_pm[0]):
+                if hour == 12:
+                    hour = 0
+            elif ampm == locale_time.am_pm[1]:
+                if hour != 12:
+                    hour += 12
+        elif group_key == 'M':
+            minute = parse_int(found_dict['M'])
+    return hour, minute
+",
+        );
+        let f = find_code(&code, "f").expect("missing f code");
+        let ops: Vec<_> = f
+            .instructions
+            .iter()
+            .map(|unit| unit.op)
+            .filter(|op| !matches!(op, Instruction::Cache))
+            .collect();
+
+        assert!(
+            ops.windows(7).any(|window| {
+                matches!(
+                    window,
+                    [
+                        Instruction::CompareOp { .. },
+                        Instruction::PopJumpIfFalse { .. },
+                        Instruction::NotTaken,
+                        Instruction::LoadSmallInt { .. },
+                        Instruction::StoreFast { .. },
+                        Instruction::JumpBackward { .. }
+                            | Instruction::JumpBackwardNoInterrupt { .. },
+                        Instruction::JumpBackward { .. }
+                            | Instruction::JumpBackwardNoInterrupt { .. },
+                    ]
+                )
+            }),
+            "expected CPython-style nested if body before false backedge, got ops={ops:?}"
+        );
+        assert!(
+            !ops.windows(5).any(|window| {
+                matches!(
+                    window,
+                    [
+                        Instruction::CompareOp { .. },
+                        Instruction::PopJumpIfTrue { .. },
+                        Instruction::NotTaken,
+                        Instruction::JumpBackward { .. }
+                            | Instruction::JumpBackwardNoInterrupt { .. },
+                        Instruction::LoadSmallInt { .. },
+                    ]
+                )
+            }),
+            "unexpected inverted nested if body after false backedge, got ops={ops:?}"
+        );
+    }
+
     #[test]
     fn test_loop_multiblock_conditional_body_keeps_body_before_jump_back() {
         let code = compile_exec(

diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
@@ -14745,9 +14745,11 @@ fn reorder_conditional_body_and_implicit_continue_blocks(blocks: &mut Vec<Block>
                         | Instruction::LoadFastBorrow { .. }
                         | Instruction::LoadFastLoadFast { .. }
                         | Instruction::LoadFastBorrowLoadFastBorrow { .. }
+                        | Instruction::LoadDeref { .. }
                         | Instruction::LoadConst { .. }
                         | Instruction::LoadSmallInt { .. }
                         | Instruction::LoadAttr { .. }
+                        | Instruction::BinaryOp { .. }
                         | Instruction::ContainsOp { .. }
                         | Instruction::CompareOp { .. }
                         | Instruction::ToBool
@@ -14812,6 +14814,10 @@ fn reorder_conditional_body_and_implicit_continue_blocks(blocks: &mut Vec<Block>
                 block_starts_loop_cleanup(blocks, after_jump_target);
             let after_jump_continues_conditional_chain = after_jump_target != BlockIdx::NULL
                 && block_is_pure_conditional_test(&blocks[after_jump_target.idx()]);
+            if after_jump_continues_conditional_chain {
+                current = next;
+                continue;
+            }
             let simple_single_block_can_reorder = body_is_single_block
                 && !body_tail_is_conditional
                 && !has_exceptional_duplicate_condition_line
@@ -15532,6 +15538,13 @@ fn duplicate_fallthrough_jump_back_targets(blocks: &mut Vec<Block>) {
             layout_pred = blocks[layout_pred.idx()].next;
             continue;
         }
+        if blocks[target.idx()].instructions[0]
+            .lineno_override
+            .is_some_and(|lineno| lineno >= 0)
+        {
+            layout_pred = blocks[layout_pred.idx()].next;
+            continue;
+        }
         if !block_has_no_lineno(&blocks[target.idx()])
             && trailing_conditional_jump_index(&blocks[layout_pred.idx()]).is_some()
         {