GeezerVison

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

759-776: Decode RaiseVarargs kind once and reuse it.

Line [759] and Line [775] decode argc.get(arg) separately for the same opcode path. Please extract once and reuse in both predicates.

♻️ Proposed refactor

-                    let is_reraise = match op {
-                        Instruction::RaiseVarargs { argc } => matches!(
-                            argc.get(arg),
-                            bytecode::RaiseKind::BareRaise | bytecode::RaiseKind::ReraiseFromStack
-                        ),
-                        Instruction::Reraise { .. }
-                        | Instruction::EndAsyncFor
-                        | Instruction::CleanupThrow => true,
-                        _ => false,
-                    };
+                    let raise_kind = match op {
+                        Instruction::RaiseVarargs { argc } => Some(argc.get(arg)),
+                        _ => None,
+                    };
+
+                    let is_reraise = matches!(
+                        raise_kind,
+                        Some(
+                            bytecode::RaiseKind::BareRaise
+                                | bytecode::RaiseKind::ReraiseFromStack
+                        )
+                    ) || matches!(
+                        op,
+                        Instruction::Reraise { .. }
+                            | Instruction::EndAsyncFor
+                            | Instruction::CleanupThrow
+                    );
@@
-                    let is_new_raise = matches!(
-                        op,
-                        Instruction::RaiseVarargs { argc }
-                            if matches!(
-                                argc.get(arg),
-                                bytecode::RaiseKind::Raise | bytecode::RaiseKind::RaiseCause
-                            )
-                    );
+                    let is_new_raise = matches!(
+                        raise_kind,
+                        Some(bytecode::RaiseKind::Raise | bytecode::RaiseKind::RaiseCause)
+                    );

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".

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/vm/src/frame.rs` around lines 759 - 776, Extract the result of
argc.get(arg) for the RaiseVarargs opcode into a local binding (e.g., let
raise_kind = argc.get(arg)) before the two matches, then replace both
occurrences of argc.get(arg) in the first predicate and in the is_new_raise
match arm with that raise_kind variable; update the matching arms under
Instruction::RaiseVarargs { argc } and the is_new_raise computation to use
raise_kind so the kind is decoded once and reused.

---

1330-1333: Align Copy comments with current opcode naming.

Line [1330]–Line [1332] still mention CopyItem { index: ... }; the active variant here is Instruction::Copy { i }. Updating this avoids VM debugging confusion.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/vm/src/frame.rs` around lines 1330 - 1333, Update the comment to
reference the current opcode name Instruction::Copy and its field i instead of
the outdated CopyItem { index: ... } so it matches the code. Specifically,
adjust the comment immediately above the line using let idx = i.get(arg) as
usize; to say that Instruction::Copy { i } with i.get(arg) is 1-indexed (Copy
with index 1 copies TOS, index 2 copies second from top) to avoid confusion
during VM debugging.

Configuration used: Path: .coderabbit.yml

Review profile: CHILL

Plan: Pro