RustPython
diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
@@ -1,8 +1,8 @@
 use super::Diagnostic;
 use crate::util::{
     ALL_ALLOWED_NAMES, ClassItemMeta, ContentItem, ContentItemInner, ErrorVec, ExceptionItemMeta,
-    ItemMeta, ItemMetaInner, ItemNursery, SimpleItemMeta, format_doc, pyclass_ident_and_attrs,
-    pyexception_ident_and_attrs, text_signature,
+    ItemMeta, ItemMetaInner, ItemNursery, SimpleItemMeta, format_doc, infer_native_call_flags,
+    pyclass_ident_and_attrs, pyexception_ident_and_attrs, text_signature,
 };
 use core::str::FromStr;
 use proc_macro2::{Delimiter, Group, Span, TokenStream, TokenTree};
@@ -1015,6 +1015,16 @@ where
 
         let raw = item_meta.raw()?;
         let sig_doc = text_signature(func.sig(), &py_name);
+        let has_receiver = func
+            .sig()
+            .inputs
+            .iter()
+            .any(|arg| matches!(arg, syn::FnArg::Receiver(_)));
+        let drop_first_typed = match self.inner.attr_name {
+            AttrName::Method | AttrName::ClassMethod if !has_receiver => 1,
+            _ => 0,
+        };
+        let call_flags = infer_native_call_flags(func.sig(), drop_first_typed);
 
         // Add #[allow(non_snake_case)] for setter methods like set___name__
         let method_name = ident.to_string();
@@ -1031,6 +1041,7 @@ where
             doc,
             raw,
             attr_name: self.inner.attr_name,
+            call_flags,
         });
         Ok(())
     }
