update new impl macro

RedKinda · RedKinda · commit 10175ac13019 · 2025-11-19T00:33:53.000+01:00
diff --git a/guide/pyclass-parameters.md b/guide/pyclass-parameters.md
@@ -22,7 +22,7 @@
 | `rename_all = "renaming_rule"` | Applies renaming rules to every getters and setters of a struct, or every variants of an enum. Possible values are: "camelCase", "kebab-case", "lowercase", "PascalCase", "SCREAMING-KEBAB-CASE", "SCREAMING_SNAKE_CASE", "snake_case", "UPPERCASE". |
 | `sequence` |  Inform PyO3 that this class is a [`Sequence`][params-sequence], and so leave its C-API mapping length slot empty. |
 | `set_all` | Generates setters for all fields of the pyclass. |
-| `auto_new` | Generates a default `__new__` constructor, must be used with `set_all` |
+| `new = "from_fields"` | Generates a default `__new__` constructor with all fields as parameters in the `new()` method. |
 | `skip_from_py_object` | Prevents this PyClass from participating in the `FromPyObject: PyClass + Clone` blanket implementation. This allows a custom `FromPyObject` impl, even if `self` is `Clone`. |
 | `str` | Implements `__str__` using the `Display` implementation of the underlying Rust datatype or by passing an optional format string `str="<format string>"`. *Note: The optional format string is only allowed for structs.  `name` and `rename_all` are incompatible with the optional format string.  Additional details can be found in the discussion on this [PR](https://github.com/PyO3/pyo3/pull/4233).* |
 | `subclass` | Allows other Python classes and `#[pyclass]` to inherit from this class. Enums cannot be subclassed. |
diff --git a/newsfragments/5421.added.md b/newsfragments/5421.added.md
@@ -1 +1 @@
-Implement `auto_new` attribute for `#[pyclass]`
+Implement `new = "from_fields"` attribute for `#[pyclass]`
diff --git a/pyo3-macros-backend/src/attributes.rs b/pyo3-macros-backend/src/attributes.rs
@@ -40,7 +40,7 @@ pub mod kw {
     syn::custom_keyword!(sequence);
     syn::custom_keyword!(set);
     syn::custom_keyword!(set_all);
-    syn::custom_keyword!(auto_new);
+    syn::custom_keyword!(new);
     syn::custom_keyword!(signature);
     syn::custom_keyword!(str);
     syn::custom_keyword!(subclass);
@@ -312,13 +312,41 @@ impl ToTokens for TextSignatureAttributeValue {
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum NewImplTypeAttributeValue {
+    FromFields,
+    // Future variant for 'default' should go here
+}
+
+impl Parse for NewImplTypeAttributeValue {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let string_literal: LitStr = input.parse()?;
+        if string_literal.value().as_str() == "from_fields" {
+            Ok(NewImplTypeAttributeValue::FromFields)
+        } else {
+            bail_spanned!(string_literal.span() => "expected \"from_fields\"")
+        }
+    }
+}
+
+impl ToTokens for NewImplTypeAttributeValue {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        match self {
+            NewImplTypeAttributeValue::FromFields => {
+                tokens.extend(quote! { "from_fields" });
+            }
+        }
+    }
+}
+
 pub type ExtendsAttribute = KeywordAttribute<kw::extends, Path>;
 pub type FreelistAttribute = KeywordAttribute<kw::freelist, Box<Expr>>;
 pub type ModuleAttribute = KeywordAttribute<kw::module, LitStr>;
 pub type NameAttribute = KeywordAttribute<kw::name, NameLitStr>;
 pub type RenameAllAttribute = KeywordAttribute<kw::rename_all, RenamingRuleLitStr>;
 pub type StrFormatterAttribute = OptionalKeywordAttribute<kw::str, StringFormatter>;
 pub type TextSignatureAttribute = KeywordAttribute<kw::text_signature, TextSignatureAttributeValue>;
+pub type NewImplTypeAttribute = KeywordAttribute<kw::new, NewImplTypeAttributeValue>;
 pub type SubmoduleAttribute = kw::submodule;
 pub type GILUsedAttribute = KeywordAttribute<kw::gil_used, LitBool>;
 
diff --git a/pyo3-macros-backend/src/pyclass.rs b/pyo3-macros-backend/src/pyclass.rs
@@ -11,7 +11,8 @@ use syn::{parse_quote, parse_quote_spanned, spanned::Spanned, ImplItemFn, Result
 use crate::attributes::kw::frozen;
 use crate::attributes::{
     self, kw, take_pyo3_options, CrateAttribute, ExtendsAttribute, FreelistAttribute,
-    ModuleAttribute, NameAttribute, NameLitStr, RenameAllAttribute, StrFormatterAttribute,
+    ModuleAttribute, NameAttribute, NameLitStr, NewImplTypeAttribute, NewImplTypeAttributeValue,
+    RenameAllAttribute, StrFormatterAttribute,
 };
 use crate::combine_errors::CombineErrors;
 #[cfg(feature = "experimental-inspect")]
@@ -85,7 +86,7 @@ pub struct PyClassPyO3Options {
     pub rename_all: Option<RenameAllAttribute>,
     pub sequence: Option<kw::sequence>,
     pub set_all: Option<kw::set_all>,
-    pub auto_new: Option<kw::auto_new>,
+    pub new: Option<NewImplTypeAttribute>,
     pub str: Option<StrFormatterAttribute>,
     pub subclass: Option<kw::subclass>,
     pub unsendable: Option<kw::unsendable>,
@@ -113,7 +114,7 @@ pub enum PyClassPyO3Option {
     RenameAll(RenameAllAttribute),
     Sequence(kw::sequence),
     SetAll(kw::set_all),
-    AutoNew(kw::auto_new),
+    New(NewImplTypeAttribute),
     Str(StrFormatterAttribute),
     Subclass(kw::subclass),
     Unsendable(kw::unsendable),
@@ -160,8 +161,8 @@ impl Parse for PyClassPyO3Option {
             input.parse().map(PyClassPyO3Option::Sequence)
         } else if lookahead.peek(attributes::kw::set_all) {
             input.parse().map(PyClassPyO3Option::SetAll)
-        } else if lookahead.peek(attributes::kw::auto_new) {
-            input.parse().map(PyClassPyO3Option::AutoNew)
+        } else if lookahead.peek(attributes::kw::new) {
+            input.parse().map(PyClassPyO3Option::New)
         } else if lookahead.peek(attributes::kw::str) {
             input.parse().map(PyClassPyO3Option::Str)
         } else if lookahead.peek(attributes::kw::subclass) {
@@ -244,7 +245,7 @@ impl PyClassPyO3Options {
             PyClassPyO3Option::RenameAll(rename_all) => set_option!(rename_all),
             PyClassPyO3Option::Sequence(sequence) => set_option!(sequence),
             PyClassPyO3Option::SetAll(set_all) => set_option!(set_all),
-            PyClassPyO3Option::AutoNew(auto_new) => set_option!(auto_new),
+            PyClassPyO3Option::New(new) => set_option!(new),
             PyClassPyO3Option::Str(str) => set_option!(str),
             PyClassPyO3Option::Subclass(subclass) => set_option!(subclass),
             PyClassPyO3Option::Unsendable(unsendable) => set_option!(unsendable),
@@ -473,11 +474,10 @@ fn impl_class(
         }
     }
 
-    let auto_new = pyclass_auto_new(
+    let (default_new, default_new_slot) = pyclass_new_impl(
         &args.options,
-        cls,
+        &syn::parse_quote!(#cls),
         field_options.iter().map(|(f, _)| f),
-        methods_type,
         ctx,
     )?;
 
@@ -509,6 +509,7 @@ fn impl_class(
     slots.extend(default_richcmp_slot);
     slots.extend(default_hash_slot);
     slots.extend(default_str_slot);
+    slots.extend(default_new_slot);
 
     let py_class_impl = PyClassImplsBuilder::new(cls, args, methods_type, default_methods, slots)
         .doc(doc)
@@ -521,14 +522,13 @@ fn impl_class(
 
         #py_class_impl
 
-        #auto_new
-
         #[doc(hidden)]
         #[allow(non_snake_case)]
         impl #cls {
             #default_richcmp
             #default_hash
             #default_str
+            #default_new
             #default_class_getitem
         }
     })
@@ -2241,56 +2241,77 @@ fn pyclass_hash(
     }
 }
 
-fn pyclass_auto_new<'a>(
+fn pyclass_new_impl<'a>(
     options: &PyClassPyO3Options,
-    cls: &syn::Ident,
+    ty: &syn::Type,
     fields: impl Iterator<Item = &'a &'a syn::Field>,
-    methods_type: PyClassMethodsType,
     ctx: &Ctx,
-) -> Result<Option<syn::ItemImpl>> {
-    if options.auto_new.is_some() {
+) -> Result<(Option<ImplItemFn>, Option<MethodAndSlotDef>)> {
+    if options
+        .new
+        .as_ref()
+        .is_some_and(|o| matches!(o.value, NewImplTypeAttributeValue::FromFields))
+    {
         ensure_spanned!(
-            options.extends.is_none(), options.hash.span() => "The `auto_new` option cannot be used with `extends`.";
+            options.extends.is_none(), options.new.span() => "The `new=\"from_fields\"` option cannot be used with `extends`.";
         );
     }
 
-    match options.auto_new {
+    match &options.new {
         Some(opt) => {
-            if matches!(methods_type, PyClassMethodsType::Specialization) {
-                bail_spanned!(opt.span() => "`auto_new` requires the `multiple-pymethods` feature.");
+            let mut field_idents = vec![];
+            let mut field_types = vec![];
+            for (idx, field) in fields.enumerate() {
+                field_idents.push(
+                    field
+                        .ident
+                        .clone()
+                        .unwrap_or_else(|| format_ident!("_{}", idx)),
+                );
+                field_types.push(&field.ty);
             }
 
-            let autonew_impl = {
-                let Ctx { pyo3_path, .. } = ctx;
-                let mut field_idents = vec![];
-                let mut field_types = vec![];
-                for (idx, field) in fields.enumerate() {
-                    field_idents.push(
-                        field
-                            .ident
-                            .clone()
-                            .unwrap_or_else(|| format_ident!("_{}", idx)),
-                    );
-                    field_types.push(&field.ty);
-                }
-
+            let mut new_impl = {
                 parse_quote_spanned! { opt.span() =>
-                    #[#pyo3_path::pymethods]
-                    impl #cls {
-                        #[new]
-                        fn _pyo3_generated_new( #( #field_idents : #field_types ),* ) -> Self {
-                            Self {
-                                #( #field_idents, )*
-                            }
+                    fn __pyo3_generated____new__( #( #field_idents : #field_types ),* ) -> Self {
+                        Self {
+                            #( #field_idents, )*
                         }
                     }
-
                 }
             };
 
-            Ok(Some(autonew_impl))
+            let new_slot = generate_protocol_slot(
+                ty,
+                &mut new_impl,
+                &__NEW__,
+                "__new__",
+                #[cfg(feature = "experimental-inspect")]
+                FunctionIntrospectionData {
+                    names: &["__new__"],
+                    arguments: field_idents
+                        .iter()
+                        .zip(field_types.iter())
+                        .map(|(ident, ty)| {
+                            FnArg::Regular(RegularArg {
+                                name: Cow::Owned(ident.clone()),
+                                ty,
+                                from_py_with: None,
+                                default_value: None,
+                                option_wrapped_type: None,
+                                annotation: None,
+                            })
+                        })
+                        .collect(),
+                    returns: ty.clone(),
+                },
+                ctx,
+            )
+            .unwrap();
+
+            Ok((Some(new_impl), Some(new_slot)))
         }
-        None => Ok(None),
+        None => Ok((None, None)),
     }
 }
 
diff --git a/tests/test_class_attributes.rs b/tests/test_class_attributes.rs
@@ -235,6 +235,26 @@ fn test_renaming_all_struct_fields() {
     });
 }
 
+#[pyclass(get_all, set_all, new = "from_fields")]
+struct AutoNewCls {
+    a: i32,
+    b: String,
+    c: Option<f64>,
+}
+
+#[test]
+fn new_impl() {
+    Python::attach(|py| {
+        // python should be able to do AutoNewCls(1, "two", 3.0)
+        let cls = py.get_type::<AutoNewCls>();
+        pyo3::py_run!(
+            py,
+            cls,
+            "inst = cls(1, 'two', 3.0); assert inst.a == 1; assert inst.b == 'two'; assert inst.c == 3.0"
+        );
+    });
+}
+
 macro_rules! test_case {
     ($struct_name: ident, $rule: literal, $field_name: ident, $renamed_field_name: literal, $test_name: ident) => {
         #[pyclass(get_all, set_all, rename_all = $rule)]
diff --git a/tests/test_multiple_pymethods.rs b/tests/test_multiple_pymethods.rs
@@ -73,23 +73,3 @@ fn test_class_with_multiple_pymethods() {
         py_assert!(py, cls, "cls.CLASS_ATTRIBUTE == 'CLASS_ATTRIBUTE'");
     })
 }
-
-#[pyclass(get_all, set_all, auto_new)]
-struct AutoNewCls {
-    a: i32,
-    b: String,
-    c: Option<f64>,
-}
-
-#[test]
-fn auto_new() {
-    Python::attach(|py| {
-        // python should be able to do AutoNewCls(1, "two", 3.0)
-        let cls = py.get_type::<AutoNewCls>();
-        pyo3::py_run!(
-            py,
-            cls,
-            "inst = cls(1, 'two', 3.0); assert inst.a == 1; assert inst.b == 'two'; assert inst.c == 3.0"
-        );
-    });
-}

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		-Implement `auto_new` attribute for `#[pyclass]`
	`1`	+Implement `new = "from_fields"` attribute for `#[pyclass]`