From e175367abe03e7cfb201f1095a44f4bc289af8d9 Mon Sep 17 00:00:00 2001 From: "Jeong, YunWon" Date: Wed, 11 Feb 2026 12:46:25 +0900 Subject: [PATCH 1/2] Replace `std::sync::LazyLock` with `common::lock::LazyLock` lock.rs now exports both `LazyCell` and `LazyLock`: - threading: re-exports from std::sync / core::cell - non-threading: `LazyCell` from core::cell, `LazyLock` as LazyCell wrapper with Sync (safe without threading) --- crates/common/src/lock.rs | 21 +++++++++++++++++++-- crates/stdlib/src/contextvars.rs | 2 +- crates/stdlib/src/csv.rs | 2 +- crates/stdlib/src/mmap.rs | 2 +- crates/stdlib/src/openssl.rs | 9 ++++----- crates/stdlib/src/ssl/oid.rs | 2 +- crates/vm/src/builtins/bytes.rs | 2 +- crates/vm/src/builtins/dict.rs | 2 +- crates/vm/src/builtins/genericalias.rs | 2 +- crates/vm/src/builtins/mappingproxy.rs | 2 +- crates/vm/src/builtins/memory.rs | 2 +- crates/vm/src/builtins/range.rs | 2 +- crates/vm/src/builtins/set.rs | 2 +- crates/vm/src/builtins/str.rs | 2 +- crates/vm/src/builtins/template.rs | 2 +- crates/vm/src/builtins/tuple.rs | 2 +- crates/vm/src/builtins/union.rs | 2 +- crates/vm/src/builtins/weakproxy.rs | 2 +- crates/vm/src/stdlib/ctypes/array.rs | 4 ++-- crates/vm/src/stdlib/ctypes/pointer.rs | 2 +- crates/vm/src/stdlib/sre.rs | 4 ++-- crates/vm/src/stdlib/typing.rs | 2 +- crates/vm/src/types/structseq.rs | 2 +- 23 files changed, 46 insertions(+), 30 deletions(-) diff --git a/crates/common/src/lock.rs b/crates/common/src/lock.rs index f8e7da3e0e3..f230011c028 100644 --- a/crates/common/src/lock.rs +++ b/crates/common/src/lock.rs @@ -10,12 +10,29 @@ cfg_if::cfg_if! { if #[cfg(feature = "threading")] { pub use parking_lot::{RawMutex, RawRwLock, RawThreadId}; - pub use std::sync::{LazyLock as Lazy, OnceLock as OnceCell}; + pub use std::sync::{LazyLock, OnceLock as OnceCell}; + pub use core::cell::LazyCell; } else { mod cell_lock; pub use cell_lock::{RawCellMutex as RawMutex, RawCellRwLock as RawRwLock, SingleThreadId as RawThreadId}; - pub use core::cell::{LazyCell as Lazy, OnceCell}; + pub use core::cell::{LazyCell, OnceCell}; + + /// `core::cell::LazyCell` with `Sync` for use in `static` items. + /// SAFETY: Without threading, there can be no concurrent access. + pub struct LazyLock T>(core::cell::LazyCell); + // SAFETY: Without threading, there can be no concurrent access. + unsafe impl Sync for LazyLock {} + + impl T> LazyLock { + pub const fn new(f: F) -> Self { Self(core::cell::LazyCell::new(f)) } + pub fn force(this: &Self) -> &T { core::cell::LazyCell::force(&this.0) } + } + + impl T> core::ops::Deref for LazyLock { + type Target = T; + fn deref(&self) -> &T { &self.0 } + } } } diff --git a/crates/stdlib/src/contextvars.rs b/crates/stdlib/src/contextvars.rs index 700a94692d5..883ef6f6820 100644 --- a/crates/stdlib/src/contextvars.rs +++ b/crates/stdlib/src/contextvars.rs @@ -26,7 +26,7 @@ mod _contextvars { }; use crossbeam_utils::atomic::AtomicCell; use indexmap::IndexMap; - use std::sync::LazyLock; + use rustpython_common::lock::LazyLock; // TODO: Real hamt implementation type Hamt = IndexMap, PyObjectRef, ahash::RandomState>; diff --git a/crates/stdlib/src/csv.rs b/crates/stdlib/src/csv.rs index 7c89ebbba66..481f042b7df 100644 --- a/crates/stdlib/src/csv.rs +++ b/crates/stdlib/src/csv.rs @@ -18,7 +18,7 @@ mod _csv { use parking_lot::Mutex; use rustpython_vm::match_class; use std::collections::HashMap; - use std::sync::LazyLock; + use rustpython_common::lock::LazyLock; #[pyattr] const QUOTE_MINIMAL: i32 = QuoteStyle::Minimal as i32; diff --git a/crates/stdlib/src/mmap.rs b/crates/stdlib/src/mmap.rs index c70b8dfec6e..6ab898db6b8 100644 --- a/crates/stdlib/src/mmap.rs +++ b/crates/stdlib/src/mmap.rs @@ -687,7 +687,7 @@ mod mmap { impl AsSequence for PyMmap { fn as_sequence() -> &'static PySequenceMethods { - use std::sync::LazyLock; + use rustpython_common::lock::LazyLock; static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, _vm| Ok(PyMmap::sequence_downcast(seq).__len__())), item: atomic_func!(|seq, i, vm| { diff --git a/crates/stdlib/src/openssl.rs b/crates/stdlib/src/openssl.rs index 7193ed31d73..44d690f9190 100644 --- a/crates/stdlib/src/openssl.rs +++ b/crates/stdlib/src/openssl.rs @@ -26,7 +26,7 @@ cfg_if::cfg_if! { pub(crate) use _ssl::module_def; use openssl_probe::ProbeResult; -use std::sync::LazyLock; +use rustpython_common::lock::LazyLock; // define our own copy of ProbeResult so we can handle the vendor case // easily, without having to have a bunch of cfgs @@ -95,7 +95,6 @@ mod _ssl { fmt, io::{Read, Write}, path::{Path, PathBuf}, - sync::LazyLock, time::Instant, }; @@ -106,7 +105,7 @@ mod _ssl { // if openssl is vendored, it doesn't know the locations // of system certificates - cache the probe result now. #[cfg(openssl_vendored)] - std::sync::LazyLock::force(&super::PROBE); + rustpython_common::lock::LazyLock::force(&super::PROBE); __module_exec(vm, module); Ok(()) @@ -569,7 +568,7 @@ mod _ssl { // Get or create an ex_data index for SNI callback data fn get_sni_ex_data_index() -> libc::c_int { - use std::sync::LazyLock; + use rustpython_common::lock::LazyLock; static SNI_EX_DATA_IDX: LazyLock = LazyLock::new(|| unsafe { sys::SSL_get_ex_new_index( 0, @@ -613,7 +612,7 @@ mod _ssl { // Get or create an ex_data index for msg_callback data fn get_msg_callback_ex_data_index() -> libc::c_int { - use std::sync::LazyLock; + use rustpython_common::lock::LazyLock; static MSG_CB_EX_DATA_IDX: LazyLock = LazyLock::new(|| unsafe { sys::SSL_get_ex_new_index( 0, diff --git a/crates/stdlib/src/ssl/oid.rs b/crates/stdlib/src/ssl/oid.rs index 2e13733a2a2..e8abe97dc3d 100644 --- a/crates/stdlib/src/ssl/oid.rs +++ b/crates/stdlib/src/ssl/oid.rs @@ -132,7 +132,7 @@ impl OidTable { } /// Global OID table -static OID_TABLE: std::sync::LazyLock = std::sync::LazyLock::new(OidTable::build); +static OID_TABLE: rustpython_common::lock::LazyLock = rustpython_common::lock::LazyLock::new(OidTable::build); /// Macro to define OID entry using oid-registry constant macro_rules! oid_static { diff --git a/crates/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs index 1abe8a30204..39e9d868019 100644 --- a/crates/vm/src/builtins/bytes.rs +++ b/crates/vm/src/builtins/bytes.rs @@ -30,7 +30,7 @@ use crate::{ }; use bstr::ByteSlice; use core::{mem::size_of, ops::Deref}; -use std::sync::LazyLock; +use crate::common::lock::LazyLock; #[pyclass(module = false, name = "bytes")] #[derive(Clone, Debug)] diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs index b70c5e6e461..0b9a707f28b 100644 --- a/crates/vm/src/builtins/dict.rs +++ b/crates/vm/src/builtins/dict.rs @@ -26,7 +26,7 @@ use crate::{ }; use alloc::fmt; use rustpython_common::lock::PyMutex; -use std::sync::LazyLock; +use crate::common::lock::LazyLock; pub type DictContentType = dict_inner::Dict; diff --git a/crates/vm/src/builtins/genericalias.rs b/crates/vm/src/builtins/genericalias.rs index b30d8586331..f3759cb20bc 100644 --- a/crates/vm/src/builtins/genericalias.rs +++ b/crates/vm/src/builtins/genericalias.rs @@ -1,5 +1,5 @@ // spell-checker:ignore iparam gaiterobject -use std::sync::LazyLock; +use crate::common::lock::LazyLock; use super::type_; use crate::{ diff --git a/crates/vm/src/builtins/mappingproxy.rs b/crates/vm/src/builtins/mappingproxy.rs index 1036dcfdaf9..7d9feb9ff2d 100644 --- a/crates/vm/src/builtins/mappingproxy.rs +++ b/crates/vm/src/builtins/mappingproxy.rs @@ -13,7 +13,7 @@ use crate::{ PyComparisonOp, Representable, }, }; -use std::sync::LazyLock; +use crate::common::lock::LazyLock; #[pyclass(module = false, name = "mappingproxy", traverse)] #[derive(Debug)] diff --git a/crates/vm/src/builtins/memory.rs b/crates/vm/src/builtins/memory.rs index db815fcba63..38c14509142 100644 --- a/crates/vm/src/builtins/memory.rs +++ b/crates/vm/src/builtins/memory.rs @@ -30,7 +30,7 @@ use core::{cmp::Ordering, fmt::Debug, mem::ManuallyDrop, ops::Range}; use crossbeam_utils::atomic::AtomicCell; use itertools::Itertools; use rustpython_common::lock::PyMutex; -use std::sync::LazyLock; +use crate::common::lock::LazyLock; #[derive(FromArgs)] pub struct PyMemoryViewNewArgs { diff --git a/crates/vm/src/builtins/range.rs b/crates/vm/src/builtins/range.rs index c0cd070c250..9d8ac5e2497 100644 --- a/crates/vm/src/builtins/range.rs +++ b/crates/vm/src/builtins/range.rs @@ -19,7 +19,7 @@ use crossbeam_utils::atomic::AtomicCell; use malachite_bigint::{BigInt, Sign}; use num_integer::Integer; use num_traits::{One, Signed, ToPrimitive, Zero}; -use std::sync::LazyLock; +use crate::common::lock::LazyLock; // Search flag passed to iter_search enum SearchType { diff --git a/crates/vm/src/builtins/set.rs b/crates/vm/src/builtins/set.rs index 0504eba0ee0..625b6aa34fd 100644 --- a/crates/vm/src/builtins/set.rs +++ b/crates/vm/src/builtins/set.rs @@ -30,7 +30,7 @@ use rustpython_common::{ atomic::{Ordering, PyAtomic, Radium}, hash, }; -use std::sync::LazyLock; +use crate::common::lock::LazyLock; pub type SetContentType = dict_inner::Dict<()>; diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs index 754732fab04..bc761586ee3 100644 --- a/crates/vm/src/builtins/str.rs +++ b/crates/vm/src/builtins/str.rs @@ -42,7 +42,7 @@ use rustpython_common::{ str::DeduceStrKind, wtf8::{CodePoint, Wtf8, Wtf8Buf, Wtf8Chunk}, }; -use std::sync::LazyLock; +use crate::common::lock::LazyLock; use unic_ucd_bidi::BidiClass; use unic_ucd_category::GeneralCategory; use unic_ucd_ident::{is_xid_continue, is_xid_start}; diff --git a/crates/vm/src/builtins/template.rs b/crates/vm/src/builtins/template.rs index f1969fc20eb..777df61eae2 100644 --- a/crates/vm/src/builtins/template.rs +++ b/crates/vm/src/builtins/template.rs @@ -10,7 +10,7 @@ use crate::{ SelfIter, }, }; -use std::sync::LazyLock; +use crate::common::lock::LazyLock; use super::interpolation::PyInterpolation; diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs index 36860337425..2ddccbb43fd 100644 --- a/crates/vm/src/builtins/tuple.rs +++ b/crates/vm/src/builtins/tuple.rs @@ -25,7 +25,7 @@ use crate::{ vm::VirtualMachine, }; use alloc::fmt; -use std::sync::LazyLock; +use crate::common::lock::LazyLock; #[pyclass(module = false, name = "tuple", traverse = "manual")] pub struct PyTuple { diff --git a/crates/vm/src/builtins/union.rs b/crates/vm/src/builtins/union.rs index 907383639bd..2b186a95e9f 100644 --- a/crates/vm/src/builtins/union.rs +++ b/crates/vm/src/builtins/union.rs @@ -12,7 +12,7 @@ use crate::{ types::{AsMapping, AsNumber, Comparable, GetAttr, Hashable, PyComparisonOp, Representable}, }; use alloc::fmt; -use std::sync::LazyLock; +use crate::common::lock::LazyLock; const CLS_ATTRS: &[&str] = &["__module__"]; diff --git a/crates/vm/src/builtins/weakproxy.rs b/crates/vm/src/builtins/weakproxy.rs index 0f68e9e9815..43409deff38 100644 --- a/crates/vm/src/builtins/weakproxy.rs +++ b/crates/vm/src/builtins/weakproxy.rs @@ -11,7 +11,7 @@ use crate::{ Iterable, PyComparisonOp, Representable, SetAttr, }, }; -use std::sync::LazyLock; +use crate::common::lock::LazyLock; #[pyclass(module = false, name = "weakproxy", unhashable = true, traverse)] #[derive(Debug)] diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/ctypes/array.rs index 9032bf01f0b..ecb9c0eccf1 100644 --- a/crates/vm/src/stdlib/ctypes/array.rs +++ b/crates/vm/src/stdlib/ctypes/array.rs @@ -445,7 +445,7 @@ impl Initializer for PyCArray { impl AsSequence for PyCArray { fn as_sequence() -> &'static PySequenceMethods { - use std::sync::LazyLock; + use crate::common::lock::LazyLock; static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, _vm| { let zelf = PyCArray::sequence_downcast(seq); @@ -470,7 +470,7 @@ impl AsSequence for PyCArray { impl AsMapping for PyCArray { fn as_mapping() -> &'static PyMappingMethods { - use std::sync::LazyLock; + use crate::common::lock::LazyLock; static AS_MAPPING: LazyLock = LazyLock::new(|| PyMappingMethods { length: atomic_func!(|mapping, _vm| { let zelf = PyCArray::mapping_downcast(mapping); diff --git a/crates/vm/src/stdlib/ctypes/pointer.rs b/crates/vm/src/stdlib/ctypes/pointer.rs index 794650c6098..087a7bfd32d 100644 --- a/crates/vm/src/stdlib/ctypes/pointer.rs +++ b/crates/vm/src/stdlib/ctypes/pointer.rs @@ -790,7 +790,7 @@ impl AsNumber for PyCPointer { impl AsMapping for PyCPointer { fn as_mapping() -> &'static PyMappingMethods { - use std::sync::LazyLock; + use crate::common::lock::LazyLock; static AS_MAPPING: LazyLock = LazyLock::new(|| PyMappingMethods { subscript: atomic_func!(|mapping, needle, vm| { let zelf = PyCPointer::mapping_downcast(mapping); diff --git a/crates/vm/src/stdlib/sre.rs b/crates/vm/src/stdlib/sre.rs index 692b9754214..367cf245102 100644 --- a/crates/vm/src/stdlib/sre.rs +++ b/crates/vm/src/stdlib/sre.rs @@ -836,8 +836,8 @@ mod _sre { impl AsMapping for Match { fn as_mapping() -> &'static PyMappingMethods { - static AS_MAPPING: std::sync::LazyLock = - std::sync::LazyLock::new(|| PyMappingMethods { + static AS_MAPPING: crate::common::lock::LazyLock = + crate::common::lock::LazyLock::new(|| PyMappingMethods { subscript: atomic_func!(|mapping, needle, vm| { Match::mapping_downcast(mapping) .__getitem__(needle.to_owned(), vm) diff --git a/crates/vm/src/stdlib/typing.rs b/crates/vm/src/stdlib/typing.rs index 59884d1ec9c..742386dab31 100644 --- a/crates/vm/src/stdlib/typing.rs +++ b/crates/vm/src/stdlib/typing.rs @@ -35,7 +35,7 @@ pub(crate) mod decl { protocol::{PyMappingMethods, PyNumberMethods}, types::{AsMapping, AsNumber, Constructor, Iterable, Representable}, }; - use std::sync::LazyLock; + use crate::common::lock::LazyLock; #[pyfunction] pub(crate) fn _idfunc(args: FuncArgs, _vm: &VirtualMachine) -> PyObjectRef { diff --git a/crates/vm/src/types/structseq.rs b/crates/vm/src/types/structseq.rs index adf5f5658b2..6a4c5c3c87e 100644 --- a/crates/vm/src/types/structseq.rs +++ b/crates/vm/src/types/structseq.rs @@ -9,7 +9,7 @@ use crate::{ types::PyComparisonOp, vm::Context, }; -use std::sync::LazyLock; +use crate::common::lock::LazyLock; const DEFAULT_STRUCTSEQ_REDUCE: PyMethodDef = PyMethodDef::new_const( "__reduce__", From 35c66f411e4be9b61fbe5c237f52070f33b2573e Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 11 Feb 2026 04:25:48 +0000 Subject: [PATCH 2/2] Auto-format: cargo fmt --all --- crates/stdlib/src/csv.rs | 2 +- crates/stdlib/src/ssl/oid.rs | 3 ++- crates/vm/src/builtins/bytes.rs | 2 +- crates/vm/src/builtins/dict.rs | 2 +- crates/vm/src/builtins/mappingproxy.rs | 2 +- crates/vm/src/builtins/memory.rs | 2 +- crates/vm/src/builtins/range.rs | 2 +- crates/vm/src/builtins/set.rs | 2 +- crates/vm/src/builtins/str.rs | 2 +- crates/vm/src/builtins/template.rs | 2 +- crates/vm/src/builtins/tuple.rs | 2 +- crates/vm/src/builtins/union.rs | 2 +- crates/vm/src/builtins/weakproxy.rs | 2 +- crates/vm/src/stdlib/typing.rs | 2 +- crates/vm/src/types/structseq.rs | 2 +- 15 files changed, 16 insertions(+), 15 deletions(-) diff --git a/crates/stdlib/src/csv.rs b/crates/stdlib/src/csv.rs index 481f042b7df..0eecd07c936 100644 --- a/crates/stdlib/src/csv.rs +++ b/crates/stdlib/src/csv.rs @@ -16,9 +16,9 @@ mod _csv { use csv_core::Terminator; use itertools::{self, Itertools}; use parking_lot::Mutex; + use rustpython_common::lock::LazyLock; use rustpython_vm::match_class; use std::collections::HashMap; - use rustpython_common::lock::LazyLock; #[pyattr] const QUOTE_MINIMAL: i32 = QuoteStyle::Minimal as i32; diff --git a/crates/stdlib/src/ssl/oid.rs b/crates/stdlib/src/ssl/oid.rs index e8abe97dc3d..d85898c0f79 100644 --- a/crates/stdlib/src/ssl/oid.rs +++ b/crates/stdlib/src/ssl/oid.rs @@ -132,7 +132,8 @@ impl OidTable { } /// Global OID table -static OID_TABLE: rustpython_common::lock::LazyLock = rustpython_common::lock::LazyLock::new(OidTable::build); +static OID_TABLE: rustpython_common::lock::LazyLock = + rustpython_common::lock::LazyLock::new(OidTable::build); /// Macro to define OID entry using oid-registry constant macro_rules! oid_static { diff --git a/crates/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs index 39e9d868019..623885ec0fe 100644 --- a/crates/vm/src/builtins/bytes.rs +++ b/crates/vm/src/builtins/bytes.rs @@ -2,6 +2,7 @@ use super::{ PositionIterInternal, PyDictRef, PyGenericAlias, PyIntRef, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef, iter::builtins_iter, }; +use crate::common::lock::LazyLock; use crate::{ AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromBorrowedObject, TryFromObject, VirtualMachine, @@ -30,7 +31,6 @@ use crate::{ }; use bstr::ByteSlice; use core::{mem::size_of, ops::Deref}; -use crate::common::lock::LazyLock; #[pyclass(module = false, name = "bytes")] #[derive(Clone, Debug)] diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs index 0b9a707f28b..1d79a5a5906 100644 --- a/crates/vm/src/builtins/dict.rs +++ b/crates/vm/src/builtins/dict.rs @@ -2,6 +2,7 @@ use super::{ IterStatus, PositionIterInternal, PyBaseExceptionRef, PyGenericAlias, PyMappingProxy, PySet, PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef, set::PySetInner, }; +use crate::common::lock::LazyLock; use crate::object::{Traverse, TraverseFn}; use crate::{ AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult, @@ -26,7 +27,6 @@ use crate::{ }; use alloc::fmt; use rustpython_common::lock::PyMutex; -use crate::common::lock::LazyLock; pub type DictContentType = dict_inner::Dict; diff --git a/crates/vm/src/builtins/mappingproxy.rs b/crates/vm/src/builtins/mappingproxy.rs index 7d9feb9ff2d..11525c3f80a 100644 --- a/crates/vm/src/builtins/mappingproxy.rs +++ b/crates/vm/src/builtins/mappingproxy.rs @@ -1,4 +1,5 @@ use super::{PyDict, PyDictRef, PyGenericAlias, PyList, PyTuple, PyType, PyTypeRef}; +use crate::common::lock::LazyLock; use crate::{ AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func, @@ -13,7 +14,6 @@ use crate::{ PyComparisonOp, Representable, }, }; -use crate::common::lock::LazyLock; #[pyclass(module = false, name = "mappingproxy", traverse)] #[derive(Debug)] diff --git a/crates/vm/src/builtins/memory.rs b/crates/vm/src/builtins/memory.rs index 38c14509142..31afce48a6d 100644 --- a/crates/vm/src/builtins/memory.rs +++ b/crates/vm/src/builtins/memory.rs @@ -2,6 +2,7 @@ use super::{ PositionIterInternal, PyBytes, PyBytesRef, PyGenericAlias, PyInt, PyListRef, PySlice, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef, iter::builtins_iter, }; +use crate::common::lock::LazyLock; use crate::{ AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromBorrowedObject, TryFromObject, VirtualMachine, atomic_func, @@ -30,7 +31,6 @@ use core::{cmp::Ordering, fmt::Debug, mem::ManuallyDrop, ops::Range}; use crossbeam_utils::atomic::AtomicCell; use itertools::Itertools; use rustpython_common::lock::PyMutex; -use crate::common::lock::LazyLock; #[derive(FromArgs)] pub struct PyMemoryViewNewArgs { diff --git a/crates/vm/src/builtins/range.rs b/crates/vm/src/builtins/range.rs index 9d8ac5e2497..92de2463e2c 100644 --- a/crates/vm/src/builtins/range.rs +++ b/crates/vm/src/builtins/range.rs @@ -2,6 +2,7 @@ use super::{ PyGenericAlias, PyInt, PyIntRef, PySlice, PyTupleRef, PyType, PyTypeRef, builtins_iter, tuple::tuple_hash, }; +use crate::common::lock::LazyLock; use crate::{ AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine, atomic_func, @@ -19,7 +20,6 @@ use crossbeam_utils::atomic::AtomicCell; use malachite_bigint::{BigInt, Sign}; use num_integer::Integer; use num_traits::{One, Signed, ToPrimitive, Zero}; -use crate::common::lock::LazyLock; // Search flag passed to iter_search enum SearchType { diff --git a/crates/vm/src/builtins/set.rs b/crates/vm/src/builtins/set.rs index 625b6aa34fd..17f406bbcbe 100644 --- a/crates/vm/src/builtins/set.rs +++ b/crates/vm/src/builtins/set.rs @@ -5,6 +5,7 @@ use super::{ IterStatus, PositionIterInternal, PyDict, PyDictRef, PyGenericAlias, PyTupleRef, PyType, PyTypeRef, builtins_iter, }; +use crate::common::lock::LazyLock; use crate::{ AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, atomic_func, @@ -30,7 +31,6 @@ use rustpython_common::{ atomic::{Ordering, PyAtomic, Radium}, hash, }; -use crate::common::lock::LazyLock; pub type SetContentType = dict_inner::Dict<()>; diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs index bc761586ee3..a1f0de1810f 100644 --- a/crates/vm/src/builtins/str.rs +++ b/crates/vm/src/builtins/str.rs @@ -6,6 +6,7 @@ use super::{ builtins_iter, }, }; +use crate::common::lock::LazyLock; use crate::{ AsObject, Context, Py, PyExact, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult, TryFromBorrowedObject, VirtualMachine, @@ -42,7 +43,6 @@ use rustpython_common::{ str::DeduceStrKind, wtf8::{CodePoint, Wtf8, Wtf8Buf, Wtf8Chunk}, }; -use crate::common::lock::LazyLock; use unic_ucd_bidi::BidiClass; use unic_ucd_category::GeneralCategory; use unic_ucd_ident::{is_xid_continue, is_xid_start}; diff --git a/crates/vm/src/builtins/template.rs b/crates/vm/src/builtins/template.rs index 777df61eae2..891de8c6c2f 100644 --- a/crates/vm/src/builtins/template.rs +++ b/crates/vm/src/builtins/template.rs @@ -1,4 +1,5 @@ use super::{PyStr, PyTupleRef, PyType}; +use crate::common::lock::LazyLock; use crate::{ AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func, @@ -10,7 +11,6 @@ use crate::{ SelfIter, }, }; -use crate::common::lock::LazyLock; use super::interpolation::PyInterpolation; diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs index 2ddccbb43fd..67c51127cb4 100644 --- a/crates/vm/src/builtins/tuple.rs +++ b/crates/vm/src/builtins/tuple.rs @@ -1,6 +1,7 @@ use super::{ PositionIterInternal, PyGenericAlias, PyStrRef, PyType, PyTypeRef, iter::builtins_iter, }; +use crate::common::lock::LazyLock; use crate::common::{ hash::{PyHash, PyUHash}, lock::PyMutex, @@ -25,7 +26,6 @@ use crate::{ vm::VirtualMachine, }; use alloc::fmt; -use crate::common::lock::LazyLock; #[pyclass(module = false, name = "tuple", traverse = "manual")] pub struct PyTuple { diff --git a/crates/vm/src/builtins/union.rs b/crates/vm/src/builtins/union.rs index 2b186a95e9f..03939422c0c 100644 --- a/crates/vm/src/builtins/union.rs +++ b/crates/vm/src/builtins/union.rs @@ -1,4 +1,5 @@ use super::{genericalias, type_}; +use crate::common::lock::LazyLock; use crate::{ AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func, @@ -12,7 +13,6 @@ use crate::{ types::{AsMapping, AsNumber, Comparable, GetAttr, Hashable, PyComparisonOp, Representable}, }; use alloc::fmt; -use crate::common::lock::LazyLock; const CLS_ATTRS: &[&str] = &["__module__"]; diff --git a/crates/vm/src/builtins/weakproxy.rs b/crates/vm/src/builtins/weakproxy.rs index 43409deff38..437e0dc886e 100644 --- a/crates/vm/src/builtins/weakproxy.rs +++ b/crates/vm/src/builtins/weakproxy.rs @@ -1,4 +1,5 @@ use super::{PyStr, PyStrRef, PyType, PyTypeRef, PyWeak}; +use crate::common::lock::LazyLock; use crate::{ Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func, class::PyClassImpl, @@ -11,7 +12,6 @@ use crate::{ Iterable, PyComparisonOp, Representable, SetAttr, }, }; -use crate::common::lock::LazyLock; #[pyclass(module = false, name = "weakproxy", unhashable = true, traverse)] #[derive(Debug)] diff --git a/crates/vm/src/stdlib/typing.rs b/crates/vm/src/stdlib/typing.rs index 742386dab31..640353ce50c 100644 --- a/crates/vm/src/stdlib/typing.rs +++ b/crates/vm/src/stdlib/typing.rs @@ -28,6 +28,7 @@ pub fn call_typing_func_object<'a>( #[pymodule(name = "_typing", with(super::typevar::typevar))] pub(crate) mod decl { + use crate::common::lock::LazyLock; use crate::{ AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func, builtins::{PyGenericAlias, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef, type_}, @@ -35,7 +36,6 @@ pub(crate) mod decl { protocol::{PyMappingMethods, PyNumberMethods}, types::{AsMapping, AsNumber, Constructor, Iterable, Representable}, }; - use crate::common::lock::LazyLock; #[pyfunction] pub(crate) fn _idfunc(args: FuncArgs, _vm: &VirtualMachine) -> PyObjectRef { diff --git a/crates/vm/src/types/structseq.rs b/crates/vm/src/types/structseq.rs index 6a4c5c3c87e..af35f92f656 100644 --- a/crates/vm/src/types/structseq.rs +++ b/crates/vm/src/types/structseq.rs @@ -1,3 +1,4 @@ +use crate::common::lock::LazyLock; use crate::{ AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func, builtins::{PyBaseExceptionRef, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef}, @@ -9,7 +10,6 @@ use crate::{ types::PyComparisonOp, vm::Context, }; -use crate::common::lock::LazyLock; const DEFAULT_STRUCTSEQ_REDUCE: PyMethodDef = PyMethodDef::new_const( "__reduce__",