Implement auto_new attribute for #[pyclass] (#5421)

* implement auto_new on pyclasses

* fix double import

* add changelog fragment

* fix import formatting

* auto_new: unrestrict set_all and restrict extends

* update ui test

* cargo fmt

* formatting

* update new impl macro

* update ui test

* ensure generated `__new__` is treated as `#[new]`

* support tuple structs

* add ui test

* fix ui test?

* update UI test

* avoid compile error &str case

* fixup ui test

* make trybuild output stable

* bump to stable trybuild

* add UI test for conflicting `#[new]` implementations

---------

Co-authored-by: David Hewitt <mail@davidhewitt.dev>

Author: RedKinda

Cargo.toml

@@ -69,8 +69,7 @@ portable-atomic = "1.0"
 assert_approx_eq = "1.1.0"
 chrono = "0.4.25"
 chrono-tz = ">= 0.10, < 0.11"
-# Required for "and $N others" normalization
-trybuild = ">=1.0.70"
+trybuild = ">=1.0.115"
 proptest = { version = "1.0", default-features = false, features = ["std"] }
 send_wrapper = "0.6"
 serde = { version = "1.0", features = ["derive"] }

guide/pyclass-parameters.md

@@ -22,6 +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. |
+| `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. |

newsfragments/5421.added.md

@@ -0,0 +1 @@
+Implement `new = "from_fields"` attribute for `#[pyclass]`

pyo3-macros-backend/src/attributes.rs

@@ -40,6 +40,7 @@ pub mod kw {
     syn::custom_keyword!(sequence);
     syn::custom_keyword!(set);
     syn::custom_keyword!(set_all);
+    syn::custom_keyword!(new);
     syn::custom_keyword!(signature);
     syn::custom_keyword!(str);
     syn::custom_keyword!(subclass);
@@ -311,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>;
 

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")]
@@ -88,6 +89,7 @@ pub struct PyClassPyO3Options {
     pub rename_all: Option<RenameAllAttribute>,
     pub sequence: Option<kw::sequence>,
     pub set_all: Option<kw::set_all>,
+    pub new: Option<NewImplTypeAttribute>,
     pub str: Option<StrFormatterAttribute>,
     pub subclass: Option<kw::subclass>,
     pub unsendable: Option<kw::unsendable>,
@@ -115,6 +117,7 @@ pub enum PyClassPyO3Option {
     RenameAll(RenameAllAttribute),
     Sequence(kw::sequence),
     SetAll(kw::set_all),
+    New(NewImplTypeAttribute),
     Str(StrFormatterAttribute),
     Subclass(kw::subclass),
     Unsendable(kw::unsendable),
@@ -161,6 +164,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::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) {
@@ -243,6 +248,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::New(new) => set_option!(new),
             PyClassPyO3Option::Str(str) => set_option!(str),
             PyClassPyO3Option::Subclass(subclass) => set_option!(subclass),
             PyClassPyO3Option::Unsendable(unsendable) => set_option!(unsendable),
@@ -488,6 +494,13 @@ fn impl_class(
         }
     }
 
+    let (default_new, default_new_slot) = pyclass_new_impl(
+        &args.options,
+        &syn::parse_quote!(#cls),
+        field_options.iter().map(|(f, _)| f),
+        ctx,
+    )?;
+
     let mut default_methods = descriptors_to_items(
         cls,
         args.options.rename_all.as_ref(),
@@ -516,6 +529,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 impl_builder =
         PyClassImplsBuilder::new(cls, cls, args, methods_type, default_methods, slots).doc(doc);
@@ -543,6 +557,7 @@ fn impl_class(
             #default_richcmp
             #default_hash
             #default_str
+            #default_new
             #default_class_getitem
         }
     })
@@ -1711,11 +1726,11 @@ fn generate_protocol_slot(
 ) -> syn::Result<MethodAndSlotDef> {
     let spec = FnSpec::parse(
         &mut method.sig,
-        &mut Vec::new(),
+        &mut method.attrs,
         PyFunctionOptions::default(),
     )?;
     #[cfg_attr(not(feature = "experimental-inspect"), allow(unused_mut))]
-    let mut def = slot.generate_type_slot(&syn::parse_quote!(#cls), &spec, name, ctx)?;
+    let mut def = slot.generate_type_slot(cls, &spec, name, ctx)?;
     #[cfg(feature = "experimental-inspect")]
     def.add_introspection(introspection_data.generate(ctx, cls));
     Ok(def)
@@ -2431,6 +2446,94 @@ fn pyclass_hash(
     }
 }
 
+fn pyclass_new_impl<'a>(
+    options: &PyClassPyO3Options,
+    ty: &syn::Type,
+    fields: impl Iterator<Item = &'a &'a syn::Field>,
+    ctx: &Ctx,
+) -> 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.new.span() => "The `new=\"from_fields\"` option cannot be used with `extends`.";
+        );
+    }
+
+    let mut tuple_struct: bool = false;
+
+    match &options.new {
+        Some(opt) => {
+            let mut field_idents = vec![];
+            let mut field_types = vec![];
+            for (idx, field) in fields.enumerate() {
+                tuple_struct = field.ident.is_none();
+
+                field_idents.push(
+                    field
+                        .ident
+                        .clone()
+                        .unwrap_or_else(|| format_ident!("_{}", idx)),
+                );
+                field_types.push(&field.ty);
+            }
+
+            let mut new_impl = if tuple_struct {
+                parse_quote_spanned! { opt.span() =>
+                    #[new]
+                    fn __pyo3_generated____new__( #( #field_idents : #field_types ),* ) -> Self {
+                        Self (
+                            #( #field_idents, )*
+                        )
+                    }
+                }
+            } else {
+                parse_quote_spanned! { opt.span() =>
+                    #[new]
+                    fn __pyo3_generated____new__( #( #field_idents : #field_types ),* ) -> Self {
+                        Self {
+                            #( #field_idents, )*
+                        }
+                    }
+                }
+            };
+
+            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)),
+    }
+}
+
 fn pyclass_class_getitem(
     options: &PyClassPyO3Options,
     cls: &syn::Type,

tests/test_class_attributes.rs

@@ -235,6 +235,42 @@ 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"
+        );
+    });
+}
+
+#[pyclass(new = "from_fields", get_all)]
+struct Point2d(#[pyo3(name = "first")] f64, #[pyo3(name = "second")] f64);
+
+#[test]
+fn new_impl_tuple_struct() {
+    Python::attach(|py| {
+        // python should be able to do AutoNewCls(1, "two", 3.0)
+        let cls = py.get_type::<Point2d>();
+        pyo3::py_run!(
+            py,
+            cls,
+            "inst = cls(0.2, 0.3); assert inst.first == 0.2; assert inst.second == 0.3"
+        );
+    });
+}
+
 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)]

