temp

Author: youknowone

crates/derive-impl/src/pystructseq.rs

@@ -93,7 +93,7 @@ struct PyStructSeqMeta {
 }
 
 impl ItemMeta for PyStructSeqMeta {
-    const ALLOWED_NAMES: &'static [&'static str] = &["name", "module"];
+    const ALLOWED_NAMES: &'static [&'static str] = &["name", "module", "try_from_object"];
 
     fn from_inner(inner: ItemMetaInner) -> Self {
         Self { inner }
@@ -155,6 +155,32 @@ impl PyStructSeqMeta {
             Ok(None)
         }
     }
+
+    fn try_from_object(&self) -> Result<bool> {
+        const KEY: &str = "try_from_object";
+        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::Bool(lit),
+                            ..
+                        }),
+                    ..
+                }) => return Ok(lit.value()),
+                Meta::Path(_) => return Ok(true), // #[pystructseq(try_from_object)] means true
+                _ => {}
+            }
+            bail_span!(
+                inner.meta_ident,
+                "#[pystructseq({KEY}=value)] expects a boolean value"
+            )
+        } else {
+            // Default: true for backward compatibility
+            Ok(true)
+        }
+    }
 }
 
 /// New attribute macro: #[pystructseq(name = "...", module = "...")]
@@ -164,11 +190,13 @@ pub(crate) fn impl_pystructseq(attr: PunctuatedNestedMeta, item: Item) -> Result
     };
 
     let data_ident = struct_item.ident.clone();
+    let data_vis = struct_item.vis.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 try_from_object = meta.try_from_object()?;
     let pytype_ident = derive_pytype_name(&data_ident);
 
     // Parse fields from struct
@@ -204,6 +232,28 @@ pub(crate) fn impl_pystructseq(attr: PunctuatedNestedMeta, item: Item) -> Result
         class_name.clone()
     };
 
+    // Generate TryFromObject impl if requested
+    let try_from_object_impl = if try_from_object {
+        quote! {
+            // 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(),
+                        },)*
+                    })
+                }
+            }
+        }
+    } else {
+        quote! {}
+    };
+
     // Generate the output
     let output = quote! {
         // Original Data struct (with #[pystruct] attrs removed from fields)
@@ -239,24 +289,11 @@ pub(crate) fn impl_pystructseq(attr: PunctuatedNestedMeta, item: Item) -> Result
             }
         }
 
-        // 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(),
-                    },)*
-                })
-            }
-        }
+        #try_from_object_impl
 
         // Empty Python type struct
         #[doc(hidden)]
-        pub struct #pytype_ident;
+        #data_vis struct #pytype_ident;
 
         // PyClassDef for Python type
         impl ::rustpython_vm::class::PyClassDef for #pytype_ident {

crates/stdlib/src/grp.rs

