Move some free standing functions to ir::InstructionInfo methods - #8209

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

2682-2713: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Collapse the three super-instruction arms into one call.

All three match arms differ only in the super_op value while sharing the split_at_mut(1) + make_super_instruction(...) logic. Extract the differing opcode first, then call once. The first arm's nested if is equivalent to matching (Some(Opcode::LoadFast), Some(Opcode::LoadFast)) directly.

As per coding guidelines: "When branches differ only in a value but share common logic, extract the differing value first, then call the common logic once to avoid duplicate code."

♻️ Proposed refactor

-                match (block.instructions[i].instr.real_opcode(), nextop) {
-                    (Some(Opcode::LoadFast), _) => {
-                        if matches!(nextop, Some(Opcode::LoadFast)) {
-                            let (inst1, rest) = block.instructions[i..].split_at_mut(1);
-                            InstructionInfo::make_super_instruction(
-                                &mut inst1[0],
-                                &mut rest[0],
-                                Opcode::LoadFastLoadFast.into(),
-                            );
-                        }
-                    }
-
-                    (Some(Opcode::StoreFast), Some(Opcode::LoadFast)) => {
-                        let (inst1, rest) = block.instructions[i..].split_at_mut(1);
-                        InstructionInfo::make_super_instruction(
-                            &mut inst1[0],
-                            &mut rest[0],
-                            Opcode::StoreFastLoadFast.into(),
-                        );
-                    }
-
-                    (Some(Opcode::StoreFast), Some(Opcode::StoreFast)) => {
-                        let (inst1, rest) = block.instructions[i..].split_at_mut(1);
-                        InstructionInfo::make_super_instruction(
-                            &mut inst1[0],
-                            &mut rest[0],
-                            Opcode::StoreFastStoreFast.into(),
-                        );
-                    }
-
-                    (_, _) => {}
-                }
+                let super_op = match (block.instructions[i].instr.real_opcode(), nextop) {
+                    (Some(Opcode::LoadFast), Some(Opcode::LoadFast)) => {
+                        Some(Opcode::LoadFastLoadFast)
+                    }
+                    (Some(Opcode::StoreFast), Some(Opcode::LoadFast)) => {
+                        Some(Opcode::StoreFastLoadFast)
+                    }
+                    (Some(Opcode::StoreFast), Some(Opcode::StoreFast)) => {
+                        Some(Opcode::StoreFastStoreFast)
+                    }
+                    (_, _) => None,
+                };
+                if let Some(super_op) = super_op {
+                    let (inst1, rest) = block.instructions[i..].split_at_mut(1);
+                    InstructionInfo::make_super_instruction(
+                        &mut inst1[0],
+                        &mut rest[0],
+                        super_op.into(),
+                    );
+                }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/codegen/src/ir.rs` around lines 2682 - 2713, Refactor the match in
ir.rs that builds super-instructions so the repeated split_at_mut(1) and
InstructionInfo::make_super_instruction call happens only once. In the match
around block.instructions[i].instr.real_opcode(), first determine the super_op
for the three supported pairs (LoadFast/LoadFast, StoreFast/LoadFast,
StoreFast/StoreFast), then perform the shared mutation once using that opcode;
the current nested if in the LoadFast arm should be treated as a direct
(Some(Opcode::LoadFast), Some(Opcode::LoadFast)) case.

Source: Coding guidelines