Method peephole_optimize

crates/codegen/src/ir.rs:1330–1425

Peephole optimization: combine consecutive instructions into super-instructions

(&mut self)

    /// Peephole optimization: combine consecutive instructions into super-instructions
    fn peephole_optimize(&mut self) {
        for block in &mut self.blocks {
            let mut i = 0;
            while i + 1 < block.instructions.len() {
                let combined = {
                    let curr = &block.instructions[i];
                    let next = &block.instructions[i + 1];

                    // Only combine if both are real instructions (not pseudo)
                    let (Some(curr_instr), Some(next_instr)) =
                        (curr.instr.real(), next.instr.real())
                    else {
                        i += 1;
                        continue;
                    };

                    match (curr_instr, next_instr) {
                        // LoadFast + LoadFast -> LoadFastLoadFast (if both indices < 16)
                        (Instruction::LoadFast { .. }, Instruction::LoadFast { .. }) => {
                            let idx1 = u32::from(curr.arg);
                            let idx2 = u32::from(next.arg);
                            if idx1 < 16 && idx2 < 16 {
                                let packed = (idx1 << 4) | idx2;
                                Some((
                                    Instruction::LoadFastLoadFast {
                                        var_nums: Arg::marker(),
                                    },
                                    OpArg::new(packed),
                                ))
                            } else {
                                None
                            }
                        }
                        // StoreFast + StoreFast -> StoreFastStoreFast (if both indices < 16)
                        (Instruction::StoreFast { .. }, Instruction::StoreFast { .. }) => {
                            let idx1 = u32::from(curr.arg);
                            let idx2 = u32::from(next.arg);
                            if idx1 < 16 && idx2 < 16 {
                                let packed = (idx1 << 4) | idx2;
                                Some((
                                    Instruction::StoreFastStoreFast {
                                        var_nums: Arg::marker(),
                                    },
                                    OpArg::new(packed),
                                ))
                            } else {
                                None
                            }
                        }
                        // Note: StoreFast + LoadFast → StoreFastLoadFast is done in a
                        // separate pass AFTER optimize_load_fast_borrow, because CPython
                        // only combines STORE_FAST + LOAD_FAST (not LOAD_FAST_BORROW).
                        (Instruction::LoadConst { consti }, Instruction::ToBool) => {
                            let consti = consti.get(curr.arg);
                            let constant = &self.metadata.consts[consti.as_usize()];
                            if let ConstantData::Boolean { .. } = constant {
                                Some((curr_instr, OpArg::from(consti.as_u32())))
                            } else {