crates/codegen/src/ir.rs (1)

693-795: Make the borrow optimization conservative on stack underflow and method loads.
The underflow path says “don’t optimize this block,” but the loop continues, so the analysis still runs and may convert unsafely. Also, LOAD_ATTR with method-flag pushes two values; treating it as (1,1) undercounts pushes and can mis-mark LOAD_FAST as fully consumed. Consider using AnyInstruction::stack_effect for pseudo ops and bailing out on underflow, plus a precise LOAD_ATTR case.

🔧 Suggested change

-            for (i, info) in block.instructions.iter().enumerate() {
-                let Some(instr) = info.instr.real() else {
-                    continue;
-                };
-
-                // Get stack effect
-                let effect = instr.stack_effect(info.arg);
+            let mut valid_block = true;
+            for (i, info) in block.instructions.iter().enumerate() {
+                let instr_real = info.instr.real();
+
+                // Get stack effect (includes pseudo ops)
+                let effect = info.instr.stack_effect(info.arg);
                 let num_popped = if effect < 0 { (-effect) as usize } else { 0 };
                 let num_pushed = if effect > 0 { effect as usize } else { 0 };
 
                 // More precise: calculate actual pops and pushes
                 // For most instructions: pops = max(0, -effect), pushes = max(0, effect)
                 // But some instructions have both pops and pushes
-                let (pops, pushes) = match instr {
+                let (pops, pushes) = match instr_real {
+                    Some(Instruction::LoadAttr { idx }) => {
+                        let (_, is_method) = bytecode::decode_load_attr_arg(idx.get(info.arg));
+                        if is_method { (1, 2) } else { (1, 1) }
+                    }
                     // Instructions that both pop and push
-                    Instruction::BinaryOp { .. } => (2, 1),
-                    Instruction::CompareOp { .. } => (2, 1),
-                    Instruction::ContainsOp(_) => (2, 1),
-                    Instruction::IsOp(_) => (2, 1),
-                    Instruction::UnaryInvert
-                    | Instruction::UnaryNegative
-                    | Instruction::UnaryNot
-                    | Instruction::ToBool => (1, 1),
-                    Instruction::GetIter | Instruction::GetAIter => (1, 1),
-                    Instruction::LoadAttr { .. } => (1, 1), // simplified
-                    Instruction::Call { nargs } => (nargs.get(info.arg) as usize + 2, 1),
-                    Instruction::CallKw { nargs } => (nargs.get(info.arg) as usize + 3, 1),
+                    Some(Instruction::BinaryOp { .. }) => (2, 1),
+                    Some(Instruction::CompareOp { .. }) => (2, 1),
+                    Some(Instruction::ContainsOp(_)) => (2, 1),
+                    Some(Instruction::IsOp(_)) => (2, 1),
+                    Some(Instruction::UnaryInvert)
+                    | Some(Instruction::UnaryNegative)
+                    | Some(Instruction::UnaryNot)
+                    | Some(Instruction::ToBool) => (1, 1),
+                    Some(Instruction::GetIter) | Some(Instruction::GetAIter) => (1, 1),
+                    Some(Instruction::Call { nargs }) => (nargs.get(info.arg) as usize + 2, 1),
+                    Some(Instruction::CallKw { nargs }) => (nargs.get(info.arg) as usize + 3, 1),
                     // Use stack effect for others
                     _ => (num_popped, num_pushed),
                 };
 
                 // Pop values from stack
                 for _ in 0..pops {
                     if stack.pop().is_none() {
                         // Stack underflow in simulation - block receives values from elsewhere
                         // Conservative: don't optimize this block
-                        break;
+                        valid_block = false;
+                        break;
                     }
                 }
+                if !valid_block {
+                    break;
+                }
 
                 // Push values to stack with source instruction index
-                let source = match instr {
-                    Instruction::LoadFast(_) | Instruction::LoadFastLoadFast { .. } => i,
+                let source = match instr_real {
+                    Some(Instruction::LoadFast(_))
+                    | Some(Instruction::LoadFastLoadFast { .. }) => i,
                     _ => NOT_LOCAL,
                 };
                 for _ in 0..pushes {
                     stack.push(source);
                 }
             }
 
+            if !valid_block {
+                continue;
+            }
             // Mark instructions whose values remain on stack at block end
             for &src in &stack {
                 if src != NOT_LOCAL {
                     unconsumed[src] = true;
                 }
             }

crates/vm/src/frame.rs (1)

1341-1391: Consider extracting common error-handling logic.

The LoadFastBorrow and LoadFastBorrowLoadFastBorrow handlers duplicate the unbound-local error creation pattern from LoadFast and LoadFastLoadFast. While the TODO comments indicate future divergence for the actual load semantics, the error-handling logic will likely remain the same.

You could extract a helper to reduce duplication:

fn unbound_local_error(varname: &'static PyStrInterned, vm: &VirtualMachine) -> PyBaseExceptionRef {
    vm.new_exception_msg(
        vm.ctx.exceptions.unbound_local_error.to_owned(),
        format!("local variable '{varname}' referenced before assignment"),
    )
}

This is optional since the current implementation is correct and the duplication may be intentional for future optimization work.

.cspell.dict/rust-more.txt (1)

92-93: bitvec/Bitvec entries break alphabetical ordering.

The dictionary appears to be alphabetically sorted, but bitvec and Bitvec are appended at the end after winsock. They should be placed between bitor and bstr to maintain consistency.

📋 Suggested placement

 bitflags
 bitor
+bitvec
+Bitvec
 bitxor
 bstr

And remove from end of file:

 winresource
 winsock
-bitvec
-Bitvec

crates/vm/src/frame.rs (1)

1341-1391: Consider tracking the borrow-optimization TODO.

If this is intentionally a placeholder, linking it to an issue will make the follow‑up easier. I can help draft the issue or a concrete implementation plan if you want.