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

3160-3164: SendGen can use send_none for the common None case.

Instruction::Send already does this, but Instruction::SendGen still always calls send. Aligning both paths keeps the intended fastpath consistent.

Suggested patch

-                    match coro.send(receiver, val, vm)? {
+                    let ret = if vm.is_none(&val) {
+                        coro.send_none(receiver, vm)?
+                    } else {
+                        coro.send(receiver, val, vm)?
+                    };
+                    match ret {

🤖 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 3160 - 3164, The SendGen path currently
calls coro.send(...) even when val is None; change it to use the fastpath method
coro.send_none(...) (or send_none) when val equals PyNone to match
Instruction::Send behavior—locate the block gated by can_fast_send in the
SendGen handling (symbols: SendGen, can_fast_send, top_value, builtin_coro,
send) and replace the call to coro.send(receiver, val, vm) with a conditional
that invokes coro.send_none(receiver, vm) for the None case and falls back to
coro.send(...) otherwise, preserving the existing PyIterReturn handling and
error propagation.

crates/vm/src/coroutine.rs (1)

146-182: Deduplicate send_none/send shared execution path.

Both functions duplicate the same closed-check / frame-prepare / resume / finalize flow and only differ in value preparation.

♻️ Proposed refactor

+    fn send_impl<F>(
+        &self,
+        jen: &PyObject,
+        vm: &VirtualMachine,
+        value_for_state: F,
+    ) -> PyResult<PyIterReturn>
+    where
+        F: FnOnce(bool) -> PyResult<Option<PyObjectRef>>,
+    {
+        if self.closed.load() {
+            return Ok(PyIterReturn::StopIteration(None));
+        }
+        let started = self.frame.lasti() > 0;
+        let value = value_for_state(started)?;
+        self.frame.locals_to_fast(vm)?;
+        let result = self.run_with_context(jen, vm, |f| f.resume(value, vm));
+        self.finalize_send_result(jen, result, vm)
+    }
+
     pub(crate) fn send_none(&self, jen: &PyObject, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        if self.closed.load() {
-            return Ok(PyIterReturn::StopIteration(None));
-        }
-        self.frame.locals_to_fast(vm)?;
-        let value = if self.frame.lasti() > 0 {
-            Some(vm.ctx.none())
-        } else {
-            None
-        };
-        let result = self.run_with_context(jen, vm, |f| f.resume(value, vm));
-        self.finalize_send_result(jen, result, vm)
+        self.send_impl(jen, vm, |started| {
+            Ok(if started { Some(vm.ctx.none()) } else { None })
+        })
     }
 
     pub fn send(
         &self,
         jen: &PyObject,
         value: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<PyIterReturn> {
-        if self.closed.load() {
-            return Ok(PyIterReturn::StopIteration(None));
-        }
-        self.frame.locals_to_fast(vm)?;
-        let value = if self.frame.lasti() > 0 {
-            Some(value)
-        } else if !vm.is_none(&value) {
-            return Err(vm.new_type_error(format!(
-                "can't send non-None value to a just-started {}",
-                gen_name(jen, vm),
-            )));
-        } else {
-            None
-        };
-        let result = self.run_with_context(jen, vm, |f| f.resume(value, vm));
-        self.finalize_send_result(jen, result, vm)
+        self.send_impl(jen, vm, |started| {
+            if started {
+                Ok(Some(value))
+            } else if !vm.is_none(&value) {
+                Err(vm.new_type_error(format!(
+                    "can't send non-None value to a just-started {}",
+                    gen_name(jen, vm),
+                )))
+            } else {
+                Ok(None)
+            }
+        })
     }

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/coroutine.rs` around lines 146 - 182, Both send_none and send
duplicate the same closed-check, frame.locals_to_fast call, resume via
run_with_context, and finalize_send_result logic; extract that shared flow into
a helper (e.g., send_common or resume_with_value) that accepts the prepared
Option<PyObjectRef> (or a closure producing it) and performs closed.load check,
self.frame.locals_to_fast(vm)?, calls run_with_context(jen, vm, |f|
f.resume(value, vm)), and returns finalize_send_result; then simplify send_none
to compute its value (using frame.lasti() and vm.ctx.none()) and call the
helper, and simplify send to compute its value (respecting frame.lasti() and the
non-None error) and call the same helper, keeping all original calls to
frame.lasti, run_with_context, finalize_send_result, and closed.load.

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

7837-7861: Reduce duplicated guard/backoff branches in descriptor call-conv selection.

The NOARGS and O branches duplicate the same backoff/return structure with only expected-arity differing. Extract expected arity first, then run one shared guard+backoff path.

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 7837 - 7861, The NOARGS and O branches
in the descriptor call-conv selection duplicate the same guard/backoff/return
logic; refactor by computing the expected arity from call_conv (e.g., map
PyMethodFlags::NOARGS -> 0, PyMethodFlags::O -> 1) and choose the Instruction
variant after the check, then perform a single shared guard that compares nargs
to expected_arity and on mismatch runs the adaptive backoff using
self.code.instructions.read_adaptive_counter(cache_base) and
write_adaptive_counter(...bytecode::adaptive_counter_backoff(...)) and returns;
update references to new_op, call_conv, nargs, cache_base, and the Instruction
variants (CallMethodDescriptorNoargs, etc.) accordingly.