@@ -5,34 +5,38 @@ pub(crate) use grp::make_module;
 mod grp {
     use crate::vm::{
         PyObjectRef, PyResult, VirtualMachine,
-        builtins::{PyIntRef, PyListRef, PyStrRef},
+        builtins::{PyIntRef, PyListRef, PyStrRef, PyTypeRef},
+        class::PyClassImpl,
         convert::{IntoPyException, ToPyObject},
         exceptions,
-        types::PyStructSequenceLegacy,
+        types::PyStructSequence,
     };
     use nix::unistd;
     use std::ptr::NonNull;
 
-    #[pyattr]
-    #[pyclass(module = "grp", name = "struct_group", traverse)]
-    #[derive(PyStructSequence)]
-    struct Group {
-        #[pytraverse(skip)]
+    #[pystructseq(name = "struct_group", module = "grp")]
+    struct GroupData {
         gr_name: String,
-        #[pytraverse(skip)]
         gr_passwd: String,
-        #[pytraverse(skip)]
         gr_gid: u32,
         gr_mem: PyListRef,
     }
-    #[pyclass(with(PyStructSequenceLegacy))]
-    impl Group {
+
+    #[pyattr]
+    fn struct_group(vm: &VirtualMachine) -> PyTypeRef {
+        PyGroup::make_class(&vm.ctx)
+    }
+
+    #[pyclass(with(PyStructSequence))]
+    impl PyGroup {}
+
+    impl GroupData {
         fn from_unistd_group(group: unistd::Group, vm: &VirtualMachine) -> Self {
             let cstr_lossy = |s: std::ffi::CString| {
                 s.into_string()
                     .unwrap_or_else(|e| e.into_cstring().to_string_lossy().into_owned())
             };
-            Group {
+            GroupData {
                 gr_name: group.name,
                 gr_passwd: cstr_lossy(group.passwd),
                 gr_gid: group.gid.as_raw(),
@@ -44,7 +48,7 @@ mod grp {
     }
 
     #[pyfunction]
-    fn getgrgid(gid: PyIntRef, vm: &VirtualMachine) -> PyResult<Group> {
+    fn getgrgid(gid: PyIntRef, vm: &VirtualMachine) -> PyResult<GroupData> {
         let gr_gid = gid.as_bigint();
         let gid = libc::gid_t::try_from(gr_gid)
             .map(unistd::Gid::from_raw)
@@ -61,11 +65,11 @@ mod grp {
                     .into(),
             )
         })?;
-        Ok(Group::from_unistd_group(group, vm))
+        Ok(GroupData::from_unistd_group(group, vm))
     }
 
     #[pyfunction]
-    fn getgrnam(name: PyStrRef, vm: &VirtualMachine) -> PyResult<Group> {
+    fn getgrnam(name: PyStrRef, vm: &VirtualMachine) -> PyResult<GroupData> {
         let gr_name = name.as_str();
         if gr_name.contains('\0') {
             return Err(exceptions::cstring_error(vm));
@@ -78,7 +82,7 @@ mod grp {
                     .into(),
             )
         })?;
-        Ok(Group::from_unistd_group(group, vm))
+        Ok(GroupData::from_unistd_group(group, vm))
     }
 
     #[pyfunction]
@@ -91,7 +95,7 @@ mod grp {
         unsafe { libc::setgrent() };
         while let Some(ptr) = NonNull::new(unsafe { libc::getgrent() }) {
             let group = unistd::Group::from(unsafe { ptr.as_ref() });
-            let group = Group::from_unistd_group(group, vm).to_pyobject(vm);
+            let group = GroupData::from_unistd_group(group, vm).to_pyobject(vm);
             list.push(group);
         }
         unsafe { libc::endgrent() };

crates/stdlib/src/resource.rs

@@ -6,9 +6,11 @@ pub(crate) use resource::make_module;
 mod resource {
     use crate::vm::{
         PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, VirtualMachine,
+        builtins::PyTypeRef,
+        class::PyClassImpl,
         convert::{ToPyException, ToPyObject},
         stdlib::os,
-        types::PyStructSequenceLegacy,
+        types::PyStructSequence,
     };
     use std::{io, mem};
 
@@ -63,10 +65,8 @@ mod resource {
     #[pyattr]
     use libc::{RUSAGE_CHILDREN, RUSAGE_SELF};
 
-    #[pyattr]
-    #[pyclass(name = "struct_rusage")]
-    #[derive(PyStructSequence)]
-    struct Rusage {
+    #[pystructseq(name = "struct_rusage", module = "resource")]
+    struct RusageData {
         ru_utime: f64,
         ru_stime: f64,
         ru_maxrss: libc::c_long,
@@ -85,10 +85,15 @@ mod resource {
         ru_nivcsw: libc::c_long,
     }
 
-    #[pyclass(with(PyStructSequenceLegacy))]
-    impl Rusage {}
+    #[pyattr]
+    fn struct_rusage(vm: &VirtualMachine) -> PyTypeRef {
+        PyRusage::make_class(&vm.ctx)
+    }
+
+    #[pyclass(with(PyStructSequence))]
+    impl PyRusage {}
 
-    impl From<libc::rusage> for Rusage {
+    impl From<libc::rusage> for RusageData {
         fn from(rusage: libc::rusage) -> Self {
             let tv = |tv: libc::timeval| tv.tv_sec as f64 + (tv.tv_usec as f64 / 1_000_000.0);
             Self {
@@ -113,7 +118,7 @@ mod resource {
     }
 
     #[pyfunction]
-    fn getrusage(who: i32, vm: &VirtualMachine) -> PyResult<Rusage> {
+    fn getrusage(who: i32, vm: &VirtualMachine) -> PyResult<RusageData> {
         let res = unsafe {
             let mut rusage = mem::MaybeUninit::<libc::rusage>::uninit();
             if libc::getrusage(who, rusage.as_mut_ptr()) == -1 {
@@ -122,7 +127,7 @@ mod resource {
                 Ok(rusage.assume_init())
             }
         };
-        res.map(Rusage::from).map_err(|e| {
+        res.map(RusageData::from).map_err(|e| {
             if e.kind() == io::ErrorKind::InvalidInput {
                 vm.new_value_error("invalid who parameter")
             } else {

crates/vm/src/stdlib/nt.rs

@@ -179,7 +179,7 @@ pub(crate) mod module {
     fn get_terminal_size(
         fd: OptionalArg<i32>,
         vm: &VirtualMachine,
-    ) -> PyResult<_os::PyTerminalSize> {
+    ) -> PyResult<_os::TerminalSizeData> {
         let (columns, lines) = {
             let stdhandle = match fd {
                 OptionalArg::Present(0) => Console::STD_INPUT_HANDLE,
@@ -206,7 +206,7 @@ pub(crate) mod module {
                 (w.Bottom - w.Top + 1) as usize,
             )
         };
-        Ok(_os::PyTerminalSize { columns, lines })
+        Ok(_os::TerminalSizeData { columns, lines })
     }
 
     #[cfg(target_env = "msvc")]