RustPython · youknowone · Mar 26, 2025 · Sep 8, 2024
diff --git a/.cspell.json b/.cspell.json
@@ -148,6 +148,7 @@
    "origname",
    "posixsubprocess",
    "pyexpat",
+    "pytraverse",
    "PYTHONDEBUG",
    "PYTHONHOME",
    "PYTHONINSPECT",

diff --git a/derive-impl/src/pystructseq.rs b/derive-impl/src/pystructseq.rs
@@ -1,41 +1,93 @@
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{DeriveInput, Ident, Result};
+use syn_ext::ext::{AttributeExt, GetIdent};
+use syn_ext::types::Meta;

-fn field_names(input: &DeriveInput) -> Result<Vec<&Ident>> {
-    let fields = if let syn::Data::Struct(ref struc) = input.data {
-        &struc.fields
-    } else {
+// returning a pair of not-skipped and skipped field names
+fn field_names(input: &mut DeriveInput) -> Result<(Vec<Ident>, Vec<Ident>)> {
+    let syn::Data::Struct(struc) = &mut input.data else {
        bail_span!(
            input,
            "#[pystruct_sequence] can only be on a struct declaration"
        )
    };

-    let field_names: Vec<_> = match fields {
-        syn::Fields::Named(fields) => fields
-            .named
-            .iter()
-            .map(|field| field.ident.as_ref().unwrap())
-            .collect(),
-        _ => bail_span!(
+    let syn::Fields::Named(fields) = &mut struc.fields else {
+        bail_span!(
            input,
            "#[pystruct_sequence] can only be on a struct with named fields"
-        ),
+        );
    };

-    Ok(field_names)
+    let mut not_skipped = Vec::with_capacity(fields.named.len());
+    let mut skipped = Vec::with_capacity(fields.named.len());
+    for field in &mut fields.named {
+        let mut skip = false;
+        // Collect all attributes with pystruct and their indices
+        let mut attrs_to_remove = Vec::new();
+
+        for (i, attr) in field.attrs.iter().enumerate() {
+            if !attr.path().is_ident("pystruct") {
+                continue;
+            }
+
+            let Ok(meta) = attr.parse_meta() else {
+                continue;
+            };
+
+            let Meta::List(l) = meta else {
+                bail_span!(input, "Only #[pystruct(...)] form is allowed");
+            };
+
+            let idents: Vec<_> = l
+                .nested
+                .iter()
+                .filter_map(|n| n.get_ident())
+                .cloned()
+                .collect();
+
+            // Follow #[serde(skip)] convention.
+            // Consider to add skip_serializing and skip_deserializing if required.
+            for ident in idents {
+                match ident.to_string().as_str() {
+                    "skip" => {
+                        skip = true;
+                    }
+                    _ => {
+                        bail_span!(ident, "Unknown item for #[pystruct(...)]")
+                    }
+                }
+            }
+
+            attrs_to_remove.push(i);
+        }
+
+        // Remove attributes in reverse order to maintain valid indices
+        attrs_to_remove.sort_unstable_by(|a, b| b.cmp(a)); // Sort in descending order
+        for index in attrs_to_remove {
+            field.attrs.remove(index);
+        }
+        let ident = field.ident.clone().unwrap();
+        if skip {
+            skipped.push(ident.clone());
+        } else {
+            not_skipped.push(ident.clone());
+        }
+    }
+
+    Ok((not_skipped, skipped))
 }

-pub(crate) fn impl_pystruct_sequence(input: DeriveInput) -> Result<TokenStream> {
-    let field_names = field_names(&input)?;
+pub(crate) fn impl_pystruct_sequence(mut input: DeriveInput) -> Result<TokenStream> {
+    let (not_skipped_fields, _skipped_fields) = field_names(&mut input)?;
    let ty = &input.ident;
    let ret = quote! {
        impl ::rustpython_vm::types::PyStructSequence for #ty {
-            const FIELD_NAMES: &'static [&'static str] = &[#(stringify!(#field_names)),*];
+            const FIELD_NAMES: &'static [&'static str] = &[#(stringify!(#not_skipped_fields)),*];
            fn into_tuple(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::builtins::PyTuple {
                let items = vec![#(::rustpython_vm::convert::ToPyObject::to_pyobject(
-                    self.#field_names,
+                    self.#not_skipped_fields,
                    vm,
                )),*];
                ::rustpython_vm::builtins::PyTuple::new_unchecked(items.into_boxed_slice())
@@ -50,8 +102,10 @@ pub(crate) fn impl_pystruct_sequence(input: DeriveInput) -> Result<TokenStream>
    Ok(ret)
 }

-pub(crate) fn impl_pystruct_sequence_try_from_object(input: DeriveInput) -> Result<TokenStream> {
-    let field_names = field_names(&input)?;
+pub(crate) fn impl_pystruct_sequence_try_from_object(
+    mut input: DeriveInput,
+) -> Result<TokenStream> {
+    let (not_skipped_fields, skipped_fields) = field_names(&mut input)?;
    let ty = &input.ident;
    let ret = quote! {
        impl ::rustpython_vm::TryFromObject for #ty {
@@ -60,9 +114,14 @@ pub(crate) fn impl_pystruct_sequence_try_from_object(input: DeriveInput) -> Resu
                let seq = Self::try_elements_from::<LEN>(seq, vm)?;
                // TODO: this is possible to be written without iterator
                let mut iter = seq.into_iter();
-                Ok(Self {#(
-                    #field_names: iter.next().unwrap().clone().try_into_value(vm)?
-                ),*})
+                Ok(Self {
+                #(
+                    #not_skipped_fields: iter.next().unwrap().clone().try_into_value(vm)?,
+                )*
+                #(
+                    #skipped_fields: vm.ctx.none(),
+                )*
+                })
            }
        }
    };

diff --git a/derive/src/lib.rs b/derive/src/lib.rs
@@ -225,13 +225,13 @@ pub fn pymodule(attr: TokenStream, item: TokenStream) -> TokenStream {
    derive_impl::pymodule(attr, item).into()
 }

-#[proc_macro_derive(PyStructSequence)]
+#[proc_macro_derive(PyStructSequence, attributes(pystruct))]
 pub fn pystruct_sequence(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input);
    derive_impl::pystruct_sequence(input).into()
 }

-#[proc_macro_derive(TryIntoPyStructSequence)]
+#[proc_macro_derive(TryIntoPyStructSequence, attributes(pystruct))]
 pub fn pystruct_sequence_try_from_object(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input);
    derive_impl::pystruct_sequence_try_from_object(input).into()