backup

Author: youknowone

crates/derive-impl/src/lib.rs

@@ -66,6 +66,10 @@ pub fn pystruct_sequence_try_from_object(input: DeriveInput) -> TokenStream {
     result_to_tokens(pystructseq::impl_pystruct_sequence_try_from_object(input))
 }
 
+pub fn pystructseq(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
+    result_to_tokens(pystructseq::impl_pystructseq(attr, item))
+}
+
 pub fn py_compile(input: TokenStream, compiler: &dyn Compiler) -> TokenStream {
     result_to_tokens(compile_bytecode::impl_py_compile(input, compiler))
 }

crates/derive-impl/src/pystructseq.rs

@@ -1,30 +1,27 @@
+use crate::util::{ItemMeta, ItemMetaInner};
 use proc_macro2::TokenStream;
-use quote::quote;
-use syn::{DeriveInput, Ident, Result};
+use quote::{format_ident, quote};
+use syn::{DeriveInput, Ident, Item, Result};
 use syn_ext::ext::{AttributeExt, GetIdent};
-use syn_ext::types::Meta;
+use syn_ext::types::{Meta, PunctuatedNestedMeta};
 
-// returning a pair of not-skipped and skipped field names
+/// Parse field info from struct: returns (not_skipped_fields, skipped_fields)
 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"
