implement auto_new on pyclasses

Author: RedKinda

guide/pyclass-parameters.md

@@ -21,6 +21,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` |
 | `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. |
 | `unsendable` | Required if your struct is not [`Send`][params-3]. Rather than using `unsendable`, consider implementing your struct in a thread-safe way by e.g. substituting [`Rc`][params-4] with [`Arc`][params-5]. By using `unsendable`, your class will panic when accessed by another thread. Also note the Python's GC is multi-threaded and while unsendable classes will not be traversed on foreign threads to avoid UB, this can lead to memory leaks. |

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!(auto_new);
     syn::custom_keyword!(signature);
     syn::custom_keyword!(str);
     syn::custom_keyword!(subclass);

pyo3-macros-backend/src/pyclass.rs

@@ -8,6 +8,7 @@ use syn::parse::{Parse, ParseStream};
 use syn::punctuated::Punctuated;
 use syn::{parse_quote, parse_quote_spanned, spanned::Spanned, ImplItemFn, Result, Token};
 
+use crate::PyFunctionOptions;
 use crate::attributes::kw::frozen;
 use crate::attributes::{
     self, kw, take_pyo3_options, CrateAttribute, ExtendsAttribute, FreelistAttribute,
@@ -85,6 +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 str: Option<StrFormatterAttribute>,
     pub subclass: Option<kw::subclass>,
     pub unsendable: Option<kw::unsendable>,
@@ -110,6 +112,7 @@ pub enum PyClassPyO3Option {
     RenameAll(RenameAllAttribute),
     Sequence(kw::sequence),
     SetAll(kw::set_all),
+    AutoNew(kw::auto_new),
     Str(StrFormatterAttribute),
     Subclass(kw::subclass),
     Unsendable(kw::unsendable),
@@ -154,6 +157,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::str) {
             input.parse().map(PyClassPyO3Option::Str)
         } else if lookahead.peek(attributes::kw::subclass) {
@@ -232,6 +237,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::Str(str) => set_option!(str),
             PyClassPyO3Option::Subclass(subclass) => set_option!(subclass),
             PyClassPyO3Option::Unsendable(unsendable) => set_option!(unsendable),
@@ -444,6 +450,14 @@ fn impl_class(
         }
     }
 
+    let auto_new = pyclass_auto_new(
+        &args.options,
+        cls,
+        field_options.iter().map(|(f, _)| f),
+        methods_type,
+        ctx,
+    )?;
+
     let mut default_methods = descriptors_to_items(
         cls,
         args.options.rename_all.as_ref(),
@@ -484,6 +498,8 @@ fn impl_class(
 
         #py_class_impl
 
+        #auto_new
+
         #[doc(hidden)]
         #[allow(non_snake_case)]
         impl #cls {
@@ -2203,6 +2219,58 @@ fn pyclass_hash(
     }
 }
 
+fn pyclass_auto_new<'a>(
+    options: &PyClassPyO3Options,
+    cls: &syn::Ident,
+    fields: impl Iterator<Item = &'a &'a syn::Field>,
+    methods_type: PyClassMethodsType,
+    ctx: &Ctx,
+) -> Result<Option<syn::ItemImpl>> {
+    if options.auto_new.is_some() {
+        ensure_spanned!(
+            options.set_all.is_some(), options.hash.span() => "The `auto_new` option requires the `set_all` option.";
+        );
+    }
+    match options.auto_new {
+        Some(opt) => {
+            if matches!(methods_type, PyClassMethodsType::Specialization) {
+                bail_spanned!(opt.span() => "`auto_new` requires the `multiple-pymethods` feature.");
+            }
+
+            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);
+                }
+
+                parse_quote_spanned! { opt.span() =>
+                    #[#pyo3_path::pymethods]
+                    impl #cls {
+                        #[new]
+                        fn _pyo3_generated_new( #( #field_idents : #field_types ),* ) -> Self {
+                            Self {
+                                #( #field_idents, )*
+                            }
+                        }
+                    }
+
+                }
+            };
+
+            Ok(Some(autonew_impl))
+        }
+        None => Ok(None),
+    }
+}
+
 fn pyclass_class_geitem(
     options: &PyClassPyO3Options,
     cls: &syn::Type,

tests/test_multiple_pymethods.rs

@@ -73,3 +73,23 @@ 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"
+        );
+    });
+}