Method fold_binop_constants

crates/codegen/src/ir.rs:710–769

Constant folding: fold LOAD_CONST/LOAD_SMALL_INT + LOAD_CONST/LOAD_SMALL_INT + BINARY_OP into a single LOAD_CONST when the result is computable at compile time. = fold_binops_on_constants in CPython flowgraph.c

(&mut self)

    /// into a single LOAD_CONST when the result is computable at compile time.
    /// = fold_binops_on_constants in CPython flowgraph.c
    fn fold_binop_constants(&mut self) {
        use oparg::BinaryOperator as BinOp;

        for block in &mut self.blocks {
            let mut i = 0;
            while i + 2 < block.instructions.len() {
                // Check pattern: LOAD_CONST/LOAD_SMALL_INT, LOAD_CONST/LOAD_SMALL_INT, BINARY_OP
                let Some(Instruction::BinaryOp { .. }) = block.instructions[i + 2].instr.real()
                else {
                    i += 1;
                    continue;
                };

                let op_raw = u32::from(block.instructions[i + 2].arg);
                let Ok(op) = BinOp::try_from(op_raw) else {
                    i += 1;
                    continue;
                };

                let left = Self::get_const_value_from(&self.metadata, &block.instructions[i]);
                let right = Self::get_const_value_from(&self.metadata, &block.instructions[i + 1]);

                let (Some(left_val), Some(right_val)) = (left, right) else {
                    i += 1;
                    continue;
                };

                let result = Self::eval_binop(&left_val, &right_val, op);

                if let Some(result_const) = result {
                    // Check result size limit (CPython limits to 4096 bytes)
                    if Self::const_too_big(&result_const) {
                        i += 1;
                        continue;
                    }
                    let (const_idx, _) = self.metadata.consts.insert_full(result_const);
                    // Replace first instruction with LOAD_CONST result
                    block.instructions[i].instr = Instruction::LoadConst {
                        consti: Arg::marker(),
                    }
                    .into();
                    block.instructions[i].arg = OpArg::new(const_idx as u32);
                    // NOP out the second and third instructions
                    let loc = block.instructions[i].location;
                    let end_loc = block.instructions[i].end_location;
                    block.instructions[i + 1].instr = Instruction::Nop.into();
                    block.instructions[i + 1].location = loc;
                    block.instructions[i + 1].end_location = end_loc;
                    block.instructions[i + 2].instr = Instruction::Nop.into();
                    block.instructions[i + 2].location = loc;
                    block.instructions[i + 2].end_location = end_loc;
                    // Don't advance - check if the result can be folded again
                    // (e.g., 2 ** 31 - 1)
                    i = i.saturating_sub(1); // re-check with previous instruction
                } else {
                    i += 1;
                }
            }