tests/test_compile_error.rs

@@ -9,6 +9,7 @@ fn test_compile_errors() {
     #[cfg(not(feature = "experimental-inspect"))]
     t.compile_fail("tests/ui/invalid_property_args.rs");
     t.compile_fail("tests/ui/invalid_proto_pymethods.rs");
+    #[cfg(not(all(Py_LIMITED_API, not(Py_3_10))))] // to avoid PyFunctionArgument for &str
     t.compile_fail("tests/ui/invalid_pyclass_args.rs");
     t.compile_fail("tests/ui/invalid_pyclass_doc.rs");
     t.compile_fail("tests/ui/invalid_pyclass_enum.rs");
@@ -19,6 +20,7 @@ fn test_compile_errors() {
     #[cfg(Py_3_9)]
     t.compile_fail("tests/ui/pyclass_generic_enum.rs");
     #[cfg(not(feature = "experimental-inspect"))]
+    #[cfg(not(all(Py_LIMITED_API, not(Py_3_10))))] // to avoid PyFunctionArgument for &str
     t.compile_fail("tests/ui/invalid_pyfunction_argument.rs");
     t.compile_fail("tests/ui/invalid_pyfunction_definition.rs");
     t.compile_fail("tests/ui/invalid_pyfunction_signatures.rs");

tests/ui/invalid_pyclass_args.rs

@@ -200,4 +200,22 @@ struct StructImplicitFromPyObjectDeprecated {
     b: String,
 }
 
+#[pyclass(new = "from_fields")]
+struct NonPythonField {
+    field: Box<dyn std::error::Error + Send + Sync>,
+}
+
+#[pyclass(new = "from_fields")]
+struct NewFromFieldsWithManualNew {
+    field: i32,
+}
+
+#[pymethods]
+impl NewFromFieldsWithManualNew {
+    #[new]
+    fn new(field: i32) -> Self {
+        Self { field }
+    }
+}
+
 fn main() {}