Eliminate unreachable blocks after jump normalization

Split DCE into two phases: (1) within-block truncation after terminal instructions (always runs), (2) whole-block elimination for blocks only reachable via fall-through from terminal blocks (runs after normalize_jumps when dead jump instructions exist).
RustPython · youknowone · Mar 23, 2026 · Mar 20, 2026 · Mar 20, 2026 · Mar 20, 2026
commit 83a548eace3bde36b3e9264e01944bdfa0c1bf1c
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
@@ -209,6 +209,7 @@ impl CodeInfo {
         label_exception_targets(&mut self.blocks);
         push_cold_blocks_to_end(&mut self.blocks);
         normalize_jumps(&mut self.blocks);
+        self.eliminate_unreachable_blocks();
         duplicate_end_returns(&mut self.blocks);
         self.optimize_load_global_push_null();
 
@@ -548,6 +549,7 @@ impl CodeInfo {
     }
 
     fn dce(&mut self) {
+        // Truncate instructions after terminal instructions within each block
         for block in &mut self.blocks {
             let mut last_instr = None;
             for (i, ins) in block.instructions.iter().enumerate() {
@@ -562,6 +564,45 @@ impl CodeInfo {
         }
     }
 
+    /// Clear blocks that are unreachable (not entry, not a jump target,
+    /// and only reachable via fall-through from a terminal block).
+    fn eliminate_unreachable_blocks(&mut self) {
+        let mut reachable = vec![false; self.blocks.len()];
+        reachable[0] = true;
+        // Mark blocks reachable via jump targets and exception handlers
+        for block in &self.blocks {
+            for ins in &block.instructions {
+                if ins.target != BlockIdx::NULL {
+                    reachable[ins.target.idx()] = true;
+                }
+                if let Some(eh) = &ins.except_handler {
+                    reachable[eh.handler_block.idx()] = true;
+                }
+            }
+        }
+        // Mark blocks reachable via fall-through from non-terminal blocks
+        let mut current = BlockIdx(0);
+        while current != BlockIdx::NULL {
+            let next = self.blocks[current.idx()].next;
+            if next != BlockIdx::NULL
+                && !self.blocks[current.idx()]
+                    .instructions
+                    .last()
+                    .is_some_and(|ins| {
+                        ins.instr.is_scope_exit() || ins.instr.is_unconditional_jump()
+                    })
+            {
+                reachable[next.idx()] = true;
+            }
+            current = next;
+        }
+        for (i, block) in self.blocks.iter_mut().enumerate() {
+            if !reachable[i] {
+                block.instructions.clear();
+            }
+        }
+    }
+
     /// Constant folding: fold LOAD_CONST/LOAD_SMALL_INT + BUILD_TUPLE into LOAD_CONST tuple
     /// fold_tuple_of_constants
     fn fold_tuple_constants(&mut self) {

diff --git a/...s/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap b/...s/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap