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

7009-7046: ⚡ Quick win

Extract the operator mapping to eliminate duplication. Per the coding guidelines ("When branches differ only in a value but share common logic, extract the differing value first"), the six match arms are identical except for the ComparisonOperator variant and the input pattern. Extract the mapping into a single inner match, then emit once.

♻️ Proposed refactor to reduce duplication

 fn compile_addcompare(&mut self, op: &ast::CmpOp) {
-    match op {
-        ast::CmpOp::Eq => emit!(
-            self,
-            Instruction::CompareOp {
-                opname: ComparisonOperator::Equal
-            }
-        ),
-        ast::CmpOp::NotEq => emit!(
-            self,
-            Instruction::CompareOp {
-                opname: ComparisonOperator::NotEqual
-            }
-        ),
-        ast::CmpOp::Lt => emit!(
-            self,
-            Instruction::CompareOp {
-                opname: ComparisonOperator::Less
-            }
-        ),
-        ast::CmpOp::LtE => emit!(
-            self,
-            Instruction::CompareOp {
-                opname: ComparisonOperator::LessOrEqual
-            }
-        ),
-        ast::CmpOp::Gt => emit!(
-            self,
-            Instruction::CompareOp {
-                opname: ComparisonOperator::Greater
-            }
-        ),
-        ast::CmpOp::GtE => {
-            emit!(
-                self,
-                Instruction::CompareOp {
-                    opname: ComparisonOperator::GreaterOrEqual
-                }
-            )
-        }
-    }
+    let opname = match op {
+        ast::CmpOp::Eq => ComparisonOperator::Equal,
+        ast::CmpOp::NotEq => ComparisonOperator::NotEqual,
+        ast::CmpOp::Lt => ComparisonOperator::Less,
+        ast::CmpOp::LtE => ComparisonOperator::LessOrEqual,
+        ast::CmpOp::Gt => ComparisonOperator::Greater,
+        ast::CmpOp::GtE => ComparisonOperator::GreaterOrEqual,
+    };
+    emit!(
+        self,
+        Instruction::CompareOp { opname }
+    );
 }

🤖 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/compile.rs` around lines 7009 - 7046, The match arms for
ast::CmpOp variants (Eq, NotEq, Lt, LtE, Gt, GtE) contain duplicated logic with
only the ComparisonOperator variant differing. Extract the operator mapping into
an inner match statement that converts the ast::CmpOp to its corresponding
ComparisonOperator, then emit the CompareOp instruction once using the result of
that mapping, eliminating the six repetitive emit! calls.

Source: Coding guidelines

crates/vm/src/stdlib/winsound.rs (1)

71-83: ⚡ Quick win

Consider simplifying the generic signature to impl Trait.

The generic type parameter F is not necessary here. The function could use the simpler and more idiomatic impl FnOnce(PlaySoundError) -> PyBaseExceptionRef + '_ return type, which would work equally well at all call sites (lines 91, 99, 154) while reducing complexity.

♻️ Proposed simplification

-fn map_play_err<F>(vm: &VirtualMachine) -> F
-where
-    F: FnOnce(PlaySoundError) -> PyBaseExceptionRef + '_,
-{
+fn map_play_err(vm: &VirtualMachine) -> impl FnOnce(PlaySoundError) -> PyBaseExceptionRef + '_ {
     |err| match err {
         PlaySoundError::MemoryAsyncRejected => {
             vm.new_runtime_error("Cannot play asynchronously from memory")
         }
         PlaySoundError::MemoryFlagWithoutBuffer | PlaySoundError::CallFailed => {
             vm.new_runtime_error("Failed to play sound")
         }
     }
 }

🤖 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/vm/src/stdlib/winsound.rs` around lines 71 - 83, Simplify the generic
signature of the map_play_err function by removing the explicit generic type
parameter F and using impl Trait syntax instead. Change the return type to use
impl FnOnce(PlaySoundError) -> PyBaseExceptionRef + '_ directly, which is more
idiomatic and achieves the same result at all call sites while reducing
unnecessary complexity.