From 360fb1f2bc8feb285687289b8ef6dec2d0cb08e6 Mon Sep 17 00:00:00 2001 From: "Jeong, YunWon" Date: Sun, 8 Feb 2026 11:06:08 +0900 Subject: [PATCH 1/2] no_std clippy --- Cargo.toml | 6 +- crates/codegen/src/compile.rs | 4 +- crates/common/src/crt_fd.rs | 4 +- crates/common/src/fileutils.rs | 17 ++-- crates/stdlib/src/_asyncio.rs | 2 +- crates/stdlib/src/_sqlite3.rs | 26 +++--- crates/stdlib/src/math.rs | 4 +- crates/stdlib/src/mmap.rs | 10 +- crates/stdlib/src/multiprocessing.rs | 16 ++-- crates/stdlib/src/overlapped.rs | 118 ++++++++++++------------ crates/stdlib/src/posixsubprocess.rs | 2 +- crates/stdlib/src/socket.rs | 63 +++++++------ crates/stdlib/src/ssl.rs | 8 +- crates/vm/src/builtins/function.rs | 11 ++- crates/vm/src/builtins/template.rs | 10 +- crates/vm/src/builtins/tuple.rs | 2 +- crates/vm/src/frame.rs | 2 +- crates/vm/src/signal.rs | 2 +- crates/vm/src/stdlib/_abc.rs | 2 +- crates/vm/src/stdlib/codecs.rs | 34 +++---- crates/vm/src/stdlib/ctypes.rs | 14 +-- crates/vm/src/stdlib/ctypes/base.rs | 2 + crates/vm/src/stdlib/ctypes/function.rs | 10 +- crates/vm/src/stdlib/ctypes/pointer.rs | 1 + crates/vm/src/stdlib/ctypes/simple.rs | 4 + crates/vm/src/stdlib/io.rs | 7 +- crates/vm/src/stdlib/msvcrt.rs | 4 +- crates/vm/src/stdlib/nt.rs | 95 +++++++++---------- crates/vm/src/stdlib/os.rs | 10 +- crates/vm/src/stdlib/signal.rs | 6 +- crates/vm/src/stdlib/sys.rs | 8 +- crates/vm/src/stdlib/thread.rs | 56 +++++------ crates/vm/src/stdlib/time.rs | 32 +++---- crates/vm/src/stdlib/winapi.rs | 40 ++++---- crates/vm/src/stdlib/winreg.rs | 64 ++++++------- crates/vm/src/vm/interpreter.rs | 17 ++-- crates/vm/src/vm/mod.rs | 18 ++-- crates/vm/src/vm/thread.rs | 4 +- crates/vm/src/windows.rs | 26 +++--- 39 files changed, 389 insertions(+), 372 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index cf3c8d32de3..ef09e081d73 100644 --- a/Cargo.toml +++ b/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" diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs index 6101441dadf..ac62043fa66 100644 --- a/crates/codegen/src/compile.rs +++ b/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)?; diff --git a/crates/common/src/crt_fd.rs b/crates/common/src/crt_fd.rs index 7c93a30bb65..ab7c94f8b3b 100644 --- a/crates/common/src/crt_fd.rs +++ b/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); diff --git a/crates/common/src/fileutils.rs b/crates/common/src/fileutils.rs index af9e5ad2d96..a20140a6e04 100644 --- a/crates/common/src/fileutils.rs +++ b/crates/common/src/fileutils.rs @@ -24,8 +24,9 @@ pub fn fstat(fd: crate::crt_fd::Borrowed<'_>) -> std::io::Result { 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::() as u32; - let mut file_info_buffer = std::mem::MaybeUninit::::uninit(); + let file_info_buffer_size = core::mem::size_of::() as u32; + let mut file_info_buffer = core::mem::MaybeUninit::::uninit(); unsafe { if GetFileInformationByName( file_name.as_ptr(), diff --git a/crates/stdlib/src/_asyncio.rs b/crates/stdlib/src/_asyncio.rs index cc2e78bc35f..d7b5dad3c9d 100644 --- a/crates/stdlib/src/_asyncio.rs +++ b/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) -> PyResult<()> { __module_exec(vm, module); diff --git a/crates/stdlib/src/_sqlite3.rs b/crates/stdlib/src/_sqlite3.rs index 825fff06b75..f7ae445fe81 100644 --- a/crates/stdlib/src/_sqlite3.rs +++ b/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::()).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::()).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::()).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::(), nbytes as usize) + core::slice::from_raw_parts(blob.cast::(), 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", diff --git a/crates/stdlib/src/math.rs b/crates/stdlib/src/math.rs index 238c7fd4928..80463dcaa22 100644 --- a/crates/stdlib/src/math.rs +++ b/crates/stdlib/src/math.rs @@ -732,9 +732,9 @@ mod math { // Collect current + remaining elements let p_remaining: Result, _> = - std::iter::once(Ok(p_i)).chain(p_iter).collect(); + core::iter::once(Ok(p_i)).chain(p_iter).collect(); let q_remaining: Result, _> = - 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() { diff --git a/crates/stdlib/src/mmap.rs b/crates/stdlib/src/mmap.rs index 625b6db5f6c..c70b8dfec6e 100644 --- a/crates/stdlib/src/mmap.rs +++ b/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::() + core::mem::size_of::() } } @@ -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 } diff --git a/crates/stdlib/src/multiprocessing.rs b/crates/stdlib/src/multiprocessing.rs index f3a7831defe..b18cbbb24d9 100644 --- a/crates/stdlib/src/multiprocessing.rs +++ b/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())); } diff --git a/crates/stdlib/src/overlapped.rs b/crates/stdlib/src/overlapped.rs index 7520569c055..2f266a94ee8 100644 --- a/crates/stdlib/src/overlapped.rs +++ b/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::() as u32, + core::mem::size_of::() 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 = host.as_str().encode_utf16().chain([0]).collect(); - let mut addr_len = std::mem::size_of::() as i32; + let mut addr_len = core::mem::size_of::() 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::(), + core::mem::size_of::(), ) }; 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 = host.as_str().encode_utf16().chain([0]).collect(); - let mut addr_len = std::mem::size_of::() as i32; + let mut addr_len = core::mem::size_of::() 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::(), + core::mem::size_of::(), ) }; 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::() + 16; + let size = core::mem::size_of::() + 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::() as i32; + let address: SOCKADDR_IN6 = unsafe { core::mem::zeroed() }; + let address_length = core::mem::size_of::() 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::() as i32; + let address: SOCKADDR_IN6 = unsafe { core::mem::zeroed() }; + let address_length = core::mem::size_of::() 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 = address.encode_utf16().chain(std::iter::once(0)).collect(); + let address_wide: Vec = 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::sync::Mutex>>, > = std::sync::OnceLock::new(); - fn wait_callback_registry() - -> &'static std::sync::Mutex>> - { + fn wait_callback_registry() -> &'static std::sync::Mutex< + std::collections::HashMap>, + > { 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::() as i32, + core::mem::size_of::() 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::() as i32, + core::mem::size_of::() 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> = - 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, diff --git a/crates/stdlib/src/posixsubprocess.rs b/crates/stdlib/src/posixsubprocess.rs index 86f5dc8b145..fec2ceb16d5 100644 --- a/crates/stdlib/src/posixsubprocess.rs +++ b/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(), diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs index 32fba216e97..8c307eb54ec 100644 --- a/crates/stdlib/src/socket.rs +++ b/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::() as libc::socklen_t, + core::mem::size_of::() 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::() as libc::socklen_t, + core::mem::size_of::() as libc::socklen_t, ) }) } @@ -1420,7 +1422,7 @@ mod _socket { use crate::vm::builtins::PyBytes; if let Ok(bytes) = fileno_obj.clone().downcast::() { let bytes_data = bytes.as_bytes(); - let expected_size = std::mem::size_of::(); + let expected_size = core::mem::size_of::(); 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::() as u32) } as usize; + let space = + unsafe { libc::CMSG_SPACE(core::mem::size_of::() 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::() as u32) as _; + (*cmsg).cmsg_len = libc::CMSG_LEN(core::mem::size_of::() 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::() as u32) } as usize; + let space = + unsafe { libc::CMSG_SPACE(core::mem::size_of::() 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::() as u32) as _; + (*cmsg).cmsg_len = libc::CMSG_LEN(core::mem::size_of::() 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::() as u32, - std::ptr::null_mut(), + core::mem::size_of::() 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::() as u32, - std::ptr::null_mut(), + core::mem::size_of::() 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::(), + core::mem::size_of::(), ) }; @@ -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, + ptr: core::ptr::NonNull, } impl MibTable { fn get_raw() -> io::Result { - 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) } } } diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs index 5bb6c259e66..a1b089078a8 100644 --- a/crates/stdlib/src/ssl.rs +++ b/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, + timeout: Option, vm: &VirtualMachine, ) -> PyResult { 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 = 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") diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs index 522056169eb..3a85e7d16fb 100644 --- a/crates/vm/src/builtins/function.rs +++ b/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()); } diff --git a/crates/vm/src/builtins/template.rs b/crates/vm/src/builtins/template.rs index 2433c9082e5..f1969fc20eb 100644 --- a/crates/vm/src/builtins/template.rs +++ b/crates/vm/src/builtins/template.rs @@ -271,8 +271,8 @@ impl Representable for PyTemplate { #[derive(Debug)] pub struct PyTemplateIter { template: PyRef, - 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) -> 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, _vm: &VirtualMachine) -> PyResult { - use std::sync::atomic::Ordering; + use core::sync::atomic::Ordering; loop { let from_strings = zelf.from_strings.load(Ordering::SeqCst); diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs index ba296686c73..8e4f158d844 100644 --- a/crates/vm/src/builtins/tuple.rs +++ b/crates/vm/src/builtins/tuple.rs @@ -45,7 +45,7 @@ unsafe impl Traverse for PyTuple { } fn clear(&mut self, out: &mut Vec) { - let elements = std::mem::take(&mut self.elements); + let elements = core::mem::take(&mut self.elements); out.extend(elements.into_vec()); } } diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs index e1f67f4e521..d9da2efff75 100644 --- a/crates/vm/src/frame.rs +++ b/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() }, } } diff --git a/crates/vm/src/signal.rs b/crates/vm/src/signal.rs index 4846906d611..3ad207b333d 100644 --- a/crates/vm/src/signal.rs +++ b/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; diff --git a/crates/vm/src/stdlib/_abc.rs b/crates/vm/src/stdlib/_abc.rs index e04566b4b2d..72642c249f5 100644 --- a/crates/vm/src/stdlib/_abc.rs +++ b/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); diff --git a/crates/vm/src/stdlib/codecs.rs b/crates/vm/src/stdlib/codecs.rs index 161876c965a..85869e066cb 100644 --- a/crates/vm/src/stdlib/codecs.rs +++ b/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, ) }; diff --git a/crates/vm/src/stdlib/ctypes.rs b/crates/vm/src/stdlib/ctypes.rs index 97255f4384f..dd6a6e39091 100644 --- a/crates/vm/src/stdlib/ctypes.rs +++ b/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::() { // c_void_p etc: read pointer value from buffer let buffer = cdata.buffer.read(); - if buffer.len() >= std::mem::size_of::() { + if buffer.len() >= core::mem::size_of::() { usize::from_ne_bytes( - buffer[..std::mem::size_of::()] + buffer[..core::mem::size_of::()] .try_into() - .unwrap_or([0; std::mem::size_of::()]), + .unwrap_or([0; core::mem::size_of::()]), ) } 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); } } diff --git a/crates/vm/src/stdlib/ctypes/base.rs b/crates/vm/src/stdlib/ctypes/base.rs index 55cf358dce3..058b19c59c3 100644 --- a/crates/vm/src/stdlib/ctypes/base.rs +++ b/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)) diff --git a/crates/vm/src/stdlib/ctypes/function.rs b/crates/vm/src/stdlib/ctypes/function.rs index 8383f7460a4..e690ffbaf84 100644 --- a/crates/vm/src/stdlib/ctypes/function.rs +++ b/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::() { let buffer = simple.0.buffer.read(); - if buffer.len() >= std::mem::size_of::() { + if buffer.len() >= core::mem::size_of::() { super::base::read_ptr_from_buffer(&buffer) } else { 0 @@ -1936,6 +1940,10 @@ fn ffi_to_python(ty: &Py, 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)) diff --git a/crates/vm/src/stdlib/ctypes/pointer.rs b/crates/vm/src/stdlib/ctypes/pointer.rs index 875d78a0010..b0126b95b93 100644 --- a/crates/vm/src/stdlib/ctypes/pointer.rs +++ b/crates/vm/src/stdlib/ctypes/pointer.rs @@ -508,6 +508,7 @@ 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); } diff --git a/crates/vm/src/stdlib/ctypes/simple.rs b/crates/vm/src/stdlib/ctypes/simple.rs index 46228494d5e..48ff52e9cfa 100644 --- a/crates/vm/src/stdlib/ctypes/simple.rs +++ b/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)) diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs index d3e87857d2a..cb345ca5634 100644 --- a/crates/vm/src/stdlib/io.rs +++ b/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)); } } diff --git a/crates/vm/src/stdlib/msvcrt.rs b/crates/vm/src/stdlib/msvcrt.rs index 9986db3ff8c..cf194a3f7ba 100644 --- a/crates/vm/src/stdlib/msvcrt.rs +++ b/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 { @@ -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, vm: &VirtualMachine) -> PyResult<()> { diff --git a/crates/vm/src/stdlib/nt.rs b/crates/vm/src/stdlib/nt.rs index cfe93d4e9e7..1de7a559a35 100644 --- a/crates/vm/src/stdlib/nt.rs +++ b/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::() as u32, + core::mem::size_of::() as u32, ) }; if ret == 0 { @@ -303,7 +304,7 @@ pub(crate) mod module { handle, FileBasicInfo, &info as *const _ as *const _, - std::mem::size_of::() as u32, + core::mem::size_of::() 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::() as u32, + core::mem::size_of::() 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::() as u32, + core::mem::size_of::() 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::() as u32, - &mut volume_state as *mut _ as *mut std::ffi::c_void, - std::mem::size_of::() as u32, - std::ptr::null_mut(), - std::ptr::null_mut(), + &volume_state as *const _ as *const core::ffi::c_void, + core::mem::size_of::() as u32, + &mut volume_state as *mut _ as *mut core::ffi::c_void, + core::mem::size_of::() 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 { 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 { 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, 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::() { // 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 = s.as_wtf8().encode_wide().collect(); (wide, false) } else if let Some(b) = path.downcast_ref::() { - 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::() as u32, - lpSecurityDescriptor: std::ptr::null_mut(), + nLength: core::mem::size_of::() 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::() as u32, + nLength: core::mem::size_of::() 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::() as u32, - std::ptr::null_mut(), + &mut info as *mut _ as *mut core::ffi::c_void, + core::mem::size_of::() 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(), ) }; diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs index 37c7ecea0e8..4a1affea986 100644 --- a/crates/vm/src/stdlib/os.rs +++ b/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::::uninit(); diff --git a/crates/vm/src/stdlib/signal.rs b/crates/vm/src/stdlib/signal.rs index 33dfc038ef3..bd93aa194ec 100644 --- a/crates/vm/src/stdlib/signal.rs +++ b/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 { @@ -382,7 +382,7 @@ pub(crate) mod _signal { crate::windows::init_winsock(); let mut res = 0i32; - let mut res_size = std::mem::size_of::() as i32; + let mut res_size = core::mem::size_of::() 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::(), + core::ptr::null::(), flags, ) as libc::c_long }; diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs index 417a0ccb87a..323d1193376 100644 --- a/crates/vm/src/stdlib/sys.rs +++ b/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 = 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::() as u32; + let mut version: OSVERSIONINFOEXW = unsafe { core::mem::zeroed() }; + version.dwOSVersionInfoSize = core::mem::size_of::() 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. diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs index 0ea8bf11191..f7d00787858 100644 --- a/crates/vm/src/stdlib/thread.rs +++ b/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>, - std::sync::Weak<(parking_lot::Mutex, parking_lot::Condvar)>, + Weak>, + Weak<(parking_lot::Mutex, 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>, - done_event: &std::sync::Arc<(parking_lot::Mutex, parking_lot::Condvar)>, + inner: &Arc>, + done_event: &Arc<(parking_lot::Mutex, 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> = const { std::cell::RefCell::new(Vec::new()) }; + static LOCAL_GUARDS: RefCell> = const { RefCell::new(Vec::new()) }; } // Guard that removes thread-local data when dropped struct LocalGuard { - local: std::sync::Weak, + local: Weak, thread_id: std::thread::ThreadId, } @@ -769,8 +769,8 @@ pub(crate) mod _thread { data: parking_lot::Mutex>, } - 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, + inner: Arc, } #[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>, - std::sync::Weak<(parking_lot::Mutex, parking_lot::Condvar)>, + Weak>, + Weak<(parking_lot::Mutex, 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>, + inner: Arc>, // Event to signal thread completion (for timed join support) - done_event: std::sync::Arc<(parking_lot::Mutex, parking_lot::Condvar)>, + done_event: Arc<(parking_lot::Mutex, 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 } } diff --git a/crates/vm/src/stdlib/time.rs b/crates/vm/src/stdlib/time.rs index 6d9387a3a5a..d41e0370464 100644 --- a/crates/vm/src/stdlib/time.rs +++ b/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 { 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 { 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 { 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 { - 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 { 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 { 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( diff --git a/crates/vm/src/stdlib/winapi.rs b/crates/vm/src/stdlib/winapi.rs index 16766053058..4c3849d1abc 100644 --- a/crates/vm/src/stdlib/winapi.rs +++ b/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::::uninit(); - let mut write = std::mem::MaybeUninit::::uninit(); + let mut read = core::mem::MaybeUninit::::uninit(); + let mut write = core::mem::MaybeUninit::::uninit(); WindowsSysResult(windows_sys::Win32::System::Pipes::CreatePipe( read.as_mut_ptr(), write.as_mut_ptr(), @@ -205,7 +205,7 @@ mod _winapi { ) -> PyResult { use windows_sys::Win32::Foundation::HANDLE; let target = unsafe { - let mut target = std::mem::MaybeUninit::::uninit(); + let mut target = core::mem::MaybeUninit::::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::()) as _, - std::ptr::null_mut(), + (handlelist.len() * core::mem::size_of::()) as _, + core::ptr::null_mut(), core::ptr::null(), ) }) @@ -618,7 +618,7 @@ mod _winapi { #[pyfunction] fn GetExitCodeProcess(h: WinHandle, vm: &VirtualMachine) -> PyResult { 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>, } - 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, vm: &VirtualMachine, ) -> PyResult { - 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, + thread: core::cell::UnsafeCell, } 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 { diff --git a/crates/vm/src/stdlib/winreg.rs b/crates/vm/src/stdlib/winreg.rs index ec8cec4e337..6f0a7835562 100644 --- a/crates/vm/src/stdlib/winreg.rs +++ b/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 { // 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 { 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, sub_key: String, vm: &VirtualMachine) -> PyResult { 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 { 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, 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, ) }; diff --git a/crates/vm/src/vm/interpreter.rs b/crates/vm/src/vm/interpreter.rs index 9fcc11d7f42..f6408fe2012 100644 --- a/crates/vm/src/vm/interpreter.rs +++ b/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; @@ -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") { diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs index 6c507f1b701..92d03020586 100644 --- a/crates/vm/src/vm/mod.rs +++ b/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, pub thread_count: AtomicCell, @@ -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::(); + const STACK_MARGIN_BYTES: usize = 2048 * core::mem::size_of::(); /// 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); diff --git a/crates/vm/src/vm/thread.rs b/crates/vm/src/vm/thread.rs index c3d69bc3e61..c63cc4db0e7 100644 --- a/crates/vm/src/vm/thread.rs +++ b/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() diff --git a/crates/vm/src/windows.rs b/crates/vm/src/windows.rs index ff2b612c06d..017384e2f5c 100644 --- a/crates/vm/src/windows.rs +++ b/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 = 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 std::io::Result std::io::Result std::io::Result() as u32, + core::mem::size_of::() as u32, ) }; if ret == 0 { @@ -453,24 +453,24 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result() as u32, + core::mem::size_of::() 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::() as u32, + core::mem::size_of::() as u32, ) } != 0; From 4e8cf971c7541637ff52dffd787ad12f3ab7183e Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 8 Feb 2026 07:38:06 +0000 Subject: [PATCH 2/2] Auto-format: cargo fmt --all --- crates/vm/src/stdlib/ctypes/pointer.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/crates/vm/src/stdlib/ctypes/pointer.rs b/crates/vm/src/stdlib/ctypes/pointer.rs index b0126b95b93..794650c6098 100644 --- a/crates/vm/src/stdlib/ctypes/pointer.rs +++ b/crates/vm/src/stdlib/ctypes/pointer.rs @@ -508,7 +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")] + #[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); }