From cf46d5f944fb4184118cfb9a1004a7e82097e2d4 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Tue, 30 Dec 2025 13:51:44 +0900 Subject: [PATCH] more no_std clippy --- crates/common/src/os.rs | 2 +- crates/jit/tests/common.rs | 2 +- crates/sre_engine/benches/benches.rs | 2 +- crates/stdlib/src/scproxy.rs | 2 +- crates/stdlib/src/socket.rs | 32 +++++++++++++-------------- crates/stdlib/src/sqlite.rs | 6 +++-- crates/vm/src/function/builtin.rs | 2 +- crates/vm/src/stdlib/ctypes.rs | 2 +- crates/vm/src/stdlib/ctypes/array.rs | 4 ++-- crates/vm/src/stdlib/ctypes/simple.rs | 2 +- crates/vm/src/stdlib/os.rs | 10 ++++----- crates/vm/src/stdlib/posix.rs | 4 ++-- crates/vm/src/stdlib/thread.rs | 14 ++++++------ crates/wasm/src/browser_module.rs | 3 ++- crates/wasm/src/js_module.rs | 2 +- crates/wasm/src/lib.rs | 2 ++ crates/wasm/src/vm_class.rs | 8 +++---- 17 files changed, 50 insertions(+), 49 deletions(-) diff --git a/crates/common/src/os.rs b/crates/common/src/os.rs index 3e09a29210a..1ce25988d28 100644 --- a/crates/common/src/os.rs +++ b/crates/common/src/os.rs @@ -89,7 +89,7 @@ pub fn bytes_as_os_str(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> { #[cfg(not(unix))] pub fn bytes_as_os_str(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> { - Ok(std::str::from_utf8(b)?.as_ref()) + Ok(core::str::from_utf8(b)?.as_ref()) } #[cfg(unix)] diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs index 5dafeaeb807..17c280ec3c9 100644 --- a/crates/jit/tests/common.rs +++ b/crates/jit/tests/common.rs @@ -1,9 +1,9 @@ +use core::ops::ControlFlow; use rustpython_compiler_core::bytecode::{ CodeObject, ConstantData, Instruction, OpArg, OpArgState, }; use rustpython_jit::{CompiledCode, JitType}; use std::collections::HashMap; -use std::ops::ControlFlow; #[derive(Debug, Clone)] pub struct Function { diff --git a/crates/sre_engine/benches/benches.rs b/crates/sre_engine/benches/benches.rs index 127f72e2747..9905a8db70f 100644 --- a/crates/sre_engine/benches/benches.rs +++ b/crates/sre_engine/benches/benches.rs @@ -15,7 +15,7 @@ impl Pattern { fn state_range<'a, S: StrDrive>( &self, string: S, - range: std::ops::Range, + range: core::ops::Range, ) -> (Request<'a, S>, State) { let req = Request::new(string, range.start, range.end, self.code, false); let state = State::default(); diff --git a/crates/stdlib/src/scproxy.rs b/crates/stdlib/src/scproxy.rs index 40267579029..b105dc4f2fb 100644 --- a/crates/stdlib/src/scproxy.rs +++ b/crates/stdlib/src/scproxy.rs @@ -91,7 +91,7 @@ mod _scproxy { .find(host_key) .and_then(|v| v.downcast::()) { - let h = std::borrow::Cow::::from(&host); + let h = alloc::borrow::Cow::::from(&host); let v = if let Some(port) = proxy_dict .find(port_key) .and_then(|v| v.downcast::()) diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs index 71bc8e9f170..a37a4fd241d 100644 --- a/crates/stdlib/src/socket.rs +++ b/crates/stdlib/src/socket.rs @@ -1228,7 +1228,7 @@ mod _socket { .new_os_error("interface name too long".to_owned()) .into()); } - let cstr = std::ffi::CString::new(ifname) + let cstr = alloc::ffi::CString::new(ifname) .map_err(|_| vm.new_os_error("invalid interface name".to_owned()))?; let idx = unsafe { libc::if_nametoindex(cstr.as_ptr()) }; if idx == 0 { @@ -1238,7 +1238,7 @@ mod _socket { }; // Create sockaddr_can - let mut storage: libc::sockaddr_storage = unsafe { std::mem::zeroed() }; + let mut storage: libc::sockaddr_storage = unsafe { core::mem::zeroed() }; let can_addr = &mut storage as *mut libc::sockaddr_storage as *mut libc::sockaddr_can; unsafe { @@ -1294,7 +1294,7 @@ mod _socket { } // Create sockaddr_alg - let mut storage: libc::sockaddr_storage = unsafe { std::mem::zeroed() }; + let mut storage: libc::sockaddr_storage = unsafe { core::mem::zeroed() }; let alg_addr = &mut storage as *mut libc::sockaddr_storage as *mut libc::sockaddr_alg; unsafe { @@ -1936,7 +1936,7 @@ mod _socket { flags: OptionalArg, vm: &VirtualMachine, ) -> PyResult { - use std::mem::MaybeUninit; + use core::mem::MaybeUninit; if bufsize < 0 { return Err(vm.new_value_error("negative buffer size in recvmsg".to_owned())); @@ -1955,7 +1955,7 @@ mod _socket { // Allocate buffers let mut data_buf: Vec> = vec![MaybeUninit::uninit(); bufsize]; let mut anc_buf: Vec> = vec![MaybeUninit::uninit(); ancbufsize]; - let mut addr_storage: libc::sockaddr_storage = unsafe { std::mem::zeroed() }; + let mut addr_storage: libc::sockaddr_storage = unsafe { core::mem::zeroed() }; // Set up iovec let mut iov = [libc::iovec { @@ -1964,9 +1964,9 @@ mod _socket { }]; // Set up msghdr - let mut msg: libc::msghdr = unsafe { std::mem::zeroed() }; + let mut msg: libc::msghdr = unsafe { core::mem::zeroed() }; msg.msg_name = (&mut addr_storage as *mut libc::sockaddr_storage).cast(); - msg.msg_namelen = std::mem::size_of::() as libc::socklen_t; + msg.msg_namelen = core::mem::size_of::() as libc::socklen_t; msg.msg_iov = iov.as_mut_ptr(); msg.msg_iovlen = 1; if ancbufsize > 0 { @@ -1990,7 +1990,7 @@ mod _socket { // Build data bytes let data = unsafe { data_buf.set_len(n); - std::mem::transmute::>, Vec>(data_buf) + core::mem::transmute::>, Vec>(data_buf) }; // Build ancdata list @@ -1999,7 +1999,7 @@ mod _socket { // Build address tuple let address = if msg.msg_namelen > 0 { let storage: socket2::SockAddrStorage = - unsafe { std::mem::transmute(addr_storage) }; + unsafe { core::mem::transmute(addr_storage) }; let addr = unsafe { socket2::SockAddr::new(storage, msg.msg_namelen) }; get_addr_tuple(&addr, vm) } else { @@ -2034,7 +2034,7 @@ mod _socket { let available = ctrl_end as usize - data_ptr as usize; let data_len = data_len_from_cmsg.min(available); - let data = unsafe { std::slice::from_raw_parts(data_ptr, data_len) }; + let data = unsafe { core::slice::from_raw_parts(data_ptr, data_len) }; let tuple = vm.ctx.new_tuple(vec![ vm.ctx.new_int(cmsg_ref.cmsg_level).into(), @@ -2820,13 +2820,11 @@ mod _socket { let host = host_encoded.as_deref(); // Encode port using UTF-8 - let port: Option> = match opts.port.as_ref() { - Some(Either::A(s)) => { - Some(std::borrow::Cow::Borrowed(s.to_str().ok_or_else(|| { - vm.new_unicode_encode_error("surrogates not allowed".to_owned()) - })?)) - } - Some(Either::B(i)) => Some(std::borrow::Cow::Owned(i.to_string())), + let port: Option> = match opts.port.as_ref() { + Some(Either::A(s)) => Some(alloc::borrow::Cow::Borrowed(s.to_str().ok_or_else( + || vm.new_unicode_encode_error("surrogates not allowed".to_owned()), + )?)), + Some(Either::B(i)) => Some(alloc::borrow::Cow::Owned(i.to_string())), None => None, }; let port = port.as_ref().map(|p| p.as_ref()); diff --git a/crates/stdlib/src/sqlite.rs b/crates/stdlib/src/sqlite.rs index 3a82787cd8f..54c889ecb6b 100644 --- a/crates/stdlib/src/sqlite.rs +++ b/crates/stdlib/src/sqlite.rs @@ -3191,7 +3191,9 @@ mod _sqlite { } fn aggregate_context(self) -> *mut T { - unsafe { sqlite3_aggregate_context(self.ctx, std::mem::size_of::() as c_int).cast() } + unsafe { + sqlite3_aggregate_context(self.ctx, core::mem::size_of::() as c_int).cast() + } } fn result_exception(self, vm: &VirtualMachine, exc: PyBaseExceptionRef, msg: &str) { @@ -3297,7 +3299,7 @@ mod _sqlite { } else if nbytes < 0 { Err(vm.new_system_error("negative size with ptr")) } else { - Ok(unsafe { std::slice::from_raw_parts(p.cast(), nbytes as usize) }.to_vec()) + Ok(unsafe { core::slice::from_raw_parts(p.cast(), nbytes as usize) }.to_vec()) } } diff --git a/crates/vm/src/function/builtin.rs b/crates/vm/src/function/builtin.rs index 06fd6a44f54..444df64a8ef 100644 --- a/crates/vm/src/function/builtin.rs +++ b/crates/vm/src/function/builtin.rs @@ -218,7 +218,7 @@ into_py_native_fn_tuple!( #[cfg(test)] mod tests { use super::*; - use std::mem::size_of_val; + use core::mem::size_of_val; #[test] fn test_into_native_fn_noalloc() { diff --git a/crates/vm/src/stdlib/ctypes.rs b/crates/vm/src/stdlib/ctypes.rs index f3b6dd25aca..cbe3f5405b6 100644 --- a/crates/vm/src/stdlib/ctypes.rs +++ b/crates/vm/src/stdlib/ctypes.rs @@ -1180,7 +1180,7 @@ pub(crate) mod _ctypes { path: Option, vm: &VirtualMachine, ) -> PyResult { - use std::ffi::CString; + use alloc::ffi::CString; let path = match path { Some(p) if !vm.is_none(&p) => p, diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/ctypes/array.rs index 168da2bcc01..5c298d26a56 100644 --- a/crates/vm/src/stdlib/ctypes/array.rs +++ b/crates/vm/src/stdlib/ctypes/array.rs @@ -12,8 +12,8 @@ use crate::{ protocol::{BufferDescriptor, PyBuffer, PyNumberMethods, PySequenceMethods}, types::{AsBuffer, AsNumber, AsSequence, Constructor, Initializer}, }; +use alloc::borrow::Cow; use num_traits::{Signed, ToPrimitive}; -use std::borrow::Cow; /// Get itemsize from a PEP 3118 format string /// Extracts the type code (last char after endianness prefix) and returns its size @@ -890,7 +890,7 @@ impl PyCArray { // Python's from_buffer requires writable buffer, so this is safe. let ptr = slice.as_ptr() as *mut u8; let len = slice.len(); - let owned_slice = unsafe { std::slice::from_raw_parts_mut(ptr, len) }; + let owned_slice = unsafe { core::slice::from_raw_parts_mut(ptr, len) }; Self::write_element_to_buffer( owned_slice, final_offset, diff --git a/crates/vm/src/stdlib/ctypes/simple.rs b/crates/vm/src/stdlib/ctypes/simple.rs index 9835953812f..7bcfa203b02 100644 --- a/crates/vm/src/stdlib/ctypes/simple.rs +++ b/crates/vm/src/stdlib/ctypes/simple.rs @@ -1304,7 +1304,7 @@ impl PyCSimple { let ptr = slice.as_ptr() as *mut u8; let len = slice.len().min(buffer_bytes.len()); unsafe { - std::ptr::copy_nonoverlapping(buffer_bytes.as_ptr(), ptr, len); + core::ptr::copy_nonoverlapping(buffer_bytes.as_ptr(), ptr, len); } } Cow::Owned(vec) => { diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs index add8763f5e1..fa1495fcdbf 100644 --- a/crates/vm/src/stdlib/os.rs +++ b/crates/vm/src/stdlib/os.rs @@ -1747,16 +1747,16 @@ pub(super) mod _os { // We extract raw bytes and interpret as a native-endian integer. // Note: The value may differ across architectures due to endianness. let f_fsid = { - let ptr = std::ptr::addr_of!(st.f_fsid) as *const u8; - let size = std::mem::size_of_val(&st.f_fsid); + let ptr = core::ptr::addr_of!(st.f_fsid) as *const u8; + let size = core::mem::size_of_val(&st.f_fsid); if size >= 8 { - let bytes = unsafe { std::slice::from_raw_parts(ptr, 8) }; + let bytes = unsafe { core::slice::from_raw_parts(ptr, 8) }; u64::from_ne_bytes([ bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7], ]) as libc::c_ulong } else if size >= 4 { - let bytes = unsafe { std::slice::from_raw_parts(ptr, 4) }; + let bytes = unsafe { core::slice::from_raw_parts(ptr, 4) }; u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]) as libc::c_ulong } else { 0 @@ -1784,7 +1784,7 @@ pub(super) mod _os { #[pyfunction] #[pyfunction(name = "fstatvfs")] fn statvfs(path: OsPathOrFd<'_>, vm: &VirtualMachine) -> PyResult { - let mut st: libc::statvfs = unsafe { std::mem::zeroed() }; + let mut st: libc::statvfs = unsafe { core::mem::zeroed() }; let ret = match &path { OsPathOrFd::Path(p) => { let cpath = p.clone().into_cstring(vm)?; diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs index 4ec71eecbf2..65a659790b2 100644 --- a/crates/vm/src/stdlib/posix.rs +++ b/crates/vm/src/stdlib/posix.rs @@ -360,9 +360,9 @@ pub mod module { #[cfg(any(target_os = "macos", target_os = "ios"))] fn getgroups_impl() -> nix::Result> { + use core::ptr; use libc::{c_int, gid_t}; use nix::errno::Errno; - use std::ptr; let ret = unsafe { libc::getgroups(0, ptr::null_mut()) }; let mut groups = Vec::::with_capacity(Errno::result(ret)? as usize); let ret = unsafe { @@ -1825,7 +1825,7 @@ pub mod module { #[cfg(target_os = "macos")] #[pyfunction] fn _fcopyfile(in_fd: i32, out_fd: i32, flags: i32, vm: &VirtualMachine) -> PyResult<()> { - let ret = unsafe { fcopyfile(in_fd, out_fd, std::ptr::null_mut(), flags as u32) }; + let ret = unsafe { fcopyfile(in_fd, out_fd, core::ptr::null_mut(), flags as u32) }; if ret < 0 { Err(vm.new_last_errno_error()) } else { diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs index 6ab754be094..eb881911659 100644 --- a/crates/vm/src/stdlib/thread.rs +++ b/crates/vm/src/stdlib/thread.rs @@ -192,7 +192,7 @@ pub(crate) mod _thread { #[derive(PyPayload)] struct RLock { mu: RawRMutex, - count: std::sync::atomic::AtomicUsize, + count: core::sync::atomic::AtomicUsize, } impl fmt::Debug for RLock { @@ -207,7 +207,7 @@ pub(crate) mod _thread { fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult { Self { mu: RawRMutex::INIT, - count: std::sync::atomic::AtomicUsize::new(0), + count: core::sync::atomic::AtomicUsize::new(0), } .into_ref_with_type(vm, cls) .map(Into::into) @@ -220,7 +220,7 @@ pub(crate) mod _thread { let result = acquire_lock_impl!(&self.mu, args, vm)?; if result { self.count - .fetch_add(1, std::sync::atomic::Ordering::Relaxed); + .fetch_add(1, core::sync::atomic::Ordering::Relaxed); } Ok(result) } @@ -231,11 +231,11 @@ pub(crate) mod _thread { return Err(vm.new_runtime_error("release unlocked lock")); } debug_assert!( - self.count.load(std::sync::atomic::Ordering::Relaxed) > 0, + self.count.load(core::sync::atomic::Ordering::Relaxed) > 0, "RLock count underflow" ); self.count - .fetch_sub(1, std::sync::atomic::Ordering::Relaxed); + .fetch_sub(1, core::sync::atomic::Ordering::Relaxed); unsafe { self.mu.unlock() }; Ok(()) } @@ -247,7 +247,7 @@ pub(crate) mod _thread { self.mu.unlock(); }; } - self.count.store(0, std::sync::atomic::Ordering::Relaxed); + self.count.store(0, core::sync::atomic::Ordering::Relaxed); let new_mut = RawRMutex::INIT; let old_mutex: AtomicCell<&RawRMutex> = AtomicCell::new(&self.mu); @@ -264,7 +264,7 @@ pub(crate) mod _thread { #[pymethod] fn _recursion_count(&self) -> usize { if self.mu.is_owned_by_current_thread() { - self.count.load(std::sync::atomic::Ordering::Relaxed) + self.count.load(core::sync::atomic::Ordering::Relaxed) } else { 0 } diff --git a/crates/wasm/src/browser_module.rs b/crates/wasm/src/browser_module.rs index 0b978a4b563..9b6219cab6f 100644 --- a/crates/wasm/src/browser_module.rs +++ b/crates/wasm/src/browser_module.rs @@ -117,7 +117,8 @@ mod _browser { #[pyfunction] fn request_animation_frame(func: ArgCallable, vm: &VirtualMachine) -> PyResult { - use std::{cell::RefCell, rc::Rc}; + use alloc::rc::Rc; + use core::cell::RefCell; // this basic setup for request_animation_frame taken from: // https://rustwasm.github.io/wasm-bindgen/examples/request-animation-frame.html diff --git a/crates/wasm/src/js_module.rs b/crates/wasm/src/js_module.rs index d4f623da9f4..11d23bdf6d8 100644 --- a/crates/wasm/src/js_module.rs +++ b/crates/wasm/src/js_module.rs @@ -8,6 +8,7 @@ mod _js { vm_class::{WASMVirtualMachine, stored_vm_from_wasm}, weak_vm, }; + use core::{cell, fmt, future}; use js_sys::{Array, Object, Promise, Reflect}; use rustpython_vm::{ Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine, @@ -17,7 +18,6 @@ mod _js { protocol::PyIterReturn, types::{IterNext, Representable, SelfIter}, }; - use std::{cell, fmt, future}; use wasm_bindgen::{JsCast, closure::Closure, prelude::*}; use wasm_bindgen_futures::{JsFuture, future_to_promise}; diff --git a/crates/wasm/src/lib.rs b/crates/wasm/src/lib.rs index 8d1d19ddae1..64595fd63ab 100644 --- a/crates/wasm/src/lib.rs +++ b/crates/wasm/src/lib.rs @@ -1,3 +1,5 @@ +extern crate alloc; + pub mod browser_module; pub mod convert; pub mod js_module; diff --git a/crates/wasm/src/vm_class.rs b/crates/wasm/src/vm_class.rs index ad5df8dab96..0339a47821e 100644 --- a/crates/wasm/src/vm_class.rs +++ b/crates/wasm/src/vm_class.rs @@ -3,6 +3,8 @@ use crate::{ convert::{self, PyResultExt}, js_module, wasm_builtins, }; +use alloc::rc::{Rc, Weak}; +use core::cell::RefCell; use js_sys::{Object, TypeError}; use rustpython_vm::{ Interpreter, PyObjectRef, PyPayload, PyRef, PyResult, Settings, VirtualMachine, @@ -10,11 +12,7 @@ use rustpython_vm::{ compiler::Mode, scope::Scope, }; -use std::{ - cell::RefCell, - collections::HashMap, - rc::{Rc, Weak}, -}; +use std::collections::HashMap; use wasm_bindgen::prelude::*; pub(crate) struct StoredVirtualMachine {