no_std clippy (#7043)

Cargo.toml

@@ -225,9 +225,9 @@ unsafe_op_in_unsafe_fn = "deny"
 elided_lifetimes_in_paths = "warn"
 
 [workspace.lints.clippy]
-# alloc_instead_of_core = "warn"
-# std_instead_of_alloc = "warn"
-# std_instead_of_core = "warn"
+alloc_instead_of_core = "warn"
+std_instead_of_alloc = "warn"
+std_instead_of_core = "warn"
 perf = "warn"
 style = "warn"
 complexity = "warn"

crates/codegen/src/compile.rs

@@ -8328,7 +8328,7 @@ impl Compiler {
         }
 
         // Add trailing string
-        all_strings.push(std::mem::take(&mut current_string));
+        all_strings.push(core::mem::take(&mut current_string));
 
         // Now build the Template:
         // Stack currently has all interpolations from compile_tstring_into calls
@@ -8372,7 +8372,7 @@ impl Compiler {
                 }
                 ast::InterpolatedStringElement::Interpolation(interp) => {
                     // Finish current string segment
-                    strings.push(std::mem::take(current_string));
+                    strings.push(core::mem::take(current_string));
 
                     // Compile the interpolation value
                     self.compile_expression(&interp.expression)?;

crates/common/src/crt_fd.rs

@@ -64,8 +64,8 @@ type BorrowedInner<'fd> = BorrowedFd<'fd>;
 #[cfg(windows)]
 mod win {
     use super::*;
-    use std::marker::PhantomData;
-    use std::mem::ManuallyDrop;
+    use core::marker::PhantomData;
+    use core::mem::ManuallyDrop;
 
     #[repr(transparent)]
     pub(super) struct OwnedInner(i32);

crates/common/src/fileutils.rs

@@ -24,8 +24,9 @@ pub fn fstat(fd: crate::crt_fd::Borrowed<'_>) -> std::io::Result<StatStruct> {
 pub mod windows {
     use crate::crt_fd;
     use crate::windows::ToWideString;
+    use alloc::ffi::CString;
     use libc::{S_IFCHR, S_IFDIR, S_IFMT};
-    use std::ffi::{CString, OsStr, OsString};
+    use std::ffi::{OsStr, OsString};
     use std::os::windows::io::AsRawHandle;
     use std::sync::OnceLock;
     use windows_sys::Win32::Foundation::{
@@ -119,9 +120,9 @@ pub mod windows {
             });
         }
 
-        let mut info = unsafe { std::mem::zeroed() };
-        let mut basic_info: FILE_BASIC_INFO = unsafe { std::mem::zeroed() };
-        let mut id_info: FILE_ID_INFO = unsafe { std::mem::zeroed() };
+        let mut info = unsafe { core::mem::zeroed() };
+        let mut basic_info: FILE_BASIC_INFO = unsafe { core::mem::zeroed() };
+        let mut id_info: FILE_ID_INFO = unsafe { core::mem::zeroed() };
 
         if unsafe { GetFileInformationByHandle(h as _, &mut info) } == 0
             || unsafe {
@@ -129,7 +130,7 @@ pub mod windows {
                     h as _,
                     FileBasicInfo,
                     &mut basic_info as *mut _ as *mut _,
-                    std::mem::size_of_val(&basic_info) as u32,
+                    core::mem::size_of_val(&basic_info) as u32,
                 )
             } == 0
         {
@@ -141,7 +142,7 @@ pub mod windows {
                 h as _,
                 FileIdInfo,
                 &mut id_info as *mut _ as *mut _,
-                std::mem::size_of_val(&id_info) as u32,
+                core::mem::size_of_val(&id_info) as u32,
             )
         } == 0
         {
@@ -334,8 +335,8 @@ pub mod windows {
             .ok_or_else(|| std::io::Error::from_raw_os_error(ERROR_NOT_SUPPORTED as _))?;
 
         let file_name = file_name.to_wide_with_nul();
-        let file_info_buffer_size = std::mem::size_of::<FILE_STAT_BASIC_INFORMATION>() as u32;
-        let mut file_info_buffer = std::mem::MaybeUninit::<FILE_STAT_BASIC_INFORMATION>::uninit();
+        let file_info_buffer_size = core::mem::size_of::<FILE_STAT_BASIC_INFORMATION>() as u32;
+        let mut file_info_buffer = core::mem::MaybeUninit::<FILE_STAT_BASIC_INFORMATION>::uninit();
         unsafe {
             if GetFileInformationByName(
                 file_name.as_ptr(),

crates/stdlib/src/_asyncio.rs

@@ -25,8 +25,8 @@ pub(crate) mod _asyncio {
             warn,
         },
     };
+    use core::sync::atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering};
     use crossbeam_utils::atomic::AtomicCell;
-    use std::sync::atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering};
 
     pub(crate) fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {
         __module_exec(vm, module);

crates/stdlib/src/_sqlite3.rs

@@ -12,6 +12,12 @@ pub(crate) use _sqlite3::module_def;
 
 #[pymodule]
 mod _sqlite3 {
+    use core::{
+        ffi::{CStr, c_int, c_longlong, c_uint, c_void},
+        fmt::Debug,
+        ops::Deref,
+        ptr::{NonNull, null, null_mut},
+    };
     use libsqlite3_sys::{
         SQLITE_BLOB, SQLITE_DETERMINISTIC, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_NULL,
         SQLITE_OPEN_CREATE, SQLITE_OPEN_READWRITE, SQLITE_OPEN_URI, SQLITE_TEXT, SQLITE_TRACE_STMT,
@@ -70,13 +76,7 @@ mod _sqlite3 {
         },
         utils::ToCString,
     };
-    use std::{
-        ffi::{CStr, c_int, c_longlong, c_uint, c_void},
-        fmt::Debug,
-        ops::Deref,
-        ptr::{NonNull, null, null_mut},
-        thread::ThreadId,
-    };
+    use std::thread::ThreadId;
 
     macro_rules! exceptions {
         ($(($x:ident, $base:expr)),*) => {
@@ -451,7 +451,7 @@ mod _sqlite3 {
         ) {
             let context = SqliteContext::from(context);
             let (func, vm) = unsafe { (*context.user_data::<Self>()).retrieve() };
-            let args = unsafe { std::slice::from_raw_parts(argv, argc as usize) };
+            let args = unsafe { core::slice::from_raw_parts(argv, argc as usize) };
 
             let f = || -> PyResult<()> {
                 let db = context.db_handle();
@@ -478,7 +478,7 @@ mod _sqlite3 {
         ) {
             let context = SqliteContext::from(context);
             let (cls, vm) = unsafe { (*context.user_data::<Self>()).retrieve() };
-            let args = unsafe { std::slice::from_raw_parts(argv, argc as usize) };
+            let args = unsafe { core::slice::from_raw_parts(argv, argc as usize) };
             let instance = context.aggregate_context::<*const PyObject>();
             if unsafe { (*instance).is_null() } {
                 match cls.call((), vm) {
@@ -556,7 +556,7 @@ mod _sqlite3 {
         ) {
             let context = SqliteContext::from(context);
             let (_, vm) = unsafe { (*context.user_data::<Self>()).retrieve() };
-            let args = unsafe { std::slice::from_raw_parts(argv, argc as usize) };
+            let args = unsafe { core::slice::from_raw_parts(argv, argc as usize) };
             let instance = context.aggregate_context::<*const PyObject>();
             let instance = unsafe { &**instance };
 
@@ -882,7 +882,7 @@ mod _sqlite3 {
     }
 
     impl Debug for Connection {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
             write!(f, "Sqlite3 Connection")
         }
     }
@@ -2077,7 +2077,7 @@ mod _sqlite3 {
                     } else {
                         let nbytes = st.column_bytes(i);
                         let blob = unsafe {
-                            std::slice::from_raw_parts(blob.cast::<u8>(), nbytes as usize)
+                            core::slice::from_raw_parts(blob.cast::<u8>(), nbytes as usize)
                         };
                         let blob = vm.ctx.new_bytes(blob.to_vec());
                         converter.call((blob,), vm)?
@@ -2684,7 +2684,7 @@ mod _sqlite3 {
     }
 
     impl Debug for Statement {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
             write!(
                 f,
                 "{} Statement",

crates/stdlib/src/math.rs

@@ -732,9 +732,9 @@ mod math {
 
             // Collect current + remaining elements
             let p_remaining: Result<Vec<PyObjectRef>, _> =
-                std::iter::once(Ok(p_i)).chain(p_iter).collect();
+                core::iter::once(Ok(p_i)).chain(p_iter).collect();
             let q_remaining: Result<Vec<PyObjectRef>, _> =
-                std::iter::once(Ok(q_i)).chain(q_iter).collect();
+                core::iter::once(Ok(q_i)).chain(q_iter).collect();
             let (p_vec, q_vec) = (p_remaining?, q_remaining?);
 
             if p_vec.len() != q_vec.len() {

crates/stdlib/src/mmap.rs

@@ -576,7 +576,7 @@ mod mmap {
                             SetFilePointerEx(
                                 duplicated_handle,
                                 required_size,
-                                std::ptr::null_mut(),
+                                core::ptr::null_mut(),
                                 FILE_BEGIN,
                             )
                         };
@@ -617,7 +617,7 @@ mod mmap {
 
                 // Keep the handle alive
                 let raw = owned_handle.as_raw_handle() as isize;
-                std::mem::forget(owned_handle);
+                core::mem::forget(owned_handle);
                 (raw, mmap)
             } else {
                 // Anonymous mapping
@@ -1088,7 +1088,7 @@ mod mmap {
                     SetFilePointerEx(
                         handle as HANDLE,
                         required_size,
-                        std::ptr::null_mut(),
+                        core::ptr::null_mut(),
                         FILE_BEGIN,
                     )
                 };
@@ -1267,7 +1267,7 @@ mod mmap {
         #[cfg(windows)]
         #[pymethod]
         fn __sizeof__(&self) -> usize {
-            std::mem::size_of::<Self>()
+            core::mem::size_of::<Self>()
         }
     }
 
@@ -1297,7 +1297,7 @@ mod mmap {
             };
 
             // Don't close the file handle - we're borrowing it
-            std::mem::forget(file);
+            core::mem::forget(file);
 
             result
         }

crates/stdlib/src/multiprocessing.rs

@@ -52,12 +52,10 @@ mod _multiprocessing {
         function::{FuncArgs, KwArgs},
         types::Constructor,
     };
+    use alloc::ffi::CString;
+    use core::sync::atomic::{AtomicI32, AtomicU64, Ordering};
     use libc::sem_t;
     use nix::errno::Errno;
-    use std::{
-        ffi::CString,
-        sync::atomic::{AtomicI32, AtomicU64, Ordering},
-    };
 
     /// Error type for sem_timedwait operations
     #[cfg(target_vendor = "apple")]
@@ -92,7 +90,7 @@ mod _multiprocessing {
                 tv_sec: 0,
                 tv_usec: 0,
             };
-            if unsafe { libc::gettimeofday(&mut now, std::ptr::null_mut()) } < 0 {
+            if unsafe { libc::gettimeofday(&mut now, core::ptr::null_mut()) } < 0 {
                 return Err(SemWaitError::OsError(Errno::last()));
             }
 
@@ -125,9 +123,9 @@ mod _multiprocessing {
             unsafe {
                 libc::select(
                     0,
-                    std::ptr::null_mut(),
-                    std::ptr::null_mut(),
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
+                    core::ptr::null_mut(),
+                    core::ptr::null_mut(),
                     &mut tv_delay,
                 )
             };
@@ -302,7 +300,7 @@ mod _multiprocessing {
                     tv_sec: 0,
                     tv_usec: 0,
                 };
-                let res = unsafe { libc::gettimeofday(&mut tv, std::ptr::null_mut()) };
+                let res = unsafe { libc::gettimeofday(&mut tv, core::ptr::null_mut()) };
                 if res < 0 {
                     return Err(vm.new_os_error("gettimeofday failed".to_string()));
                 }

crates/stdlib/src/overlapped.rs

@@ -112,11 +112,11 @@ mod _overlapped {
                         s,
                         SIO_GET_EXTENSION_FUNCTION_POINTER,
                         &$guid as *const _ as *const _,
-                        std::mem::size_of_val(&$guid) as u32,
+                        core::mem::size_of_val(&$guid) as u32,
                         &mut func_ptr as *mut _ as *mut _,
-                        std::mem::size_of::<usize>() as u32,
+                        core::mem::size_of::<usize>() as u32,
                         &mut dw_bytes,
-                        std::ptr::null_mut(),
+                        core::ptr::null_mut(),
                         None,
                     )
                 };
@@ -306,17 +306,17 @@ mod _overlapped {
                 let host: PyStrRef = addr_obj[0].clone().try_into_value(vm)?;
                 let port: u16 = addr_obj[1].clone().try_to_value(vm)?;
 
-                let mut addr: SOCKADDR_IN = unsafe { std::mem::zeroed() };
+                let mut addr: SOCKADDR_IN = unsafe { core::mem::zeroed() };
                 addr.sin_family = AF_INET;
 
                 let host_wide: Vec<u16> = host.as_str().encode_utf16().chain([0]).collect();
-                let mut addr_len = std::mem::size_of::<SOCKADDR_IN>() as i32;
+                let mut addr_len = core::mem::size_of::<SOCKADDR_IN>() as i32;
 
                 let ret = unsafe {
                     WSAStringToAddressW(
                         host_wide.as_ptr(),
                         AF_INET as i32,
-                        std::ptr::null(),
+                        core::ptr::null(),
                         &mut addr as *mut _ as *mut SOCKADDR,
                         &mut addr_len,
                     )
@@ -331,9 +331,9 @@ mod _overlapped {
                 addr.sin_port = port.to_be();
 
                 let bytes = unsafe {
-                    std::slice::from_raw_parts(
+                    core::slice::from_raw_parts(
                         &addr as *const _ as *const u8,
-                        std::mem::size_of::<SOCKADDR_IN>(),
+                        core::mem::size_of::<SOCKADDR_IN>(),
                     )
                 };
                 Ok((bytes.to_vec(), addr_len))
@@ -345,17 +345,17 @@ mod _overlapped {
                 let flowinfo: u32 = addr_obj[2].clone().try_to_value(vm)?;
                 let scope_id: u32 = addr_obj[3].clone().try_to_value(vm)?;
 
-                let mut addr: SOCKADDR_IN6 = unsafe { std::mem::zeroed() };
+                let mut addr: SOCKADDR_IN6 = unsafe { core::mem::zeroed() };
                 addr.sin6_family = AF_INET6;
 
                 let host_wide: Vec<u16> = host.as_str().encode_utf16().chain([0]).collect();
-                let mut addr_len = std::mem::size_of::<SOCKADDR_IN6>() as i32;
+                let mut addr_len = core::mem::size_of::<SOCKADDR_IN6>() as i32;
 
                 let ret = unsafe {
                     WSAStringToAddressW(
                         host_wide.as_ptr(),
                         AF_INET6 as i32,
-                        std::ptr::null(),
+                        core::ptr::null(),
                         &mut addr as *mut _ as *mut SOCKADDR,
                         &mut addr_len,
                     )
@@ -372,9 +372,9 @@ mod _overlapped {
                 addr.Anonymous.sin6_scope_id = scope_id;
 
                 let bytes = unsafe {
-                    std::slice::from_raw_parts(
+                    core::slice::from_raw_parts(
                         &addr as *const _ as *const u8,
-                        std::mem::size_of::<SOCKADDR_IN6>(),
+                        core::mem::size_of::<SOCKADDR_IN6>(),
                     )
                 };
                 Ok((bytes.to_vec(), addr_len))
@@ -385,7 +385,7 @@ mod _overlapped {
 
     /// Parse a SOCKADDR_IN6 (which can also hold IPv4 addresses) to a Python address tuple
     fn unparse_address(addr: &SOCKADDR_IN6, _addr_len: i32, vm: &VirtualMachine) -> PyResult {
-        use std::net::{Ipv4Addr, Ipv6Addr};
+        use core::net::{Ipv4Addr, Ipv6Addr};
 
         unsafe {
             let family = addr.sin6_family;
@@ -579,7 +579,7 @@ mod _overlapped {
             #[cfg(target_pointer_width = "32")]
             let size = core::cmp::min(size, isize::MAX as u32);
 
-            let buf = vec![0u8; std::cmp::max(size, 1) as usize];
+            let buf = vec![0u8; core::cmp::max(size, 1) as usize];
             let buf = vm.ctx.new_bytes(buf);
             inner.handle = handle as HANDLE;
             inner.data = OverlappedData::Read(buf.clone());
@@ -702,7 +702,7 @@ mod _overlapped {
             #[cfg(target_pointer_width = "32")]
             let size = core::cmp::min(size, isize::MAX as u32);
 
-            let buf = vec![0u8; std::cmp::max(size, 1) as usize];
+            let buf = vec![0u8; core::cmp::max(size, 1) as usize];
             let buf = vm.ctx.new_bytes(buf);
             inner.handle = handle as HANDLE;
             inner.data = OverlappedData::Read(buf.clone());
@@ -952,7 +952,7 @@ mod _overlapped {
             }
 
             // Buffer size: local address + remote address
-            let size = std::mem::size_of::<SOCKADDR_IN6>() + 16;
+            let size = core::mem::size_of::<SOCKADDR_IN6>() + 16;
             let buf = vec![0u8; size * 2];
             let buf = vm.ctx.new_bytes(buf);
 
@@ -972,7 +972,7 @@ mod _overlapped {
                 lpOverlapped: *mut OVERLAPPED,
             ) -> i32;
 
-            let accept_ex: AcceptExFn = unsafe { std::mem::transmute(*ACCEPT_EX.get().unwrap()) };
+            let accept_ex: AcceptExFn = unsafe { core::mem::transmute(*ACCEPT_EX.get().unwrap()) };
 
             let ret = unsafe {
                 accept_ex(
@@ -1036,7 +1036,7 @@ mod _overlapped {
             ) -> i32;
 
             let connect_ex: ConnectExFn =
-                unsafe { std::mem::transmute(*CONNECT_EX.get().unwrap()) };
+                unsafe { core::mem::transmute(*CONNECT_EX.get().unwrap()) };
 
             // Get pointer to the stored address data
             let addr_ptr = match &inner.data {
@@ -1049,9 +1049,9 @@ mod _overlapped {
                     socket as _,
                     addr_ptr as *const SOCKADDR,
                     addr_len,
-                    std::ptr::null(),
+                    core::ptr::null(),
                     0,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                     &mut inner.overlapped,
                 )
             };
@@ -1099,7 +1099,7 @@ mod _overlapped {
             ) -> i32;
 
             let disconnect_ex: DisconnectExFn =
-                unsafe { std::mem::transmute(*DISCONNECT_EX.get().unwrap()) };
+                unsafe { core::mem::transmute(*DISCONNECT_EX.get().unwrap()) };
 
             let ret = unsafe { disconnect_ex(socket as _, &mut inner.overlapped, flags, 0) };
 
@@ -1157,7 +1157,7 @@ mod _overlapped {
             ) -> i32;
 
             let transmit_file: TransmitFileFn =
-                unsafe { std::mem::transmute(*TRANSMIT_FILE.get().unwrap()) };
+                unsafe { core::mem::transmute(*TRANSMIT_FILE.get().unwrap()) };
 
             let ret = unsafe {
                 transmit_file(
@@ -1166,7 +1166,7 @@ mod _overlapped {
                     count_to_write,
                     count_per_send,
                     &mut inner.overlapped,
-                    std::ptr::null(),
+                    core::ptr::null(),
                     flags,
                 )
             };
@@ -1327,12 +1327,12 @@ mod _overlapped {
             #[cfg(target_pointer_width = "32")]
             let size = core::cmp::min(size, isize::MAX as u32);
 
-            let buf = vec![0u8; std::cmp::max(size, 1) as usize];
+            let buf = vec![0u8; core::cmp::max(size, 1) as usize];
             let buf = vm.ctx.new_bytes(buf);
             inner.handle = handle as HANDLE;
 
-            let address: SOCKADDR_IN6 = unsafe { std::mem::zeroed() };
-            let address_length = std::mem::size_of::<SOCKADDR_IN6>() as i32;
+            let address: SOCKADDR_IN6 = unsafe { core::mem::zeroed() };
+            let address_length = core::mem::size_of::<SOCKADDR_IN6>() as i32;
 
             inner.data = OverlappedData::ReadFrom(OverlappedReadFrom {
                 result: None,
@@ -1422,8 +1422,8 @@ mod _overlapped {
                 return Err(vm.new_value_error("buffer too large".to_owned()));
             }
 
-            let address: SOCKADDR_IN6 = unsafe { std::mem::zeroed() };
-            let address_length = std::mem::size_of::<SOCKADDR_IN6>() as i32;
+            let address: SOCKADDR_IN6 = unsafe { core::mem::zeroed() };
+            let address_length = core::mem::size_of::<SOCKADDR_IN6>() as i32;
 
             inner.data = OverlappedData::ReadFromInto(OverlappedReadFromInto {
                 result: None,
@@ -1502,7 +1502,7 @@ mod _overlapped {
                 }
             }
 
-            let mut overlapped: OVERLAPPED = unsafe { std::mem::zeroed() };
+            let mut overlapped: OVERLAPPED = unsafe { core::mem::zeroed() };
             if event != NULL {
                 overlapped.hEvent = event as HANDLE;
             }
@@ -1571,7 +1571,7 @@ mod _overlapped {
                 unsafe {
                     Foundation::CloseHandle(inner.overlapped.hEvent);
                 }
-                inner.overlapped.hEvent = std::ptr::null_mut();
+                inner.overlapped.hEvent = core::ptr::null_mut();
             }
 
             // Restore last error
@@ -1588,17 +1588,17 @@ mod _overlapped {
             CreateFileW, FILE_FLAG_OVERLAPPED, OPEN_EXISTING,
         };
 
-        let address_wide: Vec<u16> = address.encode_utf16().chain(std::iter::once(0)).collect();
+        let address_wide: Vec<u16> = address.encode_utf16().chain(core::iter::once(0)).collect();
 
         let handle = unsafe {
             CreateFileW(
                 address_wide.as_ptr(),
                 GENERIC_READ | GENERIC_WRITE,
                 0,
-                std::ptr::null(),
+                core::ptr::null(),
                 OPEN_EXISTING,
                 FILE_FLAG_OVERLAPPED,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
 
@@ -1635,7 +1635,7 @@ mod _overlapped {
     fn GetQueuedCompletionStatus(port: isize, msecs: u32, vm: &VirtualMachine) -> PyResult {
         let mut bytes_transferred = 0;
         let mut completion_key = 0;
-        let mut overlapped: *mut OVERLAPPED = std::ptr::null_mut();
+        let mut overlapped: *mut OVERLAPPED = core::ptr::null_mut();
         let ret = unsafe {
             windows_sys::Win32::System::IO::GetQueuedCompletionStatus(
                 port as HANDLE,
@@ -1693,12 +1693,12 @@ mod _overlapped {
     // Uses Arc for reference counting to prevent use-after-free when callback
     // and UnregisterWait race - the data stays alive until both are done
     static WAIT_CALLBACK_REGISTRY: std::sync::OnceLock<
-        std::sync::Mutex<std::collections::HashMap<isize, std::sync::Arc<PostCallbackData>>>,
+        std::sync::Mutex<std::collections::HashMap<isize, alloc::sync::Arc<PostCallbackData>>>,
     > = std::sync::OnceLock::new();
 
-    fn wait_callback_registry()
-    -> &'static std::sync::Mutex<std::collections::HashMap<isize, std::sync::Arc<PostCallbackData>>>
-    {
+    fn wait_callback_registry() -> &'static std::sync::Mutex<
+        std::collections::HashMap<isize, alloc::sync::Arc<PostCallbackData>>,
+    > {
         WAIT_CALLBACK_REGISTRY
             .get_or_init(|| std::sync::Mutex::new(std::collections::HashMap::new()))
     }
@@ -1721,7 +1721,7 @@ mod _overlapped {
     ) {
         // Reconstruct Arc from raw pointer - this gives us ownership of one reference
         // The Arc prevents use-after-free since we own a reference count
-        let data = unsafe { std::sync::Arc::from_raw(parameter as *const PostCallbackData) };
+        let data = unsafe { alloc::sync::Arc::from_raw(parameter as *const PostCallbackData) };
 
         unsafe {
             let _ = windows_sys::Win32::System::IO::PostQueuedCompletionStatus(
@@ -1747,15 +1747,15 @@ mod _overlapped {
             RegisterWaitForSingleObject, WT_EXECUTEINWAITTHREAD, WT_EXECUTEONLYONCE,
         };
 
-        let data = std::sync::Arc::new(PostCallbackData {
+        let data = alloc::sync::Arc::new(PostCallbackData {
             completion_port: completion_port as HANDLE,
             overlapped: overlapped as *mut OVERLAPPED,
         });
 
         // Create raw pointer for the callback - this increments refcount
-        let data_ptr = std::sync::Arc::into_raw(data.clone());
+        let data_ptr = alloc::sync::Arc::into_raw(data.clone());
 
-        let mut new_wait_object: HANDLE = std::ptr::null_mut();
+        let mut new_wait_object: HANDLE = core::ptr::null_mut();
         let ret = unsafe {
             RegisterWaitForSingleObject(
                 &mut new_wait_object,
@@ -1770,7 +1770,7 @@ mod _overlapped {
         if ret == 0 {
             // Registration failed - reconstruct Arc to drop the extra reference
             unsafe {
-                let _ = std::sync::Arc::from_raw(data_ptr);
+                let _ = alloc::sync::Arc::from_raw(data_ptr);
             }
             return Err(set_from_windows_err(0, vm));
         }
@@ -1829,7 +1829,7 @@ mod _overlapped {
         };
 
         let ret = if family == AF_INET as i32 {
-            let mut addr: SOCKADDR_IN = unsafe { std::mem::zeroed() };
+            let mut addr: SOCKADDR_IN = unsafe { core::mem::zeroed() };
             addr.sin_family = AF_INET;
             addr.sin_port = 0;
             addr.sin_addr.S_un.S_addr = INADDR_ANY;
@@ -1837,19 +1837,19 @@ mod _overlapped {
                 bind(
                     socket as _,
                     &addr as *const _ as *const SOCKADDR,
-                    std::mem::size_of::<SOCKADDR_IN>() as i32,
+                    core::mem::size_of::<SOCKADDR_IN>() as i32,
                 )
             }
         } else if family == AF_INET6 as i32 {
             // in6addr_any is all zeros, which we have from zeroed()
-            let mut addr: SOCKADDR_IN6 = unsafe { std::mem::zeroed() };
+            let mut addr: SOCKADDR_IN6 = unsafe { core::mem::zeroed() };
             addr.sin6_family = AF_INET6;
             addr.sin6_port = 0;
             unsafe {
                 bind(
                     socket as _,
                     &addr as *const _ as *const SOCKADDR,
-                    std::mem::size_of::<SOCKADDR_IN6>() as i32,
+                    core::mem::size_of::<SOCKADDR_IN6>() as i32,
                 )
             }
         } else {
@@ -1875,19 +1875,19 @@ mod _overlapped {
         const LANG_NEUTRAL: u32 = 0;
         const SUBLANG_DEFAULT: u32 = 1;
 
-        let mut buffer: *mut u16 = std::ptr::null_mut();
+        let mut buffer: *mut u16 = core::ptr::null_mut();
 
         let len = unsafe {
             FormatMessageW(
                 FORMAT_MESSAGE_ALLOCATE_BUFFER
                     | FORMAT_MESSAGE_FROM_SYSTEM
                     | FORMAT_MESSAGE_IGNORE_INSERTS,
-                std::ptr::null(),
+                core::ptr::null(),
                 error_code,
                 (SUBLANG_DEFAULT << 10) | LANG_NEUTRAL,
                 &mut buffer as *mut _ as *mut u16,
                 0,
-                std::ptr::null(),
+                core::ptr::null(),
             )
         };
 
@@ -1899,7 +1899,7 @@ mod _overlapped {
         }
 
         // Convert to Rust string, trimming trailing whitespace
-        let slice = unsafe { std::slice::from_raw_parts(buffer, len as usize) };
+        let slice = unsafe { core::slice::from_raw_parts(buffer, len as usize) };
         let msg = String::from_utf16_lossy(slice).trim_end().to_string();
 
         unsafe { LocalFree(buffer as *mut _) };
@@ -1918,10 +1918,10 @@ mod _overlapped {
                 socket as _,
                 addr_bytes.as_ptr() as *const SOCKADDR,
                 addr_len,
-                std::ptr::null(),
-                std::ptr::null_mut(),
-                std::ptr::null(),
-                std::ptr::null(),
+                core::ptr::null(),
+                core::ptr::null_mut(),
+                core::ptr::null(),
+                core::ptr::null(),
             )
         };
 
@@ -1945,15 +1945,15 @@ mod _overlapped {
         }
 
         let name_wide: Option<Vec<u16>> =
-            name.map(|n| n.encode_utf16().chain(std::iter::once(0)).collect());
+            name.map(|n| n.encode_utf16().chain(core::iter::once(0)).collect());
         let name_ptr = name_wide
             .as_ref()
             .map(|n| n.as_ptr())
-            .unwrap_or(std::ptr::null());
+            .unwrap_or(core::ptr::null());
 
         let event = unsafe {
             windows_sys::Win32::System::Threading::CreateEventW(
-                std::ptr::null(),
+                core::ptr::null(),
                 if manual_reset { 1 } else { 0 },
                 if initial_state { 1 } else { 0 },
                 name_ptr,

crates/stdlib/src/posixsubprocess.rs

@@ -38,7 +38,7 @@ mod _posixsubprocess {
             && vm
                 .state
                 .finalizing
-                .load(std::sync::atomic::Ordering::Acquire)
+                .load(core::sync::atomic::Ordering::Acquire)
         {
             return Err(vm.new_python_finalization_error(
                 "preexec_fn not supported at interpreter shutdown".to_owned(),

crates/stdlib/src/socket.rs

@@ -1253,11 +1253,12 @@ mod _socket {
                         (*can_addr).can_family = libc::AF_CAN as libc::sa_family_t;
                         (*can_addr).can_ifindex = ifindex;
                     }
-                    let storage: socket2::SockAddrStorage = unsafe { std::mem::transmute(storage) };
+                    let storage: socket2::SockAddrStorage =
+                        unsafe { core::mem::transmute(storage) };
                     Ok(unsafe {
                         socket2::SockAddr::new(
                             storage,
-                            std::mem::size_of::<libc::sockaddr_can>() as libc::socklen_t,
+                            core::mem::size_of::<libc::sockaddr_can>() as libc::socklen_t,
                         )
                     })
                 }
@@ -1316,11 +1317,12 @@ mod _socket {
                             (*alg_addr).salg_name[i] = b;
                         }
                     }
-                    let storage: socket2::SockAddrStorage = unsafe { std::mem::transmute(storage) };
+                    let storage: socket2::SockAddrStorage =
+                        unsafe { core::mem::transmute(storage) };
                     Ok(unsafe {
                         socket2::SockAddr::new(
                             storage,
-                            std::mem::size_of::<libc::sockaddr_alg>() as libc::socklen_t,
+                            core::mem::size_of::<libc::sockaddr_alg>() as libc::socklen_t,
                         )
                     })
                 }
@@ -1420,7 +1422,7 @@ mod _socket {
                 use crate::vm::builtins::PyBytes;
                 if let Ok(bytes) = fileno_obj.clone().downcast::<PyBytes>() {
                     let bytes_data = bytes.as_bytes();
-                    let expected_size = std::mem::size_of::<c::WSAPROTOCOL_INFOW>();
+                    let expected_size = core::mem::size_of::<c::WSAPROTOCOL_INFOW>();
 
                     if bytes_data.len() != expected_size {
                         return Err(vm
@@ -1431,9 +1433,9 @@ mod _socket {
                             .into());
                     }
 
-                    let mut info: c::WSAPROTOCOL_INFOW = unsafe { std::mem::zeroed() };
+                    let mut info: c::WSAPROTOCOL_INFOW = unsafe { core::mem::zeroed() };
                     unsafe {
-                        std::ptr::copy_nonoverlapping(
+                        core::ptr::copy_nonoverlapping(
                             bytes_data.as_ptr(),
                             &mut info as *mut c::WSAPROTOCOL_INFOW as *mut u8,
                             expected_size,
@@ -1477,7 +1479,7 @@ mod _socket {
                                 Some(errcode!(ENOTSOCK)) | Some(errcode!(EBADF))
                             ) =>
                     {
-                        std::mem::forget(sock);
+                        core::mem::forget(sock);
                         return Err(e.into());
                     }
                     _ => {}
@@ -1842,17 +1844,18 @@ mod _socket {
             // Add ALG_SET_OP control message
             {
                 let op_bytes = op.to_ne_bytes();
-                let space = unsafe { libc::CMSG_SPACE(std::mem::size_of::<u32>() as u32) } as usize;
+                let space =
+                    unsafe { libc::CMSG_SPACE(core::mem::size_of::<u32>() as u32) } as usize;
                 let old_len = control_buf.len();
                 control_buf.resize(old_len + space, 0u8);
 
                 let cmsg = control_buf[old_len..].as_mut_ptr() as *mut libc::cmsghdr;
                 unsafe {
-                    (*cmsg).cmsg_len = libc::CMSG_LEN(std::mem::size_of::<u32>() as u32) as _;
+                    (*cmsg).cmsg_len = libc::CMSG_LEN(core::mem::size_of::<u32>() as u32) as _;
                     (*cmsg).cmsg_level = libc::SOL_ALG;
                     (*cmsg).cmsg_type = libc::ALG_SET_OP;
                     let data = libc::CMSG_DATA(cmsg);
-                    std::ptr::copy_nonoverlapping(op_bytes.as_ptr(), data, op_bytes.len());
+                    core::ptr::copy_nonoverlapping(op_bytes.as_ptr(), data, op_bytes.len());
                 }
             }
 
@@ -1873,26 +1876,27 @@ mod _socket {
                     let data = libc::CMSG_DATA(cmsg);
                     // Write ivlen
                     let ivlen = (iv_bytes.len() as u32).to_ne_bytes();
-                    std::ptr::copy_nonoverlapping(ivlen.as_ptr(), data, 4);
+                    core::ptr::copy_nonoverlapping(ivlen.as_ptr(), data, 4);
                     // Write iv
-                    std::ptr::copy_nonoverlapping(iv_bytes.as_ptr(), data.add(4), iv_bytes.len());
+                    core::ptr::copy_nonoverlapping(iv_bytes.as_ptr(), data.add(4), iv_bytes.len());
                 }
             }
 
             // Add ALG_SET_AEAD_ASSOCLEN control message if assoclen is provided
             if let Some(assoclen_val) = assoclen {
                 let assoclen_bytes = assoclen_val.to_ne_bytes();
-                let space = unsafe { libc::CMSG_SPACE(std::mem::size_of::<u32>() as u32) } as usize;
+                let space =
+                    unsafe { libc::CMSG_SPACE(core::mem::size_of::<u32>() as u32) } as usize;
                 let old_len = control_buf.len();
                 control_buf.resize(old_len + space, 0u8);
 
                 let cmsg = control_buf[old_len..].as_mut_ptr() as *mut libc::cmsghdr;
                 unsafe {
-                    (*cmsg).cmsg_len = libc::CMSG_LEN(std::mem::size_of::<u32>() as u32) as _;
+                    (*cmsg).cmsg_len = libc::CMSG_LEN(core::mem::size_of::<u32>() as u32) as _;
                     (*cmsg).cmsg_level = libc::SOL_ALG;
                     (*cmsg).cmsg_type = libc::ALG_SET_AEAD_ASSOCLEN;
                     let data = libc::CMSG_DATA(cmsg);
-                    std::ptr::copy_nonoverlapping(
+                    core::ptr::copy_nonoverlapping(
                         assoclen_bytes.as_ptr(),
                         data,
                         assoclen_bytes.len(),
@@ -1911,7 +1915,7 @@ mod _socket {
                 .collect();
 
             // Set up msghdr
-            let mut msghdr: libc::msghdr = unsafe { std::mem::zeroed() };
+            let mut msghdr: libc::msghdr = unsafe { core::mem::zeroed() };
             msghdr.msg_iov = iovecs.as_ptr() as *mut _;
             msghdr.msg_iovlen = iovecs.len() as _;
             if !control_buf.is_empty() {
@@ -2376,11 +2380,11 @@ mod _socket {
                             fd as _,
                             cmd,
                             &option_val as *const u32 as *const _,
-                            std::mem::size_of::<u32>() as u32,
-                            std::ptr::null_mut(),
+                            core::mem::size_of::<u32>() as u32,
+                            core::ptr::null_mut(),
                             0,
                             &mut recv,
-                            std::ptr::null_mut(),
+                            core::ptr::null_mut(),
                             None,
                         )
                     };
@@ -2419,11 +2423,11 @@ mod _socket {
                             fd as _,
                             cmd,
                             &ka as *const TcpKeepalive as *const _,
-                            std::mem::size_of::<TcpKeepalive>() as u32,
-                            std::ptr::null_mut(),
+                            core::mem::size_of::<TcpKeepalive>() as u32,
+                            core::ptr::null_mut(),
                             0,
                             &mut recv,
-                            std::ptr::null_mut(),
+                            core::ptr::null_mut(),
                             None,
                         )
                     };
@@ -2454,9 +2458,9 @@ mod _socket {
 
             let info = unsafe { info.assume_init() };
             let bytes = unsafe {
-                std::slice::from_raw_parts(
+                core::slice::from_raw_parts(
                     &info as *const c::WSAPROTOCOL_INFOW as *const u8,
-                    std::mem::size_of::<c::WSAPROTOCOL_INFOW>(),
+                    core::mem::size_of::<c::WSAPROTOCOL_INFOW>(),
                 )
             };
 
@@ -3120,7 +3124,6 @@ mod _socket {
         }
         #[cfg(windows)]
         {
-            use std::ptr;
             use windows_sys::Win32::NetworkManagement::Ndis::NET_LUID_LH;
 
             let table = MibTable::get_raw().map_err(|err| err.into_pyexception(vm))?;
@@ -3147,14 +3150,14 @@ mod _socket {
                 }
             }
             struct MibTable {
-                ptr: ptr::NonNull<IpHelper::MIB_IF_TABLE2>,
+                ptr: core::ptr::NonNull<IpHelper::MIB_IF_TABLE2>,
             }
             impl MibTable {
                 fn get_raw() -> io::Result<Self> {
-                    let mut ptr = ptr::null_mut();
+                    let mut ptr = core::ptr::null_mut();
                     let ret = unsafe { IpHelper::GetIfTable2Ex(IpHelper::MibIfTableRaw, &mut ptr) };
                     if ret == 0 {
-                        let ptr = unsafe { ptr::NonNull::new_unchecked(ptr) };
+                        let ptr = unsafe { core::ptr::NonNull::new_unchecked(ptr) };
                         Ok(Self { ptr })
                     } else {
                         Err(io::Error::from_raw_os_error(ret as i32))
@@ -3166,7 +3169,7 @@ mod _socket {
                     unsafe {
                         let p = self.ptr.as_ptr();
                         let ptr = &raw const (*p).Table as *const IpHelper::MIB_IF_ROW2;
-                        std::slice::from_raw_parts(ptr, (*p).NumEntries as usize)
+                        core::slice::from_raw_parts(ptr, (*p).NumEntries as usize)
                     }
                 }
             }

crates/stdlib/src/ssl.rs

@@ -2616,7 +2616,7 @@ mod _ssl {
         pub(crate) fn sock_wait_for_io_with_timeout(
             &self,
             kind: SelectKind,
-            timeout: Option<std::time::Duration>,
+            timeout: Option<core::time::Duration>,
             vm: &VirtualMachine,
         ) -> PyResult<bool> {
             if self.is_bio_mode() {
@@ -4157,7 +4157,7 @@ mod _ssl {
 
                             // Calculate deadline for timeout mode
                             let deadline = timeout.map(|t| {
-                                std::time::Instant::now() + std::time::Duration::from_secs_f64(t)
+                                std::time::Instant::now() + core::time::Duration::from_secs_f64(t)
                             });
 
                             // Wait for peer's close_notify
@@ -5020,7 +5020,7 @@ mod _ssl {
         let store_name_wide: Vec<u16> = store_name
             .as_str()
             .encode_utf16()
-            .chain(std::iter::once(0))
+            .chain(core::iter::once(0))
             .collect();
 
         // Open system store
@@ -5044,7 +5044,7 @@ mod _ssl {
 
             let crl = unsafe { &*crl_context };
             let crl_bytes =
-                unsafe { std::slice::from_raw_parts(crl.pbCrlEncoded, crl.cbCrlEncoded as usize) };
+                unsafe { core::slice::from_raw_parts(crl.pbCrlEncoded, crl.cbCrlEncoded as usize) };
 
             let enc_type = if crl.dwCertEncodingType == X509_ASN_ENCODING {
                 vm.new_pyobj("x509_asn")

crates/vm/src/builtins/function.rs

@@ -89,28 +89,29 @@ unsafe impl Traverse for PyFunction {
         // Clear module, doc, and type_params (Py_CLEAR)
         if let Some(mut guard) = self.module.try_lock() {
             let old_module =
-                std::mem::replace(&mut *guard, Context::genesis().none.to_owned().into());
+                core::mem::replace(&mut *guard, Context::genesis().none.to_owned().into());
             out.push(old_module);
         }
         if let Some(mut guard) = self.doc.try_lock() {
-            let old_doc = std::mem::replace(&mut *guard, Context::genesis().none.to_owned().into());
+            let old_doc =
+                core::mem::replace(&mut *guard, Context::genesis().none.to_owned().into());
             out.push(old_doc);
         }
         if let Some(mut guard) = self.type_params.try_lock() {
             let old_type_params =
-                std::mem::replace(&mut *guard, Context::genesis().empty_tuple.to_owned());
+                core::mem::replace(&mut *guard, Context::genesis().empty_tuple.to_owned());
             out.push(old_type_params.into());
         }
 
         // Replace name and qualname with empty string to break potential str subclass cycles
         // name and qualname could be str subclasses, so they could have reference cycles
         if let Some(mut guard) = self.name.try_lock() {
-            let old_name = std::mem::replace(&mut *guard, Context::genesis().empty_str.to_owned());
+            let old_name = core::mem::replace(&mut *guard, Context::genesis().empty_str.to_owned());
             out.push(old_name.into());
         }
         if let Some(mut guard) = self.qualname.try_lock() {
             let old_qualname =
-                std::mem::replace(&mut *guard, Context::genesis().empty_str.to_owned());
+                core::mem::replace(&mut *guard, Context::genesis().empty_str.to_owned());
             out.push(old_qualname.into());
         }
 

crates/vm/src/builtins/template.rs

@@ -271,8 +271,8 @@ impl Representable for PyTemplate {
 #[derive(Debug)]
 pub struct PyTemplateIter {
     template: PyRef<PyTemplate>,
-    index: std::sync::atomic::AtomicUsize,
-    from_strings: std::sync::atomic::AtomicBool,
+    index: core::sync::atomic::AtomicUsize,
+    from_strings: core::sync::atomic::AtomicBool,
 }
 
 impl PyPayload for PyTemplateIter {
@@ -286,8 +286,8 @@ impl PyTemplateIter {
     fn new(template: PyRef<PyTemplate>) -> Self {
         Self {
             template,
-            index: std::sync::atomic::AtomicUsize::new(0),
-            from_strings: std::sync::atomic::AtomicBool::new(true),
+            index: core::sync::atomic::AtomicUsize::new(0),
+            from_strings: core::sync::atomic::AtomicBool::new(true),
         }
     }
 }
@@ -299,7 +299,7 @@ impl SelfIter for PyTemplateIter {}
 
 impl IterNext for PyTemplateIter {
     fn next(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        use std::sync::atomic::Ordering;
+        use core::sync::atomic::Ordering;
 
         loop {
             let from_strings = zelf.from_strings.load(Ordering::SeqCst);

crates/vm/src/builtins/tuple.rs

@@ -45,7 +45,7 @@ unsafe impl Traverse for PyTuple {
     }
 
     fn clear(&mut self, out: &mut Vec<PyObjectRef>) {
-        let elements = std::mem::take(&mut self.elements);
+        let elements = core::mem::take(&mut self.elements);
         out.extend(elements.into_vec());
     }
 }

crates/vm/src/frame.rs

@@ -3204,7 +3204,7 @@ impl ExecutingFrame<'_> {
         let stack = &self.state.stack;
         match &stack[stack.len() - depth as usize - 1] {
             Some(obj) => obj,
-            None => unsafe { std::hint::unreachable_unchecked() },
+            None => unsafe { core::hint::unreachable_unchecked() },
         }
     }
 

crates/vm/src/signal.rs

@@ -1,10 +1,10 @@
 #![cfg_attr(target_os = "wasi", allow(dead_code))]
 use crate::{PyResult, VirtualMachine};
 use alloc::fmt;
+use core::cell::Cell;
 #[cfg(windows)]
 use core::sync::atomic::AtomicIsize;
 use core::sync::atomic::{AtomicBool, Ordering};
-use std::cell::Cell;
 use std::sync::mpsc;
 
 pub(crate) const NSIG: usize = 64;

crates/vm/src/stdlib/_abc.rs

@@ -15,7 +15,7 @@ mod _abc {
         protocol::PyIterReturn,
         types::Constructor,
     };
-    use std::sync::atomic::{AtomicU64, Ordering};
+    use core::sync::atomic::{AtomicU64, Ordering};
 
     // Global invalidation counter
     static ABC_INVALIDATION_COUNTER: AtomicU64 = AtomicU64::new(0);

crates/vm/src/stdlib/codecs.rs

@@ -409,10 +409,10 @@ mod _codecs_windows {
                 WC_NO_BEST_FIT_CHARS,
                 wide.as_ptr(),
                 wide.len() as i32,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
                 0,
                 core::ptr::null(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
 
@@ -436,7 +436,7 @@ mod _codecs_windows {
                 if errors == "strict" {
                     &mut used_default_char
                 } else {
-                    std::ptr::null_mut()
+                    core::ptr::null_mut()
                 },
             )
         };
@@ -488,7 +488,7 @@ mod _codecs_windows {
                 MB_ERR_INVALID_CHARS,
                 data.as_ptr().cast(),
                 len as i32,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
                 0,
             )
         };
@@ -501,7 +501,7 @@ mod _codecs_windows {
                     0,
                     data.as_ptr().cast(),
                     len as i32,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                     0,
                 )
             };
@@ -595,10 +595,10 @@ mod _codecs_windows {
                 WC_NO_BEST_FIT_CHARS,
                 wide.as_ptr(),
                 wide.len() as i32,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
                 0,
                 core::ptr::null(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
 
@@ -622,7 +622,7 @@ mod _codecs_windows {
                 if errors == "strict" {
                     &mut used_default_char
                 } else {
-                    std::ptr::null_mut()
+                    core::ptr::null_mut()
                 },
             )
         };
@@ -674,7 +674,7 @@ mod _codecs_windows {
                 MB_ERR_INVALID_CHARS,
                 data.as_ptr().cast(),
                 len as i32,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
                 0,
             )
         };
@@ -687,7 +687,7 @@ mod _codecs_windows {
                     0,
                     data.as_ptr().cast(),
                     len as i32,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                     0,
                 )
             };
@@ -791,7 +791,7 @@ mod _codecs_windows {
         let pused = if use_default_char {
             &mut used_default_char as *mut i32
         } else {
-            std::ptr::null_mut()
+            core::ptr::null_mut()
         };
 
         let size = unsafe {
@@ -800,7 +800,7 @@ mod _codecs_windows {
                 flags,
                 wide.as_ptr(),
                 wide.len() as i32,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
                 0,
                 core::ptr::null(),
                 pused,
@@ -826,7 +826,7 @@ mod _codecs_windows {
         let pused = if use_default_char {
             &mut used_default_char as *mut i32
         } else {
-            std::ptr::null_mut()
+            core::ptr::null_mut()
         };
 
         let result = unsafe {
@@ -898,7 +898,7 @@ mod _codecs_windows {
                 let pused = if use_default_char {
                     &mut used_default_char as *mut i32
                 } else {
-                    std::ptr::null_mut()
+                    core::ptr::null_mut()
                 };
                 let outsize = unsafe {
                     WideCharToMultiByte(
@@ -906,7 +906,7 @@ mod _codecs_windows {
                         flags,
                         wchars.as_ptr(),
                         wchar_len,
-                        std::ptr::null_mut(),
+                        core::ptr::null_mut(),
                         0,
                         core::ptr::null(),
                         pused,
@@ -957,7 +957,7 @@ mod _codecs_windows {
                 let pused = if use_default_char {
                     &mut used_default_char as *mut i32
                 } else {
-                    std::ptr::null_mut()
+                    core::ptr::null_mut()
                 };
 
                 let mut buf = [0u8; 8];
@@ -1098,7 +1098,7 @@ mod _codecs_windows {
                     flags,
                     data.as_ptr().cast(),
                     data.len() as i32,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                     0,
                 )
             };

crates/vm/src/stdlib/ctypes.rs

@@ -1187,7 +1187,7 @@ pub(crate) mod _ctypes {
 
         let error_code = code.unwrap_or_else(|| unsafe { GetLastError() });
 
-        let mut buffer: *mut u16 = std::ptr::null_mut();
+        let mut buffer: *mut u16 = core::ptr::null_mut();
         let len = unsafe {
             FormatMessageW(
                 FORMAT_MESSAGE_ALLOCATE_BUFFER
@@ -1207,7 +1207,7 @@ pub(crate) mod _ctypes {
         }
 
         let message = unsafe {
-            let slice = std::slice::from_raw_parts(buffer, len as usize);
+            let slice = core::slice::from_raw_parts(buffer, len as usize);
             let msg = String::from_utf16_lossy(slice).trim_end().to_string();
             LocalFree(buffer as *mut _);
             msg
@@ -1244,11 +1244,11 @@ pub(crate) mod _ctypes {
         } else if let Some(cdata) = src.downcast_ref::<PyCData>() {
             // c_void_p etc: read pointer value from buffer
             let buffer = cdata.buffer.read();
-            if buffer.len() >= std::mem::size_of::<usize>() {
+            if buffer.len() >= core::mem::size_of::<usize>() {
                 usize::from_ne_bytes(
-                    buffer[..std::mem::size_of::<usize>()]
+                    buffer[..core::mem::size_of::<usize>()]
                         .try_into()
-                        .unwrap_or([0; std::mem::size_of::<usize>()]),
+                        .unwrap_or([0; core::mem::size_of::<usize>()]),
                 )
             } else {
                 0
@@ -1264,9 +1264,9 @@ pub(crate) mod _ctypes {
                 let iunknown = src_ptr as *mut *const usize;
                 let vtable = *iunknown;
                 debug_assert!(!vtable.is_null(), "IUnknown vtable is null");
-                let addref_fn: extern "system" fn(*mut std::ffi::c_void) -> u32 =
+                let addref_fn: extern "system" fn(*mut core::ffi::c_void) -> u32 =
                     core::mem::transmute(*vtable.add(1)); // AddRef is index 1
-                addref_fn(src_ptr as *mut std::ffi::c_void);
+                addref_fn(src_ptr as *mut core::ffi::c_void);
             }
         }
 

crates/vm/src/stdlib/ctypes/base.rs

@@ -2053,6 +2053,8 @@ pub(super) fn bytes_to_pyobject(
                 let len = unsafe { libc::wcslen(ptr as *const libc::wchar_t) };
                 let wchars =
                     unsafe { core::slice::from_raw_parts(ptr as *const libc::wchar_t, len) };
+                // wchar_t is i32 on some platforms and u32 on others
+                #[allow(clippy::unnecessary_cast)]
                 let s: String = wchars
                     .iter()
                     .filter_map(|&c| char::from_u32(c as u32))

crates/vm/src/stdlib/ctypes/function.rs

@@ -643,6 +643,10 @@ fn wstring_at_impl(ptr: usize, size: isize, vm: &VirtualMachine) -> PyResult {
     }
     #[cfg(not(windows))]
     {
+        #[allow(
+            clippy::useless_conversion,
+            reason = "wchar_t is i32 on some platforms and u32 on others"
+        )]
         let s: String = wchars
             .iter()
             .filter_map(|&c| u32::try_from(c).ok().and_then(char::from_u32))
@@ -1209,7 +1213,7 @@ fn resolve_com_method(
     let self_arg = &args.args[0];
     let com_ptr = if let Some(simple) = self_arg.downcast_ref::<PyCSimple>() {
         let buffer = simple.0.buffer.read();
-        if buffer.len() >= std::mem::size_of::<usize>() {
+        if buffer.len() >= core::mem::size_of::<usize>() {
             super::base::read_ptr_from_buffer(&buffer)
         } else {
             0
@@ -1936,6 +1940,10 @@ fn ffi_to_python(ty: &Py<PyType>, ptr: *const c_void, vm: &VirtualMachine) -> Py
                     }
                     #[cfg(not(windows))]
                     {
+                        #[allow(
+                            clippy::useless_conversion,
+                            reason = "wchar_t is i32 on some platforms and u32 on others"
+                        )]
                         let s: String = slice
                             .iter()
                             .filter_map(|&c| u32::try_from(c).ok().and_then(char::from_u32))

crates/vm/src/stdlib/ctypes/pointer.rs

@@ -508,6 +508,10 @@ impl PyCPointer {
             for _ in 0..len {
                 let addr = (ptr_value as isize + cur * wchar_size as isize) as *const libc::wchar_t;
                 unsafe {
+                    #[allow(
+                        clippy::unnecessary_cast,
+                        reason = "wchar_t is i32 on some platforms and u32 on others"
+                    )]
                     if let Some(c) = char::from_u32(*addr as u32) {
                         result.push(c);
                     }

crates/vm/src/stdlib/ctypes/simple.rs

@@ -1179,6 +1179,10 @@ impl PyCSimple {
                 }
                 #[cfg(not(windows))]
                 {
+                    #[allow(
+                        clippy::useless_conversion,
+                        reason = "wchar_t is i32 on some platforms and u32 on others"
+                    )]
                     let s: String = wchars
                         .iter()
                         .filter_map(|&c| u32::try_from(c).ok().and_then(char::from_u32))

crates/vm/src/stdlib/io.rs

@@ -43,7 +43,7 @@ impl ToOSErrorBuilder for std::io::Error {
             if errno > 0 && errno <= MAX_POSIX_ERRNO {
                 let ptr = unsafe { libc::strerror(errno) };
                 if !ptr.is_null() {
-                    let s = unsafe { std::ffi::CStr::from_ptr(ptr) }.to_string_lossy();
+                    let s = unsafe { core::ffi::CStr::from_ptr(ptr) }.to_string_lossy();
                     if !s.starts_with("Unknown error") {
                         break 'msg s.into_owned();
                     }
@@ -5378,7 +5378,10 @@ mod fileio {
                         }
                         // Store st_blksize for _blksize property
                         if status.st_blksize > 1 {
-                            #[allow(clippy::useless_conversion)] // needed for 32-bit platforms
+                            #[allow(
+                                clippy::useless_conversion,
+                                reason = "needed for 32-bit platforms"
+                            )]
                             zelf.blksize.store(i64::from(status.st_blksize));
                         }
                     }

crates/vm/src/stdlib/msvcrt.rs

@@ -58,7 +58,7 @@ mod msvcrt {
     #[pyfunction]
     fn getwch() -> String {
         let c = unsafe { _getwch() };
-        std::char::from_u32(c).unwrap().to_string()
+        char::from_u32(c).unwrap().to_string()
     }
     #[pyfunction]
     fn getche() -> Vec<u8> {
@@ -68,7 +68,7 @@ mod msvcrt {
     #[pyfunction]
     fn getwche() -> String {
         let c = unsafe { _getwche() };
-        std::char::from_u32(c).unwrap().to_string()
+        char::from_u32(c).unwrap().to_string()
     }
     #[pyfunction]
     fn putch(b: PyRef<PyBytes>, vm: &VirtualMachine) -> PyResult<()> {

crates/vm/src/stdlib/nt.rs

@@ -16,9 +16,10 @@ pub(crate) mod module {
         stdlib::os::{_os, DirFd, SupportFunc, TargetIsDirectory},
     };
 
+    use core::mem::MaybeUninit;
     use libc::intptr_t;
     use std::os::windows::io::AsRawHandle;
-    use std::{env, io, mem::MaybeUninit, os::windows::ffi::OsStringExt};
+    use std::{env, io, os::windows::ffi::OsStringExt};
     use windows_sys::Win32::{
         Foundation::{self, INVALID_HANDLE_VALUE},
         Storage::FileSystem,
@@ -99,7 +100,7 @@ pub(crate) mod module {
 
             // Check if it's a symlink or junction point
             if is_directory && (attrs & FileSystem::FILE_ATTRIBUTE_REPARSE_POINT) != 0 {
-                let mut find_data: WIN32_FIND_DATAW = unsafe { std::mem::zeroed() };
+                let mut find_data: WIN32_FIND_DATAW = unsafe { core::mem::zeroed() };
                 let handle = unsafe { FindFirstFileW(wide_path.as_ptr(), &mut find_data) };
                 if handle != INVALID_HANDLE_VALUE {
                     is_link = find_data.dwReserved0 == IO_REPARSE_TAG_SYMLINK
@@ -145,7 +146,7 @@ pub(crate) mod module {
     #[pyfunction]
     pub(super) fn symlink(args: SymlinkArgs<'_>, vm: &VirtualMachine) -> PyResult<()> {
         use crate::exceptions::ToOSErrorBuilder;
-        use std::sync::atomic::{AtomicBool, Ordering};
+        use core::sync::atomic::{AtomicBool, Ordering};
         use windows_sys::Win32::Storage::FileSystem::WIN32_FILE_ATTRIBUTE_DATA;
         use windows_sys::Win32::Storage::FileSystem::{
             CreateSymbolicLinkW, FILE_ATTRIBUTE_DIRECTORY, GetFileAttributesExW,
@@ -170,7 +171,7 @@ pub(crate) mod module {
                 Ok(wide) => wide,
                 Err(_) => return false,
             };
-            let mut info: WIN32_FILE_ATTRIBUTE_DATA = unsafe { std::mem::zeroed() };
+            let mut info: WIN32_FILE_ATTRIBUTE_DATA = unsafe { core::mem::zeroed() };
             let ok = unsafe {
                 GetFileAttributesExW(
                     wide.as_ptr(),
@@ -277,13 +278,13 @@ pub(crate) mod module {
         };
 
         // Get current file info
-        let mut info: FILE_BASIC_INFO = unsafe { std::mem::zeroed() };
+        let mut info: FILE_BASIC_INFO = unsafe { core::mem::zeroed() };
         let ret = unsafe {
             GetFileInformationByHandleEx(
                 handle,
                 FileBasicInfo,
                 &mut info as *mut _ as *mut _,
-                std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+                core::mem::size_of::<FILE_BASIC_INFO>() as u32,
             )
         };
         if ret == 0 {
@@ -303,7 +304,7 @@ pub(crate) mod module {
                 handle,
                 FileBasicInfo,
                 &info as *const _ as *const _,
-                std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+                core::mem::size_of::<FILE_BASIC_INFO>() as u32,
             )
         };
         if ret == 0 {
@@ -389,7 +390,7 @@ pub(crate) mod module {
                     core::ptr::null(),
                     OPEN_EXISTING,
                     FILE_FLAG_BACKUP_SEMANTICS,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                 )
             };
             if handle == INVALID_HANDLE_VALUE {
@@ -415,7 +416,7 @@ pub(crate) mod module {
         };
 
         let wide_path = path.as_ref().to_wide_with_nul();
-        let mut find_data: WIN32_FIND_DATAW = unsafe { std::mem::zeroed() };
+        let mut find_data: WIN32_FIND_DATAW = unsafe { core::mem::zeroed() };
 
         let handle = unsafe { FindFirstFileW(wide_path.as_ptr(), &mut find_data) };
         if handle == INVALID_HANDLE_VALUE {
@@ -534,13 +535,13 @@ pub(crate) mod module {
 
         if tested_type != PY_IFREG && tested_type != PY_IFDIR {
             // For symlinks/junctions, need FileAttributeTagInfo to get reparse tag
-            let mut info: FILE_ATTRIBUTE_TAG_INFO = unsafe { std::mem::zeroed() };
+            let mut info: FILE_ATTRIBUTE_TAG_INFO = unsafe { core::mem::zeroed() };
             let ret = unsafe {
                 GetFileInformationByHandleEx(
                     handle,
                     FileAttributeTagInfoClass,
                     &mut info as *mut _ as *mut _,
-                    std::mem::size_of::<FILE_ATTRIBUTE_TAG_INFO>() as u32,
+                    core::mem::size_of::<FILE_ATTRIBUTE_TAG_INFO>() as u32,
                 )
             };
             if ret == 0 {
@@ -554,13 +555,13 @@ pub(crate) mod module {
             )
         } else {
             // For regular files/directories, FileBasicInfo is sufficient
-            let mut info: FILE_BASIC_INFO = unsafe { std::mem::zeroed() };
+            let mut info: FILE_BASIC_INFO = unsafe { core::mem::zeroed() };
             let ret = unsafe {
                 GetFileInformationByHandleEx(
                     handle,
                     FileBasicInfo,
                     &mut info as *mut _ as *mut _,
-                    std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+                    core::mem::size_of::<FILE_BASIC_INFO>() as u32,
                 )
             };
             if ret == 0 {
@@ -629,7 +630,7 @@ pub(crate) mod module {
                 core::ptr::null(),
                 OPEN_EXISTING,
                 flags,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
 
@@ -710,7 +711,7 @@ pub(crate) mod module {
                 core::ptr::null(),
                 OPEN_EXISTING,
                 flags,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
         if handle != INVALID_HANDLE_VALUE {
@@ -731,7 +732,7 @@ pub(crate) mod module {
                     core::ptr::null(),
                     OPEN_EXISTING,
                     FILE_FLAG_BACKUP_SEMANTICS,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                 )
             };
             if handle != INVALID_HANDLE_VALUE {
@@ -889,7 +890,7 @@ pub(crate) mod module {
                 core::ptr::null(),
                 OPEN_EXISTING,
                 FILE_FLAG_BACKUP_SEMANTICS,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
         if handle == INVALID_HANDLE_VALUE {
@@ -908,12 +909,12 @@ pub(crate) mod module {
             DeviceIoControl(
                 handle,
                 FSCTL_QUERY_PERSISTENT_VOLUME_STATE,
-                &volume_state as *const _ as *const std::ffi::c_void,
-                std::mem::size_of::<FileFsPersistentVolumeInformation>() as u32,
-                &mut volume_state as *mut _ as *mut std::ffi::c_void,
-                std::mem::size_of::<FileFsPersistentVolumeInformation>() as u32,
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
+                &volume_state as *const _ as *const core::ffi::c_void,
+                core::mem::size_of::<FileFsPersistentVolumeInformation>() as u32,
+                &mut volume_state as *mut _ as *mut core::ffi::c_void,
+                core::mem::size_of::<FileFsPersistentVolumeInformation>() as u32,
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
 
@@ -1018,7 +1019,7 @@ pub(crate) mod module {
                     core::ptr::null(),
                     FileSystem::OPEN_EXISTING,
                     0,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                 )
             };
             if console_handle == INVALID_HANDLE_VALUE {
@@ -1064,7 +1065,7 @@ pub(crate) mod module {
         vm: &VirtualMachine,
     ) -> PyResult<intptr_t> {
         use crate::function::FsPath;
-        use std::iter::once;
+        use core::iter::once;
 
         let path = path.to_wide_cstring(vm)?;
 
@@ -1105,7 +1106,7 @@ pub(crate) mod module {
         vm: &VirtualMachine,
     ) -> PyResult<intptr_t> {
         use crate::function::FsPath;
-        use std::iter::once;
+        use core::iter::once;
 
         let path = path.to_wide_cstring(vm)?;
 
@@ -1178,7 +1179,7 @@ pub(crate) mod module {
         argv: Either<PyListRef, PyTupleRef>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        use std::iter::once;
+        use core::iter::once;
 
         let make_widestring =
             |s: &str| widestring::WideCString::from_os_str(s).map_err(|err| err.to_pyexception(vm));
@@ -1219,7 +1220,7 @@ pub(crate) mod module {
         env: PyDictRef,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        use std::iter::once;
+        use core::iter::once;
 
         let make_widestring =
             |s: &str| widestring::WideCString::from_os_str(s).map_err(|err| err.to_pyexception(vm));
@@ -1299,7 +1300,7 @@ pub(crate) mod module {
                 core::ptr::null(),
                 OPEN_EXISTING,
                 FILE_FLAG_BACKUP_SEMANTICS,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
         if handle == INVALID_HANDLE_VALUE {
@@ -1342,7 +1343,7 @@ pub(crate) mod module {
                 wpath.as_ptr(),
                 buffer.len() as _,
                 buffer.as_mut_ptr(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
         if ret == 0 {
@@ -1356,7 +1357,7 @@ pub(crate) mod module {
                     wpath.as_ptr(),
                     buffer.len() as _,
                     buffer.as_mut_ptr(),
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                 )
             };
             if ret == 0 {
@@ -1371,7 +1372,7 @@ pub(crate) mod module {
     #[pyfunction]
     fn _getvolumepathname(path: OsPath, vm: &VirtualMachine) -> PyResult {
         let wide = path.to_wide_cstring(vm)?;
-        let buflen = std::cmp::max(wide.len(), Foundation::MAX_PATH as usize);
+        let buflen = core::cmp::max(wide.len(), Foundation::MAX_PATH as usize);
         if buflen > u32::MAX as usize {
             return Err(vm.new_overflow_error("path too long".to_owned()));
         }
@@ -1478,7 +1479,7 @@ pub(crate) mod module {
             (wide, false)
         } else if let Some(b) = path.downcast_ref::<PyBytes>() {
             // On Windows, bytes must be valid UTF-8 - this raises UnicodeDecodeError if not
-            let s = std::str::from_utf8(b.as_bytes()).map_err(|e| {
+            let s = core::str::from_utf8(b.as_bytes()).map_err(|e| {
                 vm.new_exception_msg(
                     vm.ctx.exceptions.unicode_decode_error.to_owned(),
                     format!(
@@ -1550,7 +1551,7 @@ pub(crate) mod module {
             .iter()
             .copied()
             .map(|c| if c == b'/' as u16 { b'\\' as u16 } else { c })
-            .chain(std::iter::once(0)) // null-terminated
+            .chain(core::iter::once(0)) // null-terminated
             .collect();
 
         let mut end: *const u16 = core::ptr::null();
@@ -1718,7 +1719,7 @@ pub(crate) mod module {
             let wide: Vec<u16> = s.as_wtf8().encode_wide().collect();
             (wide, false)
         } else if let Some(b) = path.downcast_ref::<PyBytes>() {
-            let s = std::str::from_utf8(b.as_bytes()).map_err(|e| {
+            let s = core::str::from_utf8(b.as_bytes()).map_err(|e| {
                 vm.new_exception_msg(
                     vm.ctx.exceptions.unicode_decode_error.to_owned(),
                     format!(
@@ -1968,8 +1969,8 @@ pub(crate) mod module {
         // special case: mode 0o700 sets a protected ACL
         let res = if args.mode == 0o700 {
             let mut sec_attr = SECURITY_ATTRIBUTES {
-                nLength: std::mem::size_of::<SECURITY_ATTRIBUTES>() as u32,
-                lpSecurityDescriptor: std::ptr::null_mut(),
+                nLength: core::mem::size_of::<SECURITY_ATTRIBUTES>() as u32,
+                lpSecurityDescriptor: core::ptr::null_mut(),
                 bInheritHandle: 0,
             };
             // Set a discretionary ACL (D) that is protected (P) and includes
@@ -1983,7 +1984,7 @@ pub(crate) mod module {
                     sddl.as_ptr(),
                     SDDL_REVISION_1,
                     &mut sec_attr.lpSecurityDescriptor,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                 )
             };
             if convert_result == 0 {
@@ -1994,7 +1995,7 @@ pub(crate) mod module {
             unsafe { LocalFree(sec_attr.lpSecurityDescriptor) };
             res
         } else {
-            unsafe { FileSystem::CreateDirectoryW(wide.as_ptr(), std::ptr::null_mut()) }
+            unsafe { FileSystem::CreateDirectoryW(wide.as_ptr(), core::ptr::null_mut()) }
         };
 
         if res == 0 {
@@ -2030,7 +2031,7 @@ pub(crate) mod module {
         use windows_sys::Win32::System::Pipes::CreatePipe;
 
         let mut attr = SECURITY_ATTRIBUTES {
-            nLength: std::mem::size_of::<SECURITY_ATTRIBUTES>() as u32,
+            nLength: core::mem::size_of::<SECURITY_ATTRIBUTES>() as u32,
             lpSecurityDescriptor: core::ptr::null_mut(),
             bInheritHandle: 0,
         };
@@ -2074,7 +2075,7 @@ pub(crate) mod module {
         type NtQueryInformationProcessFn = unsafe extern "system" fn(
             process_handle: isize,
             process_information_class: u32,
-            process_information: *mut std::ffi::c_void,
+            process_information: *mut core::ffi::c_void,
             process_information_length: u32,
             return_length: *mut u32,
         ) -> i32;
@@ -2099,15 +2100,15 @@ pub(crate) mod module {
         };
         let nt_query: NtQueryInformationProcessFn = unsafe { core::mem::transmute(func) };
 
-        let mut info: PROCESS_BASIC_INFORMATION = unsafe { std::mem::zeroed() };
+        let mut info: PROCESS_BASIC_INFORMATION = unsafe { core::mem::zeroed() };
 
         let status = unsafe {
             nt_query(
                 GetCurrentProcess() as isize,
                 0, // ProcessBasicInformation
-                &mut info as *mut _ as *mut std::ffi::c_void,
-                std::mem::size_of::<PROCESS_BASIC_INFORMATION>() as u32,
-                std::ptr::null_mut(),
+                &mut info as *mut _ as *mut core::ffi::c_void,
+                core::mem::size_of::<PROCESS_BASIC_INFORMATION>() as u32,
+                core::ptr::null_mut(),
             )
         };
 
@@ -2185,7 +2186,7 @@ pub(crate) mod module {
                 core::ptr::null(),
                 OPEN_EXISTING,
                 FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
 
@@ -2211,7 +2212,7 @@ pub(crate) mod module {
                 buffer.as_mut_ptr() as *mut _,
                 BUFFER_SIZE as u32,
                 &mut bytes_returned,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
 

crates/vm/src/stdlib/os.rs

@@ -1011,10 +1011,10 @@ pub(super) mod _os {
             let st_ino = stat.st_ino;
 
             #[cfg(not(windows))]
-            #[allow(clippy::useless_conversion)] // needed for 32-bit platforms
+            #[allow(clippy::useless_conversion, reason = "needed for 32-bit platforms")]
             let st_blksize = i64::from(stat.st_blksize);
             #[cfg(not(windows))]
-            #[allow(clippy::useless_conversion)] // needed for 32-bit platforms
+            #[allow(clippy::useless_conversion, reason = "needed for 32-bit platforms")]
             let st_blocks = i64::from(stat.st_blocks);
 
             Self {
@@ -1342,9 +1342,9 @@ pub(super) mod _os {
         #[cfg(unix)]
         {
             use std::os::unix::ffi::OsStrExt;
-            let src_cstr = std::ffi::CString::new(src.path.as_os_str().as_bytes())
+            let src_cstr = alloc::ffi::CString::new(src.path.as_os_str().as_bytes())
                 .map_err(|_| vm.new_value_error("embedded null byte"))?;
-            let dst_cstr = std::ffi::CString::new(dst.path.as_os_str().as_bytes())
+            let dst_cstr = alloc::ffi::CString::new(dst.path.as_os_str().as_bytes())
                 .map_err(|_| vm.new_value_error("embedded null byte"))?;
 
             let follow = follow_symlinks.into_option().unwrap_or(true);
@@ -1595,7 +1595,7 @@ pub(super) mod _os {
     fn times(vm: &VirtualMachine) -> PyResult {
         #[cfg(windows)]
         {
-            use std::mem::MaybeUninit;
+            use core::mem::MaybeUninit;
             use windows_sys::Win32::{Foundation::FILETIME, System::Threading};
 
             let mut _create = MaybeUninit::<FILETIME>::uninit();

crates/vm/src/stdlib/signal.rs

@@ -28,7 +28,7 @@ pub(crate) mod _signal {
             static WAKEUP: atomic::AtomicUsize = atomic::AtomicUsize::new(INVALID_WAKEUP);
             // windows doesn't use the same fds for files and sockets like windows does, so we need
             // this to know whether to send() or write()
-            static WAKEUP_IS_SOCKET: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+            static WAKEUP_IS_SOCKET: core::sync::atomic::AtomicBool = core::sync::atomic::AtomicBool::new(false);
 
             impl<'a> TryFromBorrowedObject<'a> for WakeupFd {
                 fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a crate::PyObject) -> PyResult<Self> {
@@ -382,7 +382,7 @@ pub(crate) mod _signal {
 
             crate::windows::init_winsock();
             let mut res = 0i32;
-            let mut res_size = std::mem::size_of::<i32>() as i32;
+            let mut res_size = core::mem::size_of::<i32>() as i32;
             let res = unsafe {
                 WinSock::getsockopt(
                     fd,
@@ -468,7 +468,7 @@ pub(crate) mod _signal {
                 libc::SYS_pidfd_send_signal,
                 pidfd,
                 sig,
-                std::ptr::null::<libc::siginfo_t>(),
+                core::ptr::null::<libc::siginfo_t>(),
                 flags,
             ) as libc::c_long
         };

crates/vm/src/stdlib/sys.rs

@@ -935,7 +935,7 @@ mod sys {
 
             // Get the size of the version information block
             let ver_block_size =
-                GetFileVersionInfoSizeW(kernel32_path.as_ptr(), std::ptr::null_mut());
+                GetFileVersionInfoSizeW(kernel32_path.as_ptr(), core::ptr::null_mut());
             if ver_block_size == 0 {
                 return Err(std::io::Error::last_os_error());
             }
@@ -955,7 +955,7 @@ mod sys {
             // Prepare an empty sub-block string (L"") as required by VerQueryValueW
             let sub_block: Vec<u16> = std::ffi::OsStr::new("").to_wide_with_nul();
 
-            let mut ffi_ptr: *mut VS_FIXEDFILEINFO = std::ptr::null_mut();
+            let mut ffi_ptr: *mut VS_FIXEDFILEINFO = core::ptr::null_mut();
             let mut ffi_len: u32 = 0;
             if VerQueryValueW(
                 ver_block.as_ptr() as *const _,
@@ -987,8 +987,8 @@ mod sys {
             GetVersionExW, OSVERSIONINFOEXW, OSVERSIONINFOW,
         };
 
-        let mut version: OSVERSIONINFOEXW = unsafe { std::mem::zeroed() };
-        version.dwOSVersionInfoSize = std::mem::size_of::<OSVERSIONINFOEXW>() as u32;
+        let mut version: OSVERSIONINFOEXW = unsafe { core::mem::zeroed() };
+        version.dwOSVersionInfoSize = core::mem::size_of::<OSVERSIONINFOEXW>() as u32;
         let result = unsafe {
             let os_vi = &mut version as *mut OSVERSIONINFOEXW as *mut OSVERSIONINFOW;
             // SAFETY: GetVersionExW accepts a pointer of OSVERSIONINFOW, but windows-sys crate's type currently doesn't allow to do so.

crates/vm/src/stdlib/thread.rs

@@ -17,7 +17,10 @@ pub(crate) mod _thread {
         function::{ArgCallable, Either, FuncArgs, KwArgs, OptionalArg, PySetterValue},
         types::{Constructor, GetAttr, Representable, SetAttr},
     };
-    use alloc::fmt;
+    use alloc::{
+        fmt,
+        sync::{Arc, Weak},
+    };
     use core::{cell::RefCell, time::Duration};
     use crossbeam_utils::atomic::AtomicCell;
     use parking_lot::{
@@ -318,7 +321,7 @@ pub(crate) mod _thread {
     fn set_name(name: PyStrRef) {
         #[cfg(target_os = "linux")]
         {
-            use std::ffi::CString;
+            use alloc::ffi::CString;
             if let Ok(c_name) = CString::new(name.as_str()) {
                 // pthread_setname_np on Linux has a 16-byte limit including null terminator
                 // TODO: Potential UTF-8 boundary issue when truncating thread name on Linux.
@@ -335,7 +338,7 @@ pub(crate) mod _thread {
         }
         #[cfg(target_os = "macos")]
         {
-            use std::ffi::CString;
+            use alloc::ffi::CString;
             if let Ok(c_name) = CString::new(name.as_str()) {
                 unsafe {
                     libc::pthread_setname_np(c_name.as_ptr());
@@ -516,8 +519,8 @@ pub(crate) mod _thread {
 
     // Registry for non-daemon threads that need to be joined at shutdown
     pub type ShutdownEntry = (
-        std::sync::Weak<parking_lot::Mutex<ThreadHandleInner>>,
-        std::sync::Weak<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+        Weak<parking_lot::Mutex<ThreadHandleInner>>,
+        Weak<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
     );
 
     #[pyfunction]
@@ -571,14 +574,11 @@ pub(crate) mod _thread {
     /// Add a non-daemon thread handle to the shutdown registry
     fn add_to_shutdown_handles(
         vm: &VirtualMachine,
-        inner: &std::sync::Arc<parking_lot::Mutex<ThreadHandleInner>>,
-        done_event: &std::sync::Arc<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+        inner: &Arc<parking_lot::Mutex<ThreadHandleInner>>,
+        done_event: &Arc<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
     ) {
         let mut handles = vm.state.shutdown_handles.lock();
-        handles.push((
-            std::sync::Arc::downgrade(inner),
-            std::sync::Arc::downgrade(done_event),
-        ));
+        handles.push((Arc::downgrade(inner), Arc::downgrade(done_event)));
     }
 
     #[pyfunction]
@@ -744,12 +744,12 @@ pub(crate) mod _thread {
     // Thread-local storage for cleanup guards
     // When a thread terminates, the guard is dropped, which triggers cleanup
     thread_local! {
-        static LOCAL_GUARDS: std::cell::RefCell<Vec<LocalGuard>> = const { std::cell::RefCell::new(Vec::new()) };
+        static LOCAL_GUARDS: RefCell<Vec<LocalGuard>> = const { RefCell::new(Vec::new()) };
     }
 
     // Guard that removes thread-local data when dropped
     struct LocalGuard {
-        local: std::sync::Weak<LocalData>,
+        local: Weak<LocalData>,
         thread_id: std::thread::ThreadId,
     }
 
@@ -769,8 +769,8 @@ pub(crate) mod _thread {
         data: parking_lot::Mutex<std::collections::HashMap<std::thread::ThreadId, PyDictRef>>,
     }
 
-    impl std::fmt::Debug for LocalData {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl fmt::Debug for LocalData {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             f.debug_struct("LocalData").finish_non_exhaustive()
         }
     }
@@ -779,7 +779,7 @@ pub(crate) mod _thread {
     #[pyclass(module = "_thread", name = "_local")]
     #[derive(Debug, PyPayload)]
     struct Local {
-        inner: std::sync::Arc<LocalData>,
+        inner: Arc<LocalData>,
     }
 
     #[pyclass(with(GetAttr, SetAttr), flags(BASETYPE))]
@@ -810,7 +810,7 @@ pub(crate) mod _thread {
             // Register cleanup guard only if we inserted a new entry
             if need_guard {
                 let guard = LocalGuard {
-                    local: std::sync::Arc::downgrade(&self.inner),
+                    local: Arc::downgrade(&self.inner),
                     thread_id,
                 };
                 LOCAL_GUARDS.with(|guards| {
@@ -824,7 +824,7 @@ pub(crate) mod _thread {
         #[pyslot]
         fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
             Self {
-                inner: std::sync::Arc::new(LocalData {
+                inner: Arc::new(LocalData {
                     data: parking_lot::Mutex::new(std::collections::HashMap::new()),
                 }),
             }
@@ -879,8 +879,8 @@ pub(crate) mod _thread {
     // Registry of all ThreadHandles for fork cleanup
     // Stores weak references so handles can be garbage collected normally
     pub type HandleEntry = (
-        std::sync::Weak<parking_lot::Mutex<ThreadHandleInner>>,
-        std::sync::Weak<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+        Weak<parking_lot::Mutex<ThreadHandleInner>>,
+        Weak<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
     );
 
     // Re-export type from vm::thread for PyGlobalState
@@ -1030,15 +1030,15 @@ pub(crate) mod _thread {
     #[pyclass(module = "_thread", name = "_ThreadHandle")]
     #[derive(Debug, PyPayload)]
     struct ThreadHandle {
-        inner: std::sync::Arc<parking_lot::Mutex<ThreadHandleInner>>,
+        inner: Arc<parking_lot::Mutex<ThreadHandleInner>>,
         // Event to signal thread completion (for timed join support)
-        done_event: std::sync::Arc<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+        done_event: Arc<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
     }
 
     #[pyclass]
     impl ThreadHandle {
         fn new(vm: &VirtualMachine) -> Self {
-            let inner = std::sync::Arc::new(parking_lot::Mutex::new(ThreadHandleInner {
+            let inner = Arc::new(parking_lot::Mutex::new(ThreadHandleInner {
                 state: ThreadHandleState::NotStarted,
                 ident: 0,
                 join_handle: None,
@@ -1046,13 +1046,13 @@ pub(crate) mod _thread {
                 joined: false,
             }));
             let done_event =
-                std::sync::Arc::new((parking_lot::Mutex::new(false), parking_lot::Condvar::new()));
+                Arc::new((parking_lot::Mutex::new(false), parking_lot::Condvar::new()));
 
             // Register in global registry for fork cleanup
-            vm.state.thread_handles.lock().push((
-                std::sync::Arc::downgrade(&inner),
-                std::sync::Arc::downgrade(&done_event),
-            ));
+            vm.state
+                .thread_handles
+                .lock()
+                .push((Arc::downgrade(&inner), Arc::downgrade(&done_event)));
 
             Self { inner, done_event }
         }

crates/vm/src/stdlib/time.rs

@@ -179,7 +179,7 @@ mod decl {
     #[cfg(target_env = "msvc")]
     #[cfg(not(target_arch = "wasm32"))]
     fn get_tz_info() -> TIME_ZONE_INFORMATION {
-        let mut info: TIME_ZONE_INFORMATION = unsafe { std::mem::zeroed() };
+        let mut info: TIME_ZONE_INFORMATION = unsafe { core::mem::zeroed() };
         unsafe { GetTimeZoneInformation(&mut info) };
         info
     }
@@ -437,7 +437,7 @@ mod decl {
     #[cfg(all(target_arch = "wasm32", target_os = "emscripten"))]
     fn get_process_time(vm: &VirtualMachine) -> PyResult<Duration> {
         let t: libc::tms = unsafe {
-            let mut t = std::mem::MaybeUninit::uninit();
+            let mut t = core::mem::MaybeUninit::uninit();
             if libc::times(t.as_mut_ptr()) == -1 {
                 return Err(vm.new_os_error("Failed to get clock time".to_owned()));
             }
@@ -820,7 +820,7 @@ mod platform {
         PyRef, PyResult, VirtualMachine,
         builtins::{PyNamespace, PyStrRef},
     };
-    use std::time::Duration;
+    use core::time::Duration;
     use windows_sys::Win32::{
         Foundation::FILETIME,
         System::Performance::{QueryPerformanceCounter, QueryPerformanceFrequency},
@@ -835,7 +835,7 @@ mod platform {
 
     fn win_perf_counter_frequency(vm: &VirtualMachine) -> PyResult<i64> {
         let frequency = unsafe {
-            let mut freq = std::mem::MaybeUninit::uninit();
+            let mut freq = core::mem::MaybeUninit::uninit();
             if QueryPerformanceFrequency(freq.as_mut_ptr()) == 0 {
                 return Err(vm.new_last_os_error());
             }
@@ -862,7 +862,7 @@ mod platform {
 
     pub(super) fn get_perf_time(vm: &VirtualMachine) -> PyResult<Duration> {
         let ticks = unsafe {
-            let mut performance_count = std::mem::MaybeUninit::uninit();
+            let mut performance_count = core::mem::MaybeUninit::uninit();
             QueryPerformanceCounter(performance_count.as_mut_ptr());
             performance_count.assume_init()
         };
@@ -875,9 +875,9 @@ mod platform {
     }
 
     fn get_system_time_adjustment(vm: &VirtualMachine) -> PyResult<u32> {
-        let mut _time_adjustment = std::mem::MaybeUninit::uninit();
-        let mut time_increment = std::mem::MaybeUninit::uninit();
-        let mut _is_time_adjustment_disabled = std::mem::MaybeUninit::uninit();
+        let mut _time_adjustment = core::mem::MaybeUninit::uninit();
+        let mut time_increment = core::mem::MaybeUninit::uninit();
+        let mut _is_time_adjustment_disabled = core::mem::MaybeUninit::uninit();
         let time_increment = unsafe {
             if GetSystemTimeAdjustment(
                 _time_adjustment.as_mut_ptr(),
@@ -939,10 +939,10 @@ mod platform {
 
     pub(super) fn get_thread_time(vm: &VirtualMachine) -> PyResult<Duration> {
         let (kernel_time, user_time) = unsafe {
-            let mut _creation_time = std::mem::MaybeUninit::uninit();
-            let mut _exit_time = std::mem::MaybeUninit::uninit();
-            let mut kernel_time = std::mem::MaybeUninit::uninit();
-            let mut user_time = std::mem::MaybeUninit::uninit();
+            let mut _creation_time = core::mem::MaybeUninit::uninit();
+            let mut _exit_time = core::mem::MaybeUninit::uninit();
+            let mut kernel_time = core::mem::MaybeUninit::uninit();
+            let mut user_time = core::mem::MaybeUninit::uninit();
 
             let thread = GetCurrentThread();
             if GetThreadTimes(
@@ -964,10 +964,10 @@ mod platform {
 
     pub(super) fn get_process_time(vm: &VirtualMachine) -> PyResult<Duration> {
         let (kernel_time, user_time) = unsafe {
-            let mut _creation_time = std::mem::MaybeUninit::uninit();
-            let mut _exit_time = std::mem::MaybeUninit::uninit();
-            let mut kernel_time = std::mem::MaybeUninit::uninit();
-            let mut user_time = std::mem::MaybeUninit::uninit();
+            let mut _creation_time = core::mem::MaybeUninit::uninit();
+            let mut _exit_time = core::mem::MaybeUninit::uninit();
+            let mut kernel_time = core::mem::MaybeUninit::uninit();
+            let mut user_time = core::mem::MaybeUninit::uninit();
 
             let process = GetCurrentProcess();
             if GetProcessTimes(

crates/vm/src/stdlib/winapi.rs

@@ -14,7 +14,7 @@ mod _winapi {
         types::Constructor,
         windows::{WinHandle, WindowsSysResult},
     };
-    use std::ptr::{null, null_mut};
+    use core::ptr::{null, null_mut};
     use windows_sys::Win32::Foundation::{HANDLE, INVALID_HANDLE_VALUE, MAX_PATH};
 
     #[pyattr]
@@ -179,8 +179,8 @@ mod _winapi {
     ) -> PyResult<(WinHandle, WinHandle)> {
         use windows_sys::Win32::Foundation::HANDLE;
         let (read, write) = unsafe {
-            let mut read = std::mem::MaybeUninit::<HANDLE>::uninit();
-            let mut write = std::mem::MaybeUninit::<HANDLE>::uninit();
+            let mut read = core::mem::MaybeUninit::<HANDLE>::uninit();
+            let mut write = core::mem::MaybeUninit::<HANDLE>::uninit();
             WindowsSysResult(windows_sys::Win32::System::Pipes::CreatePipe(
                 read.as_mut_ptr(),
                 write.as_mut_ptr(),
@@ -205,7 +205,7 @@ mod _winapi {
     ) -> PyResult<WinHandle> {
         use windows_sys::Win32::Foundation::HANDLE;
         let target = unsafe {
-            let mut target = std::mem::MaybeUninit::<HANDLE>::uninit();
+            let mut target = core::mem::MaybeUninit::<HANDLE>::uninit();
             WindowsSysResult(windows_sys::Win32::Foundation::DuplicateHandle(
                 src_process.0,
                 src.0,
@@ -282,8 +282,8 @@ mod _winapi {
         vm: &VirtualMachine,
     ) -> PyResult<(WinHandle, WinHandle, u32, u32)> {
         let mut si: windows_sys::Win32::System::Threading::STARTUPINFOEXW =
-            unsafe { std::mem::zeroed() };
-        si.StartupInfo.cb = std::mem::size_of_val(&si) as _;
+            unsafe { core::mem::zeroed() };
+        si.StartupInfo.cb = core::mem::size_of_val(&si) as _;
 
         macro_rules! si_attr {
             ($attr:ident, $t:ty) => {{
@@ -351,7 +351,7 @@ mod _winapi {
             .map_or_else(null_mut, |w| w.as_mut_ptr());
 
         let procinfo = unsafe {
-            let mut procinfo = std::mem::MaybeUninit::uninit();
+            let mut procinfo = core::mem::MaybeUninit::uninit();
             WindowsSysResult(windows_sys::Win32::System::Threading::CreateProcessW(
                 app_name,
                 command_line,
@@ -505,10 +505,10 @@ mod _winapi {
 
                 let attr_count = handlelist.is_some() as u32;
                 let (result, mut size) = unsafe {
-                    let mut size = std::mem::MaybeUninit::uninit();
+                    let mut size = core::mem::MaybeUninit::uninit();
                     let result = WindowsSysResult(
                         windows_sys::Win32::System::Threading::InitializeProcThreadAttributeList(
-                            std::ptr::null_mut(),
+                            core::ptr::null_mut(),
                             attr_count,
                             0,
                             size.as_mut_ptr(),
@@ -543,8 +543,8 @@ mod _winapi {
                             0,
                             (2 & 0xffff) | 0x20000, // PROC_THREAD_ATTRIBUTE_HANDLE_LIST
                             handlelist.as_mut_ptr() as _,
-                            (handlelist.len() * std::mem::size_of::<usize>()) as _,
-                            std::ptr::null_mut(),
+                            (handlelist.len() * core::mem::size_of::<usize>()) as _,
+                            core::ptr::null_mut(),
                             core::ptr::null(),
                         )
                     })
@@ -618,7 +618,7 @@ mod _winapi {
     #[pyfunction]
     fn GetExitCodeProcess(h: WinHandle, vm: &VirtualMachine) -> PyResult<u32> {
         unsafe {
-            let mut ec = std::mem::MaybeUninit::uninit();
+            let mut ec = core::mem::MaybeUninit::uninit();
             WindowsSysResult(windows_sys::Win32::System::Threading::GetExitCodeProcess(
                 h.0,
                 ec.as_mut_ptr(),
@@ -838,8 +838,8 @@ mod _winapi {
         write_buffer: Option<Vec<u8>>,
     }
 
-    impl std::fmt::Debug for OverlappedInner {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for OverlappedInner {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_struct("OverlappedInner")
                 .field("handle", &self.handle)
                 .field("pending", &self.pending)
@@ -858,7 +858,7 @@ mod _winapi {
 
             let event = unsafe { CreateEventW(null(), 1, 0, null()) };
             let mut overlapped: windows_sys::Win32::System::IO::OVERLAPPED =
-                unsafe { std::mem::zeroed() };
+                unsafe { core::mem::zeroed() };
             overlapped.hEvent = event;
 
             Overlapped {
@@ -1323,8 +1323,8 @@ mod _winapi {
         milliseconds: OptionalArg<u32>,
         vm: &VirtualMachine,
     ) -> PyResult<PyObjectRef> {
-        use std::sync::Arc;
-        use std::sync::atomic::{AtomicU32, Ordering};
+        use alloc::sync::Arc;
+        use core::sync::atomic::{AtomicU32, Ordering};
         use windows_sys::Win32::Foundation::{CloseHandle, WAIT_FAILED, WAIT_OBJECT_0};
         use windows_sys::Win32::System::SystemInformation::GetTickCount64;
         use windows_sys::Win32::System::Threading::{
@@ -1468,7 +1468,7 @@ mod _winapi {
                 cancel_event: isize,
                 handle_base: usize,
                 result: AtomicU32,
-                thread: std::cell::UnsafeCell<isize>,
+                thread: core::cell::UnsafeCell<isize>,
             }
 
             unsafe impl Send for BatchData {}
@@ -1486,13 +1486,13 @@ mod _winapi {
                         cancel_event: cancel_event as isize,
                         handle_base: base,
                         result: AtomicU32::new(WAIT_FAILED),
-                        thread: std::cell::UnsafeCell::new(0),
+                        thread: core::cell::UnsafeCell::new(0),
                     })
                 })
                 .collect();
 
             // Thread function
-            extern "system" fn batch_wait_thread(param: *mut std::ffi::c_void) -> u32 {
+            extern "system" fn batch_wait_thread(param: *mut core::ffi::c_void) -> u32 {
                 let data = unsafe { &*(param as *const BatchData) };
                 let handles: Vec<_> = data.handles.iter().map(|&h| h as _).collect();
                 let result = unsafe {

crates/vm/src/stdlib/winreg.rs

@@ -14,10 +14,10 @@ mod winreg {
     use crate::protocol::PyNumberMethods;
     use crate::types::{AsNumber, Hashable};
     use crate::{Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine};
+    use core::ptr;
     use crossbeam_utils::atomic::AtomicCell;
     use malachite_bigint::Sign;
     use num_traits::ToPrimitive;
-    use std::ptr;
     use windows_sys::Win32::Foundation::{self, ERROR_MORE_DATA};
     use windows_sys::Win32::System::Registry;
 
@@ -188,7 +188,7 @@ mod winreg {
         #[pymethod]
         fn Close(&self, vm: &VirtualMachine) -> PyResult<()> {
             // Atomically swap the handle with null and get the old value
-            let old_hkey = self.hkey.swap(std::ptr::null_mut());
+            let old_hkey = self.hkey.swap(core::ptr::null_mut());
             // Already closed - silently succeed
             if old_hkey.is_null() {
                 return Ok(());
@@ -204,7 +204,7 @@ mod winreg {
         #[pymethod]
         fn Detach(&self) -> PyResult<usize> {
             // Atomically swap the handle with null and return the old value
-            let old_hkey = self.hkey.swap(std::ptr::null_mut());
+            let old_hkey = self.hkey.swap(core::ptr::null_mut());
             Ok(old_hkey as usize)
         }
 
@@ -230,7 +230,7 @@ mod winreg {
 
     impl Drop for PyHkey {
         fn drop(&mut self) {
-            let hkey = self.hkey.swap(std::ptr::null_mut());
+            let hkey = self.hkey.swap(core::ptr::null_mut());
             if !hkey.is_null() {
                 unsafe { Registry::RegCloseKey(hkey) };
             }
@@ -290,7 +290,7 @@ mod winreg {
         vm: &VirtualMachine,
     ) -> PyResult<PyHkey> {
         if let Some(computer_name) = computer_name {
-            let mut ret_key = std::ptr::null_mut();
+            let mut ret_key = core::ptr::null_mut();
             let wide_computer_name = computer_name.to_wide_with_nul();
             let res = unsafe {
                 Registry::RegConnectRegistryW(
@@ -305,9 +305,9 @@ mod winreg {
                 Err(vm.new_os_error(format!("error code: {res}")))
             }
         } else {
-            let mut ret_key = std::ptr::null_mut();
+            let mut ret_key = core::ptr::null_mut();
             let res = unsafe {
-                Registry::RegConnectRegistryW(std::ptr::null_mut(), key.hkey.load(), &mut ret_key)
+                Registry::RegConnectRegistryW(core::ptr::null_mut(), key.hkey.load(), &mut ret_key)
             };
             if res == 0 {
                 Ok(PyHkey::new(ret_key))
@@ -320,7 +320,7 @@ mod winreg {
     #[pyfunction]
     fn CreateKey(key: PyRef<PyHkey>, sub_key: String, vm: &VirtualMachine) -> PyResult<PyHkey> {
         let wide_sub_key = sub_key.to_wide_with_nul();
-        let mut out_key = std::ptr::null_mut();
+        let mut out_key = core::ptr::null_mut();
         let res = unsafe {
             Registry::RegCreateKeyW(key.hkey.load(), wide_sub_key.as_ptr(), &mut out_key)
         };
@@ -358,7 +358,7 @@ mod winreg {
                 args.access,
                 core::ptr::null(),
                 &mut res,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
         if err == 0 {
@@ -447,10 +447,10 @@ mod winreg {
                 index as u32,
                 tmpbuf.as_mut_ptr(),
                 &mut len,
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
         if res != 0 {
@@ -596,7 +596,7 @@ mod winreg {
     #[pyfunction(name = "OpenKeyEx")]
     fn OpenKey(args: OpenKeyArgs, vm: &VirtualMachine) -> PyResult<PyHkey> {
         let wide_sub_key = args.sub_key.to_wide_with_nul();
-        let mut res: Registry::HKEY = std::ptr::null_mut();
+        let mut res: Registry::HKEY = core::ptr::null_mut();
         let err = unsafe {
             let key = args.key.hkey.load();
             Registry::RegOpenKeyExW(
@@ -622,20 +622,20 @@ mod winreg {
         let key = key.0;
         let mut lpcsubkeys: u32 = 0;
         let mut lpcvalues: u32 = 0;
-        let mut lpftlastwritetime: Foundation::FILETIME = unsafe { std::mem::zeroed() };
+        let mut lpftlastwritetime: Foundation::FILETIME = unsafe { core::mem::zeroed() };
         let err = unsafe {
             Registry::RegQueryInfoKeyW(
                 key,
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
                 0 as _,
                 &mut lpcsubkeys,
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
                 &mut lpcvalues,
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
                 &mut lpftlastwritetime,
             )
         };
@@ -669,7 +669,7 @@ mod winreg {
         let child_key = if let Some(ref sk) = sub_key {
             if !sk.is_empty() {
                 let wide_sub_key = sk.to_wide_with_nul();
-                let mut out_key = std::ptr::null_mut();
+                let mut out_key = core::ptr::null_mut();
                 let res = unsafe {
                     Registry::RegOpenKeyExW(
                         hkey,
@@ -702,7 +702,7 @@ mod winreg {
                 Registry::RegQueryValueExW(
                     target_key,
                     core::ptr::null(), // NULL value name for default value
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                     &mut reg_type,
                     buffer.as_mut_ptr(),
                     &mut size,
@@ -759,9 +759,9 @@ mod winreg {
             Registry::RegQueryValueExW(
                 hkey,
                 wide_name.as_ptr(),
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
                 &mut buf_size,
             )
         };
@@ -787,7 +787,7 @@ mod winreg {
                 Registry::RegQueryValueExW(
                     hkey,
                     wide_name.as_ptr(),
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                     &mut typ,
                     ret_buf.as_mut_ptr(),
                     &mut ret_size,
@@ -820,7 +820,7 @@ mod winreg {
     fn SaveKey(key: PyRef<PyHkey>, file_name: String, vm: &VirtualMachine) -> PyResult<()> {
         let file_name = file_name.to_wide_with_nul();
         let res = unsafe {
-            Registry::RegSaveKeyW(key.hkey.load(), file_name.as_ptr(), std::ptr::null_mut())
+            Registry::RegSaveKeyW(key.hkey.load(), file_name.as_ptr(), core::ptr::null_mut())
         };
         if res == 0 {
             Ok(())
@@ -853,7 +853,7 @@ mod winreg {
         // Create subkey if sub_key is non-empty
         let child_key = if !sub_key.is_empty() {
             let wide_sub_key = sub_key.to_wide_with_nul();
-            let mut out_key = std::ptr::null_mut();
+            let mut out_key = core::ptr::null_mut();
             let res = unsafe {
                 Registry::RegCreateKeyExW(
                     hkey,
@@ -864,7 +864,7 @@ mod winreg {
                     Registry::KEY_SET_VALUE,
                     core::ptr::null(),
                     &mut out_key,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                 )
             };
             if res != 0 {
@@ -1150,7 +1150,7 @@ mod winreg {
         let required_size = unsafe {
             windows_sys::Win32::System::Environment::ExpandEnvironmentStringsW(
                 wide_input.as_ptr(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
                 0,
             )
         };

crates/vm/src/vm/interpreter.rs

@@ -3,6 +3,7 @@ use crate::{
     PyResult, builtins, common::rc::PyRc, frozen::FrozenModule, getpath, py_freeze, stdlib::atexit,
     vm::PyBaseExceptionRef,
 };
+use alloc::collections::BTreeMap;
 use core::sync::atomic::Ordering;
 
 type InitFunc = Box<dyn FnOnce(&mut VirtualMachine)>;
@@ -45,8 +46,8 @@ where
     use crate::common::hash::HashSecret;
     use crate::common::lock::PyMutex;
     use crate::warn::WarningsState;
+    use core::sync::atomic::AtomicBool;
     use crossbeam_utils::atomic::AtomicCell;
-    use std::sync::atomic::AtomicBool;
 
     let paths = getpath::init_path_config(&settings);
     let config = PyConfig::new(settings, paths);
@@ -55,14 +56,12 @@ where
     crate::exceptions::ExceptionZoo::extend(&ctx);
 
     // Build module_defs map from builtin modules + additional modules
-    let mut all_module_defs: std::collections::BTreeMap<
-        &'static str,
-        &'static builtins::PyModuleDef,
-    > = crate::stdlib::builtin_module_defs(&ctx)
-        .into_iter()
-        .chain(module_defs)
-        .map(|def| (def.name.as_str(), def))
-        .collect();
+    let mut all_module_defs: BTreeMap<&'static str, &'static builtins::PyModuleDef> =
+        crate::stdlib::builtin_module_defs(&ctx)
+            .into_iter()
+            .chain(module_defs)
+            .map(|def| (def.name.as_str(), def))
+            .collect();
 
     // Register sysconfigdata under platform-specific name as well
     if let Some(&sysconfigdata_def) = all_module_defs.get("_sysconfigdata") {

crates/vm/src/vm/mod.rs

@@ -39,10 +39,10 @@ use crate::{
     signal, stdlib,
     warn::WarningsState,
 };
-use alloc::borrow::Cow;
+use alloc::{borrow::Cow, collections::BTreeMap};
 use core::{
     cell::{Cell, Ref, RefCell},
-    sync::atomic::AtomicBool,
+    sync::atomic::{AtomicBool, Ordering},
 };
 use crossbeam_utils::atomic::AtomicCell;
 #[cfg(unix)]
@@ -106,7 +106,7 @@ struct ExceptionStack {
 
 pub struct PyGlobalState {
     pub config: PyConfig,
-    pub module_defs: std::collections::BTreeMap<&'static str, &'static builtins::PyModuleDef>,
+    pub module_defs: BTreeMap<&'static str, &'static builtins::PyModuleDef>,
     pub frozen: HashMap<&'static str, FrozenModule, ahash::RandomState>,
     pub stacksize: AtomicCell<usize>,
     pub thread_count: AtomicCell<usize>,
@@ -508,11 +508,7 @@ impl VirtualMachine {
         // During interpreter finalization, sys.unraisablehook may not be available,
         // but we still need to report exceptions (especially from atexit callbacks).
         // Write directly to stderr like PyErr_FormatUnraisable.
-        if self
-            .state
-            .finalizing
-            .load(std::sync::atomic::Ordering::Acquire)
-        {
+        if self.state.finalizing.load(Ordering::Acquire) {
             self.write_unraisable_to_stderr(&e, msg.as_deref(), &object);
             return;
         }
@@ -826,7 +822,7 @@ impl VirtualMachine {
 
     /// Stack margin bytes (like _PyOS_STACK_MARGIN_BYTES).
     /// 2048 * sizeof(void*) = 16KB for 64-bit.
-    const STACK_MARGIN_BYTES: usize = 2048 * std::mem::size_of::<usize>();
+    const STACK_MARGIN_BYTES: usize = 2048 * core::mem::size_of::<usize>();
 
     /// Get the stack boundaries using platform-specific APIs.
     /// Returns (base, top) where base is the lowest address and top is the highest.
@@ -858,10 +854,10 @@ impl VirtualMachine {
                 pthread_attr_destroy, pthread_attr_getstack, pthread_attr_t, pthread_getattr_np,
                 pthread_self,
             };
-            let mut attr: pthread_attr_t = unsafe { std::mem::zeroed() };
+            let mut attr: pthread_attr_t = unsafe { core::mem::zeroed() };
             unsafe {
                 if pthread_getattr_np(pthread_self(), &mut attr) == 0 {
-                    let mut stack_addr: *mut libc::c_void = std::ptr::null_mut();
+                    let mut stack_addr: *mut libc::c_void = core::ptr::null_mut();
                     let mut stack_size: libc::size_t = 0;
                     if pthread_attr_getstack(&attr, &mut stack_addr, &mut stack_size) == 0 {
                         pthread_attr_destroy(&mut attr);

crates/vm/src/vm/thread.rs

@@ -2,14 +2,14 @@ use crate::frame::Frame;
 #[cfg(feature = "threading")]
 use crate::frame::FrameRef;
 use crate::{AsObject, PyObject, VirtualMachine};
+#[cfg(feature = "threading")]
+use alloc::sync::Arc;
 use core::{
     cell::{Cell, RefCell},
     ptr::NonNull,
     sync::atomic::{AtomicPtr, Ordering},
 };
 use itertools::Itertools;
-#[cfg(feature = "threading")]
-use std::sync::Arc;
 use std::thread_local;
 
 /// Type for current frame slot - shared between threads for sys._current_frames()

crates/vm/src/windows.rs

@@ -79,7 +79,7 @@ impl ToPyObject for WinHandle {
 pub fn init_winsock() {
     static WSA_INIT: parking_lot::Once = parking_lot::Once::new();
     WSA_INIT.call_once(|| unsafe {
-        let mut wsa_data = std::mem::MaybeUninit::uninit();
+        let mut wsa_data = core::mem::MaybeUninit::uninit();
         let _ = windows_sys::Win32::Networking::WinSock::WSAStartup(0x0101, wsa_data.as_mut_ptr());
     })
 }
@@ -244,7 +244,7 @@ fn attributes_from_dir(
     };
 
     let wide: Vec<u16> = path.to_wide_with_nul();
-    let mut find_data: WIN32_FIND_DATAW = unsafe { std::mem::zeroed() };
+    let mut find_data: WIN32_FIND_DATAW = unsafe { core::mem::zeroed() };
 
     let handle = unsafe { FindFirstFileW(wide.as_ptr(), &mut find_data) };
     if handle == INVALID_HANDLE_VALUE {
@@ -252,7 +252,7 @@ fn attributes_from_dir(
     }
     unsafe { FindClose(handle) };
 
-    let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { std::mem::zeroed() };
+    let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { core::mem::zeroed() };
     info.dwFileAttributes = find_data.dwFileAttributes;
     info.ftCreationTime = find_data.ftCreationTime;
     info.ftLastAccessTime = find_data.ftLastAccessTime;
@@ -304,11 +304,11 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
             core::ptr::null(),
             OPEN_EXISTING,
             flags,
-            std::ptr::null_mut(),
+            core::ptr::null_mut(),
         )
     };
 
-    let mut file_info: BY_HANDLE_FILE_INFORMATION = unsafe { std::mem::zeroed() };
+    let mut file_info: BY_HANDLE_FILE_INFORMATION = unsafe { core::mem::zeroed() };
     let mut tag_info = FileAttributeTagInfo::default();
     let mut is_unhandled_tag = false;
 
@@ -340,7 +340,7 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
                         core::ptr::null(),
                         OPEN_EXISTING,
                         flags,
-                        std::ptr::null_mut(),
+                        core::ptr::null_mut(),
                     )
                 };
                 if h_file == INVALID_HANDLE_VALUE {
@@ -358,7 +358,7 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
                         core::ptr::null(),
                         OPEN_EXISTING,
                         flags | FILE_FLAG_OPEN_REPARSE_POINT,
-                        std::ptr::null_mut(),
+                        core::ptr::null_mut(),
                     )
                 };
                 if h_file == INVALID_HANDLE_VALUE {
@@ -400,13 +400,13 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
 
             // Query the reparse tag
             if !traverse || is_unhandled_tag {
-                let mut local_tag_info: FileAttributeTagInfo = unsafe { std::mem::zeroed() };
+                let mut local_tag_info: FileAttributeTagInfo = unsafe { core::mem::zeroed() };
                 let ret = unsafe {
                     GetFileInformationByHandleEx(
                         h_file,
                         FileAttributeTagInfo,
                         &mut local_tag_info as *mut _ as *mut _,
-                        std::mem::size_of::<FileAttributeTagInfo>() as u32,
+                        core::mem::size_of::<FileAttributeTagInfo>() as u32,
                     )
                 };
                 if ret == 0 {
@@ -453,24 +453,24 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
             }
 
             // Get FILE_BASIC_INFO
-            let mut basic_info: FILE_BASIC_INFO = unsafe { std::mem::zeroed() };
+            let mut basic_info: FILE_BASIC_INFO = unsafe { core::mem::zeroed() };
             let has_basic_info = unsafe {
                 GetFileInformationByHandleEx(
                     h_file,
                     FileBasicInfo,
                     &mut basic_info as *mut _ as *mut _,
-                    std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+                    core::mem::size_of::<FILE_BASIC_INFO>() as u32,
                 )
             } != 0;
 
             // Get FILE_ID_INFO (optional)
-            let mut id_info: FILE_ID_INFO = unsafe { std::mem::zeroed() };
+            let mut id_info: FILE_ID_INFO = unsafe { core::mem::zeroed() };
             let has_id_info = unsafe {
                 GetFileInformationByHandleEx(
                     h_file,
                     FileIdInfo,
                     &mut id_info as *mut _ as *mut _,
-                    std::mem::size_of::<FILE_ID_INFO>() as u32,
+                    core::mem::size_of::<FILE_ID_INFO>() as u32,
                 )
             } != 0;