Fix vectorcall to use slot_new from type slots, fix stat_result

Pattern B vectorcall functions now call through zelf.slots.new
instead of calling PyXxx::slot_new directly. This ensures Rust-level
subclasses with custom slot_new (e.g. stat_result subclassing tuple)
get their own constructor called correctly.

Fix PyStatResult::slot_new to use struct_sequence_new for proper
length validation and hidden field padding, matching structseq_new
behavior. Derive st_atime/st_mtime/st_ctime and their _ns variants
from integer time fields when not explicitly provided.

Author: youknowone

crates/vm/src/builtins/bool.rs

@@ -191,7 +191,7 @@ fn vectorcall_bool(
 ) -> PyResult {
     let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
     let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
-    PyBool::slot_new(zelf.to_owned(), func_args, vm)
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
 }
 
 pub(crate) fn init(context: &'static Context) {

crates/vm/src/builtins/bytes.rs

@@ -95,7 +95,7 @@ fn vectorcall_bytes(
 ) -> PyResult {
     let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
     let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
-    PyBytes::slot_new(zelf.to_owned(), func_args, vm)
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
 }
 
 pub(crate) fn init(context: &'static Context) {

crates/vm/src/builtins/complex.rs

@@ -138,7 +138,7 @@ fn vectorcall_complex(
 ) -> PyResult {
     let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
     let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
-    PyComplex::slot_new(zelf.to_owned(), func_args, vm)
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
 }
 
 pub fn init(context: &'static Context) {

crates/vm/src/builtins/float.rs

@@ -534,7 +534,7 @@ fn vectorcall_float(
 ) -> PyResult {
     let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
     let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
-    PyFloat::slot_new(zelf.to_owned(), func_args, vm)
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
 }
 
 #[rustfmt::skip] // to avoid line splitting

crates/vm/src/builtins/int.rs

@@ -800,7 +800,7 @@ fn vectorcall_int(
 ) -> PyResult {
     let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
     let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
-    PyInt::slot_new(zelf.to_owned(), func_args, vm)
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
 }
 
 pub(crate) fn init(context: &'static Context) {

crates/vm/src/builtins/set.rs

@@ -1444,7 +1444,7 @@ fn vectorcall_frozenset(
 ) -> PyResult {
     let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
     let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
-    PyFrozenSet::slot_new(zelf.to_owned(), func_args, vm)
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
 }
 
 pub fn init(context: &'static Context) {

crates/vm/src/builtins/str.rs

@@ -1790,7 +1790,7 @@ fn vectorcall_str(
 ) -> PyResult {
     let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
     let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
-    PyStr::slot_new(zelf.to_owned(), func_args, vm)
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
 }
 
 pub fn init(ctx: &'static Context) {

crates/vm/src/builtins/tuple.rs

@@ -704,7 +704,9 @@ fn vectorcall_tuple(
 ) -> PyResult {
     let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
     let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
-    PyTuple::slot_new(zelf.to_owned(), func_args, vm)
+    // Use the type's own slot_new rather than calling PyTuple::slot_new directly,
+    // so Rust-level subclasses (e.g. struct sequences) get their custom slot_new called.
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
 }
 
 pub(crate) fn init(context: &'static Context) {

crates/vm/src/stdlib/os.rs

@@ -178,7 +178,6 @@ pub(super) mod _os {
     };
     use core::time::Duration;
     use crossbeam_utils::atomic::AtomicCell;
-    use itertools::Itertools;
     use rustpython_common::wtf8::Wtf8Buf;
     use std::{env, fs, fs::OpenOptions, io, path::PathBuf, time::SystemTime};
 
@@ -1363,29 +1362,30 @@ pub(super) mod _os {
     #[pyclass(with(PyStructSequence))]
     impl PyStatResult {
         #[pyslot]
-        fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            let flatten_args = |r: &[PyObjectRef]| {
-                let mut vec_args = Vec::from(r);
-                loop {
-                    if let Ok(obj) = vec_args.iter().exactly_one() {
-                        match obj.downcast_ref::<PyTuple>() {
-                            Some(t) => {
-                                vec_args = Vec::from(t.as_slice());
-                            }
-                            None => {
-                                return vec_args;
-                            }
-                        }
-                    } else {
-                        return vec_args;
-                    }
+        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            let seq: PyObjectRef = args.bind(vm)?;
+            let result = crate::types::struct_sequence_new(cls.clone(), seq, vm)?;
+            let tuple = result.downcast_ref::<PyTuple>().unwrap();
+            let mut items: Vec<PyObjectRef> = tuple.to_vec();
+
+            // Derive hidden time fields from integer time fields.
+            // indices 7-9 are st_atime_int, st_mtime_int, st_ctime_int.
+            // i+3 → st_atime/st_mtime/st_ctime (float)
+            // i+6 → st_atime_ns/st_mtime_ns/st_ctime_ns (int nanoseconds)
+            for i in 7..=9 {
+                if vm.is_none(&items[i + 3]) {
+                    let float_val = items[i].try_float(vm)?;
+                    items[i + 3] = float_val.into();
                 }
-            };
-
-            let args: FuncArgs = flatten_args(&args.args).into();
+                if vm.is_none(&items[i + 6]) {
+                    let int_val: i64 = items[i].clone().try_into_value(vm)?;
+                    items[i + 6] = vm.ctx.new_int(int_val as i128 * 1_000_000_000).into();
+                }
+            }
 
-            let stat: StatResultData = args.bind(vm)?;
-            Ok(stat.to_pyobject(vm))
+            PyTuple::new_unchecked(items.into_boxed_slice())
+                .into_ref_with_type(vm, cls)
+                .map(Into::into)
         }
     }