add rename_all support for #[derive(IntoPyObject)] (#5112)

Author: Icxolu

newsfragments/5112.added.md

@@ -0,0 +1 @@
+add `rename_all` support for `#[derive(IntoPyObject)]`

pyo3-macros-backend/src/intopyobject.rs

@@ -1,6 +1,6 @@
-use crate::attributes::IntoPyWithAttribute;
+use crate::attributes::{IntoPyWithAttribute, RenamingRule};
 use crate::derive_attributes::{ContainerAttributes, FieldAttributes};
-use crate::utils::Ctx;
+use crate::utils::{self, Ctx};
 use proc_macro2::{Span, TokenStream};
 use quote::{format_ident, quote, quote_spanned, ToTokens};
 use syn::ext::IdentExt;
@@ -65,6 +65,7 @@ struct Container<'a, const REF: bool> {
     path: syn::Path,
     receiver: Option<Ident>,
     ty: ContainerType<'a>,
+    rename_rule: Option<RenamingRule>,
 }
 
 /// Construct a container based on fields, identifier and attributes.
@@ -79,6 +80,10 @@ impl<'a, const REF: bool> Container<'a, REF> {
     ) -> Result<Self> {
         let style = match fields {
             Fields::Unnamed(unnamed) if !unnamed.unnamed.is_empty() => {
+                ensure_spanned!(
+                    options.rename_all.is_none(),
+                    options.rename_all.span() => "`rename_all` is useless on tuple structs and variants."
+                );
                 let mut tuple_fields = unnamed
                     .unnamed
                     .iter()
@@ -127,6 +132,10 @@ impl<'a, const REF: bool> Container<'a, REF> {
                         attrs.getter.is_none(),
                         attrs.getter.unwrap().span() => "`transparent` structs may not have `item` nor `attribute` for the inner field"
                     );
+                    ensure_spanned!(
+                        options.rename_all.is_none(),
+                        options.rename_all.span() => "`rename_all` is not permitted on `transparent` structs and variants"
+                    );
                     ensure_spanned!(
                         attrs.into_py_with.is_none(),
                         attrs.into_py_with.span() => "`into_py_with` is not permitted on `transparent` structs or variants"
@@ -169,6 +178,7 @@ impl<'a, const REF: bool> Container<'a, REF> {
             path,
             receiver,
             ty: style,
+            rename_rule: options.rename_all.map(|v| v.value.rule),
         };
         Ok(v)
     }
@@ -254,7 +264,10 @@ impl<'a, const REF: bool> Container<'a, REF> {
                     .as_ref()
                     .and_then(|item| item.0.as_ref())
                     .map(|item| item.into_token_stream())
-                    .unwrap_or_else(|| f.ident.unraw().to_string().into_token_stream());
+                    .unwrap_or_else(|| {
+                        let name = f.ident.unraw().to_string();
+                        self.rename_rule.map(|rule| utils::apply_renaming_rule(rule, &name)).unwrap_or(name).into_token_stream()
+                    });
                 let value = Ident::new(&format!("arg{i}"), f.field.ty.span());
 
                 if let Some(expr_path) = f.into_py_with.as_ref().map(|i|&i.value) {
@@ -459,6 +472,9 @@ pub fn build_derive_into_pyobject<const REF: bool>(tokens: &DeriveInput) -> Resu
             if options.transparent.is_some() {
                 bail_spanned!(tokens.span() => "`transparent` is not supported at top level for enums");
             }
+            if let Some(rename_all) = options.rename_all {
+                bail_spanned!(rename_all.span() => "`rename_all` is not supported at top level for enums");
+            }
             let en = Enum::<REF>::new(en, &tokens.ident)?;
             en.build(ctx)
         }

tests/test_frompy_intopy_roundtrip.rs

@@ -225,6 +225,11 @@ pub enum Foo {
     TransparentStructVar {
         a: Option<String>,
     },
+    #[pyo3(rename_all = "camelCase", from_item_all)]
+    RenameAll {
+        long_field_name: [u16; 2],
+        other_field: Option<String>,
+    },
 }
 
 #[test]
@@ -270,5 +275,15 @@ fn test_enum() {
 
         let foo = transparent_struct_var.clone().into_pyobject(py).unwrap();
         assert_eq!(transparent_struct_var, foo.extract::<Foo>().unwrap());
+
+        let rename_all_struct_var = Foo::RenameAll {
+            long_field_name: [1, 2],
+            other_field: None,
+        };
+        let foo = (&rename_all_struct_var).into_pyobject(py).unwrap();
+        assert_eq!(rename_all_struct_var, foo.extract::<Foo>().unwrap());
+
+        let foo = rename_all_struct_var.clone().into_pyobject(py).unwrap();
+        assert_eq!(rename_all_struct_var, foo.extract::<Foo>().unwrap());
     });
 }

tests/test_intopyobject.rs

@@ -252,3 +252,38 @@ fn test_into_py_with() {
         );
     });
 }