@@ -1248,6 +1259,7 @@ struct MethodNurseryItem {
     raw: bool,
     doc: Option<String>,
     attr_name: AttrName,
+    call_flags: TokenStream,
 }
 
 impl MethodNursery {
@@ -1278,7 +1290,7 @@ impl ToTokens for MethodNursery {
             } else {
                 quote! { None }
             };
-            let flags = match &item.attr_name {
+            let binding_flags = match &item.attr_name {
                 AttrName::Method => {
                     quote! { rustpython_vm::function::PyMethodFlags::METHOD }
                 }
@@ -1290,6 +1302,12 @@ impl ToTokens for MethodNursery {
                 }
                 _ => unreachable!(),
             };
+            let call_flags = &item.call_flags;
+            let flags = quote! {
+                rustpython_vm::function::PyMethodFlags::from_bits_retain(
+                    (#binding_flags).bits() | (#call_flags).bits()
+                )
+            };
             // TODO: intern
             // let py_name = if py_name.starts_with("__") && py_name.ends_with("__") {
             //     let name_ident = Ident::new(&py_name, ident.span());

diff --git a/crates/derive-impl/src/pymodule.rs b/crates/derive-impl/src/pymodule.rs
@@ -2,8 +2,8 @@ use crate::error::Diagnostic;
 use crate::pystructseq::PyStructSequenceMeta;
 use crate::util::{
     ALL_ALLOWED_NAMES, AttrItemMeta, AttributeExt, ClassItemMeta, ContentItem, ContentItemInner,
-    ErrorVec, ItemMeta, ItemNursery, ModuleItemMeta, SimpleItemMeta, format_doc, iter_use_idents,
-    pyclass_ident_and_attrs, text_signature,
+    ErrorVec, ItemMeta, ItemNursery, ModuleItemMeta, SimpleItemMeta, format_doc,
+    infer_native_call_flags, iter_use_idents, pyclass_ident_and_attrs, text_signature,
 };
 use core::str::FromStr;
 use proc_macro2::{Delimiter, Group, TokenStream, TokenTree};
@@ -525,6 +525,7 @@ struct FunctionNurseryItem {
     cfgs: Vec<Attribute>,
     ident: Ident,
     doc: String,
+    call_flags: TokenStream,
 }
 
 impl FunctionNursery {
@@ -550,14 +551,14 @@ struct ValidatedFunctionNursery(FunctionNursery);
 impl ToTokens for ValidatedFunctionNursery {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let mut inner_tokens = TokenStream::new();
-        let flags = quote! { rustpython_vm::function::PyMethodFlags::empty() };
         for item in &self.0.items {
             let ident = &item.ident;
             let cfgs = &item.cfgs;
             let cfgs = quote!(#(#cfgs)*);
             let py_names = &item.py_names;
             let doc = &item.doc;
             let doc = quote!(Some(#doc));
+            let flags = &item.call_flags;
 
             inner_tokens.extend(quote![
                 #(
@@ -706,12 +707,14 @@ impl ModuleItem for FunctionItem {
                 py_names
             }
         };
+        let call_flags = infer_native_call_flags(func.sig(), 0);
 
         args.context.function_items.add_item(FunctionNurseryItem {
             ident: ident.to_owned(),
             py_names,
             cfgs: args.cfgs.to_vec(),
             doc,
+            call_flags,
         });
         Ok(())
     }

diff --git a/crates/derive-impl/src/util.rs b/crates/derive-impl/src/util.rs
@@ -732,6 +732,77 @@ pub(crate) fn text_signature(sig: &Signature, name: &str) -> String {
     }
 }
 
+pub(crate) fn infer_native_call_flags(sig: &Signature, drop_first_typed: usize) -> TokenStream {
+    // Best-effort mapping of Rust function signatures to CPython-style
+    // METH_* calling convention flags used by CALL specialization.
+    let mut typed_args = Vec::new();
+    for arg in &sig.inputs {
+        let syn::FnArg::Typed(typed) = arg else {
+            continue;
+        };
+        let ty_tokens = &typed.ty;
+        let ty = quote!(#ty_tokens).to_string().replace(' ', "");
+        // `vm: &VirtualMachine` is not a Python-level argument.
+        if ty.starts_with('&') && ty.ends_with("VirtualMachine") {
+            continue;
+        }
+        typed_args.push(ty);
+    }
+
+    let mut user_args = typed_args.into_iter();
+    for _ in 0..drop_first_typed {
+        if user_args.next().is_none() {
+            break;
+        }
+    }
+
+    let mut has_keywords = false;
+    let mut variable_arity = false;
+    let mut fixed_positional = 0usize;
+
+    for ty in user_args {
+        let is_named = |name: &str| {
+            ty == name
+                || ty.starts_with(&format!("{name}<"))
+                || ty.contains(&format!("::{name}<"))
+                || ty.ends_with(&format!("::{name}"))
+        };
+
+        if is_named("FuncArgs") {
+            has_keywords = true;
+            variable_arity = true;
+            continue;
+        }
+        if is_named("KwArgs") {
+            has_keywords = true;
+            variable_arity = true;
+            continue;
+        }
+        if is_named("PosArgs") || is_named("OptionalArg") || is_named("OptionalOption") {
+            variable_arity = true;
+            continue;
+        }
+        fixed_positional += 1;
+    }
+
+    if has_keywords {
+        quote! {
+            rustpython_vm::function::PyMethodFlags::from_bits_retain(
+                rustpython_vm::function::PyMethodFlags::FASTCALL.bits()
+                    | rustpython_vm::function::PyMethodFlags::KEYWORDS.bits()
+            )
+        }
+    } else if variable_arity {
+        quote! { rustpython_vm::function::PyMethodFlags::FASTCALL }
+    } else {
+        match fixed_positional {
+            0 => quote! { rustpython_vm::function::PyMethodFlags::NOARGS },
+            1 => quote! { rustpython_vm::function::PyMethodFlags::O },
+            _ => quote! { rustpython_vm::function::PyMethodFlags::FASTCALL },
+        }
+    }
+}
+
 fn func_sig(sig: &Signature) -> String {
     sig.inputs
         .iter()

diff --git a/crates/vm/src/coroutine.rs b/crates/vm/src/coroutine.rs
@@ -115,27 +115,12 @@ impl Coro {
         result
     }
 
-    pub fn send(
+    fn finalize_send_result(
         &self,
         jen: &PyObject,
-        value: PyObjectRef,
+        result: PyResult<ExecutionResult>,
         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.maybe_close(&result);
         match result {
             Ok(exec_res) => Ok(exec_res.into_iter_return(vm)),
@@ -158,6 +143,44 @@ impl Coro {
         }
     }
 
+    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)
+    }
+
+    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)
+    }
+
     pub fn throw(
         &self,
         jen: &PyObject,