RustPython
diff --git a/‎.cspell.json
Copy file name to clipboardExpand all lines: .cspell.json
+1Lines changed: 1 addition & 0 deletions b/‎.cspell.json
Copy file name to clipboardExpand all lines: .cspell.json
+1Lines changed: 1 addition & 0 deletions
diff --git a/‎derive-impl/src/pystructseq.rs
Copy file name to clipboardExpand all lines: derive-impl/src/pystructseq.rs
+71-18Lines changed: 71 additions & 18 deletions b/‎derive-impl/src/pystructseq.rs
Copy file name to clipboardExpand all lines: derive-impl/src/pystructseq.rs
+71-18Lines changed: 71 additions & 18 deletions
diff --git a/‎derive-impl/src/pytraverse.rs
Copy file name to clipboardExpand all lines: derive-impl/src/pytraverse.rs
+1-2Lines changed: 1 addition & 2 deletions b/‎derive-impl/src/pytraverse.rs
Copy file name to clipboardExpand all lines: derive-impl/src/pytraverse.rs
+1-2Lines changed: 1 addition & 2 deletions
@@ -148,6 +148,7 @@
     "origname",
     "posixsubprocess",
     "pyexpat",
+    "pytraverse",
     "PYTHONDEBUG",
     "PYTHONHOME",
     "PYTHONINSPECT",
 
@@ -1,34 +1,76 @@
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{DeriveInput, Ident, Result};
+use syn_ext::ext::GetIdent;
 
-fn field_names(input: &DeriveInput) -> Result<Vec<&Ident>> {
-    let fields = if let syn::Data::Struct(ref struc) = input.data {
-        &struc.fields
-    } else {
+struct Field {
+    ident: Ident,
+    skip: bool,
+}
+
+fn collect_fields(input: &mut DeriveInput) -> Result<Vec<Field>> {
+    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 fields_info = Vec::with_capacity(fields.named.len());
+    for field in &mut fields.named {
+        let mut removed_indices = Vec::new();
+        let mut skip = false;
+        for (i, attr) in field.attrs.iter().enumerate().rev() {
+            if !attr.path.is_ident("pystruct") {
+                continue;
+            }
+            removed_indices.push(i);
+            let Ok(meta) = attr.parse_meta() else {
+                continue;
+            };
+            let syn::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(...)]")
+                    }
+                }
+            }
+        }
+        eprintln!("removed indices: {:?}", removed_indices);
+        for index in removed_indices {
+            field.attrs.remove(index);
+        }
+        let ident = field.ident.clone().unwrap();
+        fields_info.push(Field { ident, skip });
+    }
+
+    Ok(fields_info)
 }
 
-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 fields = collect_fields(&mut input)?;
+    let field_names: Vec<_> = fields.iter().map(|f| f.ident.clone()).collect();
     let ty = &input.ident;
     let ret = quote! {
         impl ::rustpython_vm::types::PyStructSequence for #ty {
@@ -50,9 +92,20 @@ 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 fields = collect_fields(&mut input)?;
     let ty = &input.ident;
+    let field_exprs: Vec<_> = fields.into_iter().map(|f| {
+        let name = f.ident.clone();
+        if f.skip {
+            // FIXME: expected to be customizable
+            quote! { #name: vm.ctx.none().clone().into() }
+        } else {
+            quote! { #name: iter.next().unwrap().clone().try_into_value(vm)? }
+        }
+    }).collect();
     let ret = quote! {
         impl ::rustpython_vm::TryFromObject for #ty {
             fn try_from_object(vm: &::rustpython_vm::VirtualMachine, seq: ::rustpython_vm::PyObjectRef) -> ::rustpython_vm::PyResult<Self> {
@@ -61,7 +114,7 @@ pub(crate) fn impl_pystruct_sequence_try_from_object(input: DeriveInput) -> Resu
                 // 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)?
+                    #field_exprs
                 ),*})
             }
         }
 
@@ -16,9 +16,8 @@ fn valid_get_traverse_attr_from_meta_list(list: &MetaList) -> Result<TraverseAtt
         if len != 1 {
             return None;
         }
-        let mut iter = list.nested.iter();
         // we have checked the length, so unwrap is safe
-        let first_arg = iter.next().unwrap();
+        let first_arg = list.nested.first().unwrap();
         let skip = match first_arg {
             NestedMeta::Meta(Meta::Path(path)) => match path.is_ident("skip") {
                 true => true,