@@ -2,7 +2,7 @@ use proc_macro2::TokenStream;
 use quote::{ToTokens, quote};
 use syn::ext::IdentExt;
 use syn::meta::ParseNestedMeta;
-use syn::{Attribute, Data, DeriveInput, Expr, Field, Ident, Result, Token, parse_quote};
+use syn::{Attribute, Data, DeriveInput, Expr, Field, Ident, Lit, Result, Token, parse_quote};
 
 /// The kind of the python parameter, this corresponds to the value of Parameter.kind
 /// (https://docs.python.org/3/library/inspect.html#inspect.Parameter.kind)
@@ -229,28 +229,104 @@ fn compute_arity_bounds(field_attrs: &[ArgAttribute]) -> (usize, usize) {
     (min_arity, max_arity)
 }
 
+fn python_default_repr(default: Option<&DefaultValue>) -> Option<String> {
+    match default {
+        None => None,
+        Some(None) => Some("None".to_owned()),
+        Some(Some(expr)) => match expr {
+            Expr::Lit(syn::ExprLit { lit, .. }) => match lit {
+                Lit::Bool(b) => Some(if b.value {
+                    "True".to_owned()
+                } else {
+                    "False".to_owned()
+                }),
+                Lit::Int(i) => Some(i.base10_digits().to_owned()),
+                Lit::Float(f) => Some(f.base10_digits().to_owned()),
+                Lit::Str(s) => Some(format!("'{}'", s.value())),
+                _ => Some("None".to_owned()),
+            },
+            _ => Some("None".to_owned()),
+        },
+    }
+}
+
 pub(crate) fn impl_from_args(input: DeriveInput) -> Result<TokenStream> {
-    let (fields, field_attrs) = match input.data {
-        Data::Struct(syn::DataStruct { fields, .. }) => (
-            fields
-                .iter()
-                .enumerate()
-                .map(generate_field)
-                .collect::<Result<TokenStream>>()?,
-            fields
-                .iter()
-                .filter_map(|field| field.try_into().ok())
-                .collect::<Vec<ArgAttribute>>(),
-        ),
+    let struct_fields = match input.data {
+        Data::Struct(syn::DataStruct { fields, .. }) => fields,
         _ => bail_span!(input, "FromArgs input must be a struct"),
     };
 
+    let generated_fields = struct_fields
+        .iter()
+        .enumerate()
+        .map(generate_field)
+        .collect::<Result<TokenStream>>()?;
+    let field_attrs = struct_fields
+        .iter()
+        .filter_map(|field| field.try_into().ok())
+        .collect::<Vec<ArgAttribute>>();
+
     let (min_arity, max_arity) = compute_arity_bounds(&field_attrs);
 
+    let takes_keywords_named = field_attrs.iter().any(|attr| {
+        matches!(
+            attr.kind,
+            ParameterKind::KeywordOnly | ParameterKind::PositionalOrKeyword
+        )
+    });
+    let flatten_tys = struct_fields
+        .iter()
+        .zip(&field_attrs)
+        .filter(|(_, attr)| attr.kind == ParameterKind::Flatten)
+        .map(|(field, _)| field.ty.clone())
+        .collect::<Vec<_>>();
+    let takes_keywords = quote! {
+        #takes_keywords_named #(|| <#flatten_tys as ::rustpython_vm::function::FromArgs>::TAKES_KEYWORDS)*
+    };
+    let variable_arity = {
+        let from_bounds = min_arity != max_arity;
+        quote! {
+            #from_bounds #(|| <#flatten_tys as ::rustpython_vm::function::FromArgs>::VARIABLE_ARITY)*
+        }
+    };
+
+    let all_keyword_only = !field_attrs.is_empty()
+        && field_attrs
+            .iter()
+            .all(|attr| attr.kind == ParameterKind::KeywordOnly);
+    let keyword_only_signature = if all_keyword_only {
+        let mut parts = Vec::new();
+        for (field, attr) in struct_fields.iter().zip(&field_attrs) {
+            let Some(name) = attr
+                .name
+                .clone()
+                .or_else(|| field.ident.as_ref().map(|ident| ident.unraw().to_string()))
+            else {
+                continue;
+            };
+            if let Some(default) = python_default_repr(attr.default.as_ref()) {
+                parts.push(format!("{name}={default}"));
+            } else {
+                parts.push(name);
+            }
+        }
+        let joined = parts.join(", ");
+        quote!(Some(#joined))
+    } else {
+        quote!(None)
+    };
+
+    let max_positional = if all_keyword_only { 0 } else { max_arity };
+
     let name = input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
     let output = quote! {
         impl #impl_generics ::rustpython_vm::function::FromArgs for #name #ty_generics #where_clause {
+            const TAKES_KEYWORDS: bool = #takes_keywords;
+            const VARIABLE_ARITY: bool = #variable_arity;
+            const MAX_POSITIONAL: usize = #max_positional;
+            const KEYWORD_ONLY_SIGNATURE: Option<&'static str> = #keyword_only_signature;
+
             fn arity() -> ::std::ops::RangeInclusive<usize> {
                 #min_arity..=#max_arity
             }
@@ -259,7 +335,7 @@ pub(crate) fn impl_from_args(input: DeriveInput) -> Result<TokenStream> {
                 vm: &::rustpython_vm::VirtualMachine,
                 args: &mut ::rustpython_vm::function::FuncArgs
             ) -> ::core::result::Result<Self, ::rustpython_vm::function::ArgumentError> {
-                Ok(Self { #fields })
+                Ok(Self { #generated_fields })
             }
         }
     };
 
@@ -2,7 +2,7 @@ use super::Diagnostic;
 use crate::util::{
     ALL_ALLOWED_NAMES, ClassItemMeta, ContentItem, ContentItemInner, ErrorVec, ExceptionItemMeta,
     ItemMeta, ItemMetaInner, ItemNursery, SimpleItemMeta, format_doc, infer_native_call_flags,
-    pyclass_ident_and_attrs, pyexception_ident_and_attrs, text_signature,
+    pyclass_ident_and_attrs, pyexception_ident_and_attrs, sig_parts_tokens, text_signature,
 };
 use core::str::FromStr;
 use proc_macro2::{Delimiter, Group, Span, TokenStream, TokenTree};
@@ -1125,6 +1125,12 @@ where
         let drop_first_typed = usize::from(implicit_self.is_some());
         let sig_doc = text_signature(func.sig(), &py_name, implicit_self);
         let call_flags = infer_native_call_flags(func.sig(), drop_first_typed);
+        let sig_parts = sig_parts_tokens(func.sig(), implicit_self).unwrap_or_else(|| {
+            quote! {{
+                const __SIG_PARTS: &'static [rustpython_vm::function::SigPart] = &[];
+                __SIG_PARTS
+            }}
+        });
 
         // Add #[allow(non_snake_case)] for setter methods like set___name__
         let method_name = ident.to_string();
@@ -1147,6 +1153,7 @@ where
             coexist,
             attr_name: self.inner.attr_name,
             call_flags,
+            sig_parts,
         });
         Ok(())
     }
@@ -1376,6 +1383,7 @@ struct MethodNurseryItem {
     doc: Option<String>,
     attr_name: AttrName,
     call_flags: TokenStream,
+    sig_parts: TokenStream,
 }
 
 impl MethodNursery {
@@ -1441,13 +1449,15 @@ impl ToTokens for MethodNursery {
             } else {
                 quote!(new_const)
             };
+            let sig_parts = &item.sig_parts;
             inner_tokens.extend(quote! [
                 #(#cfgs)*
                 rustpython_vm::function::PyMethodDef::#method_new(
                     #py_name,
                     Self::#ident,
                     #flags,
                     #doc,
+                    #sig_parts,
                 ),
             ]);
         }
 
@@ -3,7 +3,8 @@ use crate::pystructseq::PyStructSequenceMeta;
 use crate::util::{
     ALL_ALLOWED_NAMES, AttrItemMeta, AttributeExt, ClassItemMeta, ContentItem, ContentItemInner,
     ErrorVec, ItemMeta, ItemNursery, ModuleItemMeta, SimpleItemMeta, format_doc,
-    infer_native_call_flags, iter_use_idents, pyclass_ident_and_attrs, text_signature,
+    infer_native_call_flags, iter_use_idents, pyclass_ident_and_attrs, sig_parts_tokens,
+    text_signature,
 };
 use core::str::FromStr;
 use proc_macro2::{Delimiter, Group, TokenStream, TokenTree};
@@ -526,6 +527,7 @@ struct FunctionNurseryItem {
     ident: Ident,
     doc: Option<String>,
     call_flags: TokenStream,
+    sig_parts: TokenStream,
 }
 
 impl FunctionNursery {
@@ -561,6 +563,7 @@ impl ToTokens for ValidatedFunctionNursery {
                 None => quote!(None),
             };
             let flags = &item.call_flags;
+            let sig_parts = &item.sig_parts;
 
             inner_tokens.extend(quote![
                 #(
@@ -570,6 +573,7 @@ impl ToTokens for ValidatedFunctionNursery {
                         #ident,
                         #flags,
                         #doc,
+                        #sig_parts,
                     ),
                 )*
             ]);
@@ -665,6 +669,12 @@ impl ModuleItem for FunctionItem {
 
         let py_name = item_meta.simple_name()?;
         let sig_doc = text_signature(func.sig(), &py_name, None);
+        let sig_parts = sig_parts_tokens(func.sig(), None).unwrap_or_else(|| {
+            quote! {{
+                const __SIG_PARTS: &'static [rustpython_vm::function::SigPart] = &[];
+                __SIG_PARTS
+            }}
+        });
 
         let module = args.module_name();
         // TODO: doc must exist at least one of code or CPython
@@ -716,6 +726,7 @@ impl ModuleItem for FunctionItem {
             cfgs: args.cfgs.to_vec(),
             doc,
             call_flags,
+            sig_parts,
         });
         Ok(())
     }