crates/vm/src/builtins/mappingproxy.rs (1)

265-272: Extract duplicated mappingproxy-unwrapping logic into one helper.

a_obj and b_obj use identical match logic. Please extract once and call it for both operands to keep this slot easier to maintain.

♻️ Suggested refactor

             or: Some(|a, b, vm| {
                 // Mirror CPython's mappingproxy_or: when either side is a
                 // mappingproxy, unwrap to its underlying mapping and delegate
                 // to PyNumber_Or so `dict | mp`, `mp | dict`, and `mp | mp`
                 // all produce a `dict` result.
-                let a_obj = match a.downcast_ref::<PyMappingProxy>() {
-                    Some(mp) => mp.copy(vm)?,
-                    None => a.to_pyobject(vm),
-                };
-                let b_obj = match b.downcast_ref::<PyMappingProxy>() {
-                    Some(mp) => mp.copy(vm)?,
-                    None => b.to_pyobject(vm),
-                };
+                let unwrap_mappingproxy = |obj: &PyObject| -> PyResult<PyObjectRef> {
+                    match obj.downcast_ref::<PyMappingProxy>() {
+                        Some(mp) => mp.copy(vm),
+                        None => Ok(obj.to_pyobject(vm)),
+                    }
+                };
+                let a_obj = unwrap_mappingproxy(a)?;
+                let b_obj = unwrap_mappingproxy(b)?;
                 vm._or(a_obj.as_ref(), b_obj.as_ref())
             }),

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/builtins/mappingproxy.rs` around lines 265 - 272, Extract the
duplicated match into a small helper (e.g., unwrap_mappingproxy_or_convert) that
takes the operand (the value currently named `a` or `b`) and `vm` and returns
the same result type as the current branches, using
`downcast_ref::<PyMappingProxy>()` to call `mp.copy(vm)?` or falling back to
`to_pyobject(vm)`; then call that helper for both `a` and `b` to produce `a_obj`
and `b_obj`, preserving the `?` error propagation and return types so all
existing callers (`PyMappingProxy`, `copy`, `to_pyobject`) behave identically.