-        )
+        bail_span!(input, "#[pystructseq] can only be on a struct declaration")
     };
 
     let syn::Fields::Named(fields) = &mut struc.fields else {
         bail_span!(
             input,
-            "#[pystruct_sequence] can only be on a struct with named fields"
+            "#[pystructseq] can only be on a struct with named fields"
         );
     };
 
     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() {
@@ -47,8 +44,6 @@ fn field_names(input: &mut DeriveInput) -> Result<(Vec<Ident>, Vec<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" => {
@@ -63,27 +58,257 @@ fn field_names(input: &mut DeriveInput) -> Result<(Vec<Ident>, Vec<Ident>)> {
             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
+        // Remove attributes in reverse order
+        attrs_to_remove.sort_unstable_by(|a, b| b.cmp(a));
         for index in attrs_to_remove {
             field.attrs.remove(index);
         }
         let ident = field.ident.clone().unwrap();
         if skip {
-            skipped.push(ident.clone());
+            skipped.push(ident);
         } else {
-            not_skipped.push(ident.clone());
+            not_skipped.push(ident);
         }
     }
 
     Ok((not_skipped, skipped))
 }
 
+/// Derive Python type name from Data struct name
+/// e.g., StructTimeData -> PyStructTime, StatResultData -> PyStatResult
+fn derive_pytype_name(data_ident: &Ident) -> Ident {
+    let name = data_ident.to_string();
+    let base_name = name.strip_suffix("Data").unwrap_or(&name);
+    let py_name = if base_name.starts_with("Py") {
+        base_name.to_string()
+    } else {
+        format!("Py{}", base_name)
+    };
+    format_ident!("{}", py_name)
+}
+
+/// Meta parser for #[pystructseq(...)]
+struct PyStructSeqMeta {
+    inner: ItemMetaInner,
+}
+
+impl ItemMeta for PyStructSeqMeta {
+    const ALLOWED_NAMES: &'static [&'static str] = &["name", "module"];
+
+    fn from_inner(inner: ItemMetaInner) -> Self {
+        Self { inner }
+    }
+    fn inner(&self) -> &ItemMetaInner {
+        &self.inner
+    }
+}
+
+impl PyStructSeqMeta {
+    fn class_name(&self) -> Result<String> {
+        const KEY: &str = "name";
+        let inner = self.inner();
+        if let Some((_, meta)) = inner.meta_map.get(KEY) {
+            match meta {
+                Meta::NameValue(syn::MetaNameValue {
+                    value:
+                        syn::Expr::Lit(syn::ExprLit {
+                            lit: syn::Lit::Str(lit),
+                            ..
+                        }),
+                    ..
+                }) => return Ok(lit.value()),
+                Meta::Path(_) => return Ok(inner.item_name()),
+                _ => {}
+            }
+            bail_span!(
+                inner.meta_ident,
+                "#[pystructseq({KEY}=value)] expects a string value"
+            )
+        } else {
+            // Default: derive from struct name (e.g., StructTimeData -> struct_time)
+            let name = inner.item_name();
+            let base_name = name.strip_suffix("Data").unwrap_or(&name);
+            Ok(base_name.to_lowercase())
+        }
+    }
+
+    fn module(&self) -> Result<Option<String>> {
+        const KEY: &str = "module";
+        let inner = self.inner();
+        if let Some((_, meta)) = inner.meta_map.get(KEY) {
+            match meta {
+                Meta::NameValue(syn::MetaNameValue {
+                    value:
+                        syn::Expr::Lit(syn::ExprLit {
+                            lit: syn::Lit::Str(lit),
+                            ..
+                        }),
+                    ..
+                }) => return Ok(Some(lit.value())),
+                _ => {}
+            }
+            bail_span!(
+                inner.meta_ident,
+                "#[pystructseq({KEY}=value)] expects a string value"
+            )
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+/// New attribute macro: #[pystructseq(name = "...", module = "...")]
+pub(crate) fn impl_pystructseq(attr: PunctuatedNestedMeta, item: Item) -> Result<TokenStream> {
+    let Item::Struct(mut struct_item) = item else {
+        bail_span!(item, "#[pystructseq] can only be applied to a struct");
+    };
+
+    let data_ident = struct_item.ident.clone();
+    let fake_ident = Ident::new("pystructseq", data_ident.span());
+    let meta = PyStructSeqMeta::from_nested(data_ident.clone(), fake_ident, attr.into_iter())?;
+
+    let class_name = meta.class_name()?;
+    let module_name = meta.module()?;
+    let pytype_ident = derive_pytype_name(&data_ident);
+
+    // Parse fields from struct
+    let mut derive_input: DeriveInput = syn::parse_quote!(#struct_item);
+    let (not_skipped_fields, skipped_fields) = field_names(&mut derive_input)?;
+
+    // Rebuild struct_item from modified derive_input (attributes removed from fields)
+    if let syn::Data::Struct(s) = derive_input.data {
+        struct_item.fields = s.fields;
+    }
+
+    // Generate field index constants
+    let field_indices: Vec<_> = not_skipped_fields
+        .iter()
+        .enumerate()
+        .map(|(i, field)| {
+            let const_name = format_ident!("{}_INDEX", field.to_string().to_uppercase());
+            quote! {
+                pub const #const_name: usize = #i;
+            }
+        })
+        .collect();
+
+    // Module name handling
+    let module_name_tokens = match &module_name {
+        Some(m) => quote!(Some(#m)),
+        None => quote!(None),
+    };
+
+    let module_class_name = if let Some(ref m) = module_name {
+        format!("{}.{}", m, class_name)
+    } else {
+        class_name.clone()
+    };
+
+    // Generate the output
+    let output = quote! {
+        // Original Data struct (with #[pystruct] attrs removed from fields)
+        #struct_item
+
+        // Field index constants
+        impl #data_ident {
+            #(#field_indices)*
+        }
+
+        // PyStructSequenceData trait implementation
+        impl ::rustpython_vm::types::PyStructSequenceData for #data_ident {
+            type PyType = #pytype_ident;
+
+            const REQUIRED_FIELD_NAMES: &'static [&'static str] = &[#(stringify!(#not_skipped_fields),)*];
+            const OPTIONAL_FIELD_NAMES: &'static [&'static str] = &[#(stringify!(#skipped_fields),)*];
+
+            fn into_tuple(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::builtins::PyTuple {
+                let items = vec![
+                    #(::rustpython_vm::convert::ToPyObject::to_pyobject(
+                        self.#not_skipped_fields,
+                        vm,
+                    ),)*
+                ];
+                ::rustpython_vm::builtins::PyTuple::new_unchecked(items.into_boxed_slice())
+            }
+        }
+
+        // ToPyObject for Data struct
+        impl ::rustpython_vm::convert::ToPyObject for #data_ident {
+            fn to_pyobject(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::PyObjectRef {
+                ::rustpython_vm::types::PyStructSequenceData::into_struct_sequence(self, vm).into()
+            }
+        }
+
+        // TryFromObject for Data struct
+        impl ::rustpython_vm::TryFromObject for #data_ident {
+            fn try_from_object(vm: &::rustpython_vm::VirtualMachine, seq: ::rustpython_vm::PyObjectRef) -> ::rustpython_vm::PyResult<Self> {
+                let seq = <#pytype_ident as ::rustpython_vm::types::PyStructSequence>::try_elements_from(seq, vm)?;
+                let mut iter = seq.into_iter();
+                Ok(Self {
+                    #(#not_skipped_fields: iter.next().unwrap().clone().try_into_value(vm)?,)*
+                    #(#skipped_fields: match iter.next() {
+                        Some(v) => v.clone().try_into_value(vm)?,
+                        None => vm.ctx.none(),
+                    },)*
+                })
+            }
+        }
+
+        // Empty Python type struct
+        #[doc(hidden)]
+        pub struct #pytype_ident;
+
+        // PyClassDef for Python type
+        impl ::rustpython_vm::class::PyClassDef for #pytype_ident {
+            const NAME: &'static str = #class_name;
+            const MODULE_NAME: Option<&'static str> = #module_name_tokens;
+            const TP_NAME: &'static str = #module_class_name;
+            const DOC: Option<&'static str> = None;
+            const BASICSIZE: usize = 0;
+            const UNHASHABLE: bool = false;
+
+            type Base = ::rustpython_vm::builtins::PyTuple;
+        }
+
+        // StaticType for Python type
+        impl ::rustpython_vm::class::StaticType for #pytype_ident {
+            fn static_cell() -> &'static ::rustpython_vm::common::static_cell::StaticCell<::rustpython_vm::builtins::PyTypeRef> {
+                ::rustpython_vm::common::static_cell! {
+                    static CELL: ::rustpython_vm::builtins::PyTypeRef;
+                }
+                &CELL
+            }
+
+            fn static_baseclass() -> &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType> {
+                use ::rustpython_vm::class::StaticType;
+                ::rustpython_vm::builtins::PyTuple::static_type()
+            }
+        }
+
+        // MaybeTraverse (empty - no GC fields in empty struct)
+        impl ::rustpython_vm::object::MaybeTraverse for #pytype_ident {
+            fn try_traverse(&self, _traverse_fn: &mut ::rustpython_vm::object::TraverseFn<'_>) {
+                // Empty struct has no fields to traverse
+            }
+        }
+
+        // PyStructSequence trait for Python type
+        impl ::rustpython_vm::types::PyStructSequence for #pytype_ident {
+            type Data = #data_ident;
+        }
+    };
+
+    Ok(output)
+}
+
+// Legacy derive macros (kept for backward compatibility during migration)
+// These use PyStructSequenceLegacy trait
+
 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 {
+        impl ::rustpython_vm::types::PyStructSequenceLegacy for #ty {
             const REQUIRED_FIELD_NAMES: &'static [&'static str] = &[#(stringify!(#not_skipped_fields),)*];
             const OPTIONAL_FIELD_NAMES: &'static [&'static str] = &[#(stringify!(#skipped_fields),)*];
             fn into_tuple(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::builtins::PyTuple {
@@ -98,7 +323,7 @@ pub(crate) fn impl_pystruct_sequence(mut input: DeriveInput) -> Result<TokenStre
         }
         impl ::rustpython_vm::convert::ToPyObject for #ty {
             fn to_pyobject(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::PyObjectRef {
-                ::rustpython_vm::types::PyStructSequence::into_struct_sequence(self, vm).into()
+                ::rustpython_vm::types::PyStructSequenceLegacy::into_struct_sequence(self, vm).into()
             }
         }
     };
@@ -113,7 +338,7 @@ pub(crate) fn impl_pystruct_sequence_try_from_object(
     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> {
-                let seq = Self::try_elements_from(seq, vm)?;
+                let seq = <Self as ::rustpython_vm::types::PyStructSequenceLegacy>::try_elements_from(seq, vm)?;
                 let mut iter = seq.into_iter();
                 Ok(Self {
                     #(#not_skipped_fields: iter.next().unwrap().clone().try_into_value(vm)?,)*

crates/derive/src/lib.rs

@@ -226,6 +226,31 @@ pub fn pystruct_sequence_try_from_object(input: TokenStream) -> TokenStream {
     derive_impl::pystruct_sequence_try_from_object(input).into()
 }
 
+/// Attribute macro for defining Python struct sequences.
+///
+/// This macro creates both a Data struct and a Python type struct from a single definition.
+///
+/// # Example
+/// ```ignore
+/// #[pystructseq(name = "struct_time")]
+/// pub struct StructTimeData {
+///     pub tm_year: PyObjectRef,
+///     pub tm_mon: PyObjectRef,
+///     #[pystruct(skip)]  // optional field
+///     pub tm_gmtoff: PyObjectRef,
+/// }
+/// // This generates:
+/// // - StructTimeData with PyStructSequenceData trait
+/// // - PyStructTime (empty struct) with PyStructSequence trait
+/// // - Field index constants (TM_YEAR_INDEX, etc.)
+/// ```
+#[proc_macro_attribute]
+pub fn pystructseq(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let attr = parse_macro_input!(attr with Punctuated::parse_terminated);
+    let item = parse_macro_input!(item);
+    derive_impl::pystructseq(attr, item).into()
+}
+
 struct Compiler;
 impl derive_impl::Compiler for Compiler {
     fn compile(

crates/stdlib/src/grp.rs

@@ -8,7 +8,7 @@ mod grp {
         builtins::{PyIntRef, PyListRef, PyStrRef},
         convert::{IntoPyException, ToPyObject},
         exceptions,
-        types::PyStructSequence,
+        types::PyStructSequenceLegacy,
     };
     use nix::unistd;
     use std::ptr::NonNull;
@@ -25,7 +25,7 @@ mod grp {
         gr_gid: u32,
         gr_mem: PyListRef,
     }
-    #[pyclass(with(PyStructSequence))]
+    #[pyclass(with(PyStructSequenceLegacy))]
     impl Group {
         fn from_unistd_group(group: unistd::Group, vm: &VirtualMachine) -> Self {
             let cstr_lossy = |s: std::ffi::CString| {