+
+#[test]
+fn test_struct_into_py_rename_all() {
+    #[derive(IntoPyObject, IntoPyObjectRef)]
+    #[pyo3(rename_all = "camelCase")]
+    struct Foo {
+        foo_bar: String,
+        #[pyo3(item("BAZ"))]
+        baz: usize,
+        #[pyo3(item)]
+        long_field_name: f32,
+    }
+
+    let foo = Foo {
+        foo_bar: "foobar".into(),
+        baz: 42,
+        long_field_name: 0.0,
+    };
+
+    Python::with_gil(|py| {
+        let py_foo_ref = (&foo).into_pyobject(py).unwrap();
+        let py_foo = foo.into_pyobject(py).unwrap();
+
+        py_run!(
+            py,
+            py_foo_ref,
+            "assert py_foo_ref == {'fooBar': 'foobar', 'BAZ': 42, 'longFieldName': 0},f'{py_foo_ref}'"
+        );
+        py_run!(
+            py,
+            py_foo,
+            "assert py_foo == {'fooBar': 'foobar', 'BAZ': 42, 'longFieldName': 0},f'{py_foo}'"
+        );
+    });
+}

tests/ui/invalid_intopy_derive.rs

@@ -138,4 +138,33 @@ enum EnumStructIntoPyWith {
     },
 }
 
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(transparent, rename_all = "camelCase")]
+struct StructTransparentRenameAll {
+    foo_bar: String,
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(rename_all = "camelCase")]
+struct StructTupleRenameAll(String, usize);
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EnumTransparentVariantRenameAll {
+    #[pyo3(rename_all = "camelCase")]
+    #[pyo3(transparent)]
+    Variant { foo: String },
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EnumTupleVariantRenameAll {
+    #[pyo3(rename_all = "camelCase")]
+    Variant(String, usize),
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(rename_all = "camelCase")]
+enum EnumTopRenameAll {
+    Variant { foo: String },
+}
+
 fn main() {}

tests/ui/invalid_intopy_derive.stderr

@@ -149,3 +149,33 @@ error: `into_py_with` is not permitted on `transparent` structs or variants
     |
 136 |         #[pyo3(into_py_with = into)]
     |                ^^^^^^^^^^^^
+
+error: `rename_all` is not permitted on `transparent` structs and variants
+   --> tests/ui/invalid_intopy_derive.rs:142:21
+    |
+142 | #[pyo3(transparent, rename_all = "camelCase")]
+    |                     ^^^^^^^^^^
+
+error: `rename_all` is useless on tuple structs and variants.
+   --> tests/ui/invalid_intopy_derive.rs:148:8
+    |
+148 | #[pyo3(rename_all = "camelCase")]
+    |        ^^^^^^^^^^
+
+error: `rename_all` is not permitted on `transparent` structs and variants
+   --> tests/ui/invalid_intopy_derive.rs:153:12
+    |
+153 |     #[pyo3(rename_all = "camelCase")]
+    |            ^^^^^^^^^^
+
+error: `rename_all` is useless on tuple structs and variants.
+   --> tests/ui/invalid_intopy_derive.rs:160:12
+    |
+160 |     #[pyo3(rename_all = "camelCase")]
+    |            ^^^^^^^^^^
+
+error: `rename_all` is not supported at top level for enums
+   --> tests/ui/invalid_intopy_derive.rs:165:8
+    |
+165 | #[pyo3(rename_all = "camelCase")]
+    |        ^^^^^^^^^^