From ec09599d84f23ab6e616a3986afcab4c8ff66b9e Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Wed, 26 Mar 2025 17:44:03 +0900 Subject: [PATCH 1/2] Remoce once_cell::Lazy usage --- Cargo.lock | 2 -- derive-impl/Cargo.toml | 1 - derive-impl/src/compile_bytecode.rs | 4 ++-- stdlib/Cargo.toml | 1 - stdlib/src/contextvars.rs | 4 ++-- stdlib/src/csv.rs | 6 +++--- stdlib/src/mmap.rs | 4 ++-- stdlib/src/sqlite.rs | 8 ++++---- vm/src/builtins/bytes.rs | 6 +++--- vm/src/builtins/dict.rs | 10 +++++----- vm/src/builtins/genericalias.rs | 4 ++-- vm/src/builtins/mappingproxy.rs | 6 +++--- vm/src/builtins/memory.rs | 4 ++-- vm/src/builtins/range.rs | 6 +++--- vm/src/builtins/set.rs | 6 +++--- vm/src/builtins/str.rs | 6 +++--- vm/src/builtins/tuple.rs | 7 +++---- vm/src/builtins/union.rs | 4 ++-- vm/src/builtins/weakproxy.rs | 4 ++-- vm/src/stdlib/sre.rs | 4 ++-- 20 files changed, 46 insertions(+), 51 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1fa60eac29..ab202d0b08 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2412,7 +2412,6 @@ version = "0.4.0" dependencies = [ "itertools 0.14.0", "maplit", - "once_cell", "proc-macro2", "quote", "rustpython-compiler-core", @@ -2515,7 +2514,6 @@ dependencies = [ "num-integer", "num-traits", "num_enum", - "once_cell", "openssl", "openssl-probe", "openssl-sys", diff --git a/derive-impl/Cargo.toml b/derive-impl/Cargo.toml index ca415dc543..eec7952df5 100644 --- a/derive-impl/Cargo.toml +++ b/derive-impl/Cargo.toml @@ -14,7 +14,6 @@ rustpython-compiler-core = { workspace = true } rustpython-doc = { workspace = true } itertools = { workspace = true } -once_cell = { workspace = true } syn = { workspace = true, features = ["full", "extra-traits"] } maplit = "1.0.2" diff --git a/derive-impl/src/compile_bytecode.rs b/derive-impl/src/compile_bytecode.rs index 2c702b35fe..fc349a7ed4 100644 --- a/derive-impl/src/compile_bytecode.rs +++ b/derive-impl/src/compile_bytecode.rs @@ -14,10 +14,10 @@ //! ``` use crate::Diagnostic; -use once_cell::sync::Lazy; use proc_macro2::{Span, TokenStream}; use quote::quote; use rustpython_compiler_core::{Mode, bytecode::CodeObject, frozen}; +use std::sync::LazyLock; use std::{ collections::HashMap, env, fs, @@ -29,7 +29,7 @@ use syn::{ spanned::Spanned, }; -static CARGO_MANIFEST_DIR: Lazy = Lazy::new(|| { +static CARGO_MANIFEST_DIR: LazyLock = LazyLock::new(|| { PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR is not present")) }); diff --git a/stdlib/Cargo.toml b/stdlib/Cargo.toml index b46fb16b8f..14fd0d39ec 100644 --- a/stdlib/Cargo.toml +++ b/stdlib/Cargo.toml @@ -40,7 +40,6 @@ malachite-bigint = { workspace = true } num-integer = { workspace = true } num-traits = { workspace = true } num_enum = { workspace = true } -once_cell = { workspace = true } parking_lot = { workspace = true } thread_local = { workspace = true } diff --git a/stdlib/src/contextvars.rs b/stdlib/src/contextvars.rs index bcc372ed55..4fd45842b9 100644 --- a/stdlib/src/contextvars.rs +++ b/stdlib/src/contextvars.rs @@ -33,7 +33,7 @@ mod _contextvars { }; use crossbeam_utils::atomic::AtomicCell; use indexmap::IndexMap; - use once_cell::sync::Lazy; + use std::sync::LazyLock; use std::{ cell::{Cell, RefCell, UnsafeCell}, sync::atomic::Ordering, @@ -274,7 +274,7 @@ mod _contextvars { impl AsSequence for PyContext { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { contains: atomic_func!(|seq, target, vm| { let target = target.try_to_value(vm)?; PyContext::sequence_downcast(seq).contains(target) diff --git a/stdlib/src/csv.rs b/stdlib/src/csv.rs index 4b79130111..04ebe49162 100644 --- a/stdlib/src/csv.rs +++ b/stdlib/src/csv.rs @@ -12,9 +12,9 @@ mod _csv { }; use csv_core::Terminator; use itertools::{self, Itertools}; - use once_cell::sync::Lazy; use parking_lot::Mutex; use rustpython_vm::match_class; + use std::sync::LazyLock; use std::{collections::HashMap, fmt}; #[pyattr] @@ -41,11 +41,11 @@ mod _csv { ) } - static GLOBAL_HASHMAP: Lazy>> = Lazy::new(|| { + static GLOBAL_HASHMAP: LazyLock>> = LazyLock::new(|| { let m = HashMap::new(); Mutex::new(m) }); - static GLOBAL_FIELD_LIMIT: Lazy> = Lazy::new(|| Mutex::new(131072)); + static GLOBAL_FIELD_LIMIT: LazyLock> = LazyLock::new(|| Mutex::new(131072)); fn new_csv_error(vm: &VirtualMachine, msg: String) -> PyBaseExceptionRef { vm.new_exception_msg(super::_csv::error(vm), msg) diff --git a/stdlib/src/mmap.rs b/stdlib/src/mmap.rs index cbc86bb2c9..f8600307b2 100644 --- a/stdlib/src/mmap.rs +++ b/stdlib/src/mmap.rs @@ -456,8 +456,8 @@ mod mmap { impl AsSequence for PyMmap { fn as_sequence() -> &'static PySequenceMethods { - use once_cell::sync::Lazy; - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + use std::sync::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| { let zelf = PyMmap::sequence_downcast(seq); diff --git a/stdlib/src/sqlite.rs b/stdlib/src/sqlite.rs index 67e94bd81b..97ec193c46 100644 --- a/stdlib/src/sqlite.rs +++ b/stdlib/src/sqlite.rs @@ -1953,8 +1953,8 @@ mod _sqlite { impl AsMapping for Row { fn as_mapping() -> &'static PyMappingMethods { - static AS_MAPPING: once_cell::sync::Lazy = - once_cell::sync::Lazy::new(|| PyMappingMethods { + static AS_MAPPING: std::sync::LazyLock = + std::sync::LazyLock::new(|| PyMappingMethods { length: atomic_func!(|mapping, _vm| Ok(Row::mapping_downcast(mapping) .data .len())), @@ -1969,8 +1969,8 @@ mod _sqlite { impl AsSequence for Row { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: once_cell::sync::Lazy = - once_cell::sync::Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: std::sync::LazyLock = + std::sync::LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, _vm| Ok(Row::sequence_downcast(seq).data.len())), item: atomic_func!(|seq, i, vm| Row::sequence_downcast(seq) .data diff --git a/vm/src/builtins/bytes.rs b/vm/src/builtins/bytes.rs index e9f5adc8bb..eff4190eda 100644 --- a/vm/src/builtins/bytes.rs +++ b/vm/src/builtins/bytes.rs @@ -27,7 +27,7 @@ use crate::{ }, }; use bstr::ByteSlice; -use once_cell::sync::Lazy; +use std::sync::LazyLock; use std::{mem::size_of, ops::Deref}; #[pyclass(module = false, name = "bytes")] @@ -568,7 +568,7 @@ impl AsBuffer for PyBytes { impl AsMapping for PyBytes { fn as_mapping() -> &'static PyMappingMethods { - static AS_MAPPING: Lazy = Lazy::new(|| PyMappingMethods { + static AS_MAPPING: LazyLock = LazyLock::new(|| PyMappingMethods { length: atomic_func!(|mapping, _vm| Ok(PyBytes::mapping_downcast(mapping).len())), subscript: atomic_func!( |mapping, needle, vm| PyBytes::mapping_downcast(mapping)._getitem(needle, vm) @@ -581,7 +581,7 @@ impl AsMapping for PyBytes { impl AsSequence for PyBytes { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, _vm| Ok(PyBytes::sequence_downcast(seq).len())), concat: atomic_func!(|seq, other, vm| { PyBytes::sequence_downcast(seq) diff --git a/vm/src/builtins/dict.rs b/vm/src/builtins/dict.rs index c8da40dc01..a19b11fcfb 100644 --- a/vm/src/builtins/dict.rs +++ b/vm/src/builtins/dict.rs @@ -23,9 +23,9 @@ use crate::{ }, vm::VirtualMachine, }; -use once_cell::sync::Lazy; use rustpython_common::lock::PyMutex; use std::fmt; +use std::sync::LazyLock; pub type DictContentType = dictdatatype::Dict; @@ -443,7 +443,7 @@ impl AsMapping for PyDict { impl AsSequence for PyDict { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { contains: atomic_func!(|seq, target, vm| PyDict::sequence_downcast(seq) .entries .contains(vm, target)), @@ -1133,7 +1133,7 @@ impl Comparable for PyDictKeys { impl AsSequence for PyDictKeys { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, _vm| Ok(PyDictKeys::sequence_downcast(seq).len())), contains: atomic_func!(|seq, target, vm| { PyDictKeys::sequence_downcast(seq) @@ -1196,7 +1196,7 @@ impl Comparable for PyDictItems { impl AsSequence for PyDictItems { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, _vm| Ok(PyDictItems::sequence_downcast(seq).len())), contains: atomic_func!(|seq, target, vm| { let needle: &Py = match target.downcast_ref() { @@ -1246,7 +1246,7 @@ impl Unconstructible for PyDictValues {} impl AsSequence for PyDictValues { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, _vm| Ok(PyDictValues::sequence_downcast(seq).len())), ..PySequenceMethods::NOT_IMPLEMENTED }); diff --git a/vm/src/builtins/genericalias.rs b/vm/src/builtins/genericalias.rs index 0e0a34227b..549985bcfb 100644 --- a/vm/src/builtins/genericalias.rs +++ b/vm/src/builtins/genericalias.rs @@ -1,4 +1,4 @@ -use once_cell::sync::Lazy; +use std::sync::LazyLock; use super::type_; use crate::{ @@ -325,7 +325,7 @@ pub fn subs_parameters PyResult>( impl AsMapping for PyGenericAlias { fn as_mapping() -> &'static PyMappingMethods { - static AS_MAPPING: Lazy = Lazy::new(|| PyMappingMethods { + static AS_MAPPING: LazyLock = LazyLock::new(|| PyMappingMethods { subscript: atomic_func!(|mapping, needle, vm| { PyGenericAlias::mapping_downcast(mapping).getitem(needle.to_owned(), vm) }), diff --git a/vm/src/builtins/mappingproxy.rs b/vm/src/builtins/mappingproxy.rs index 385d18df0b..5dd31500fb 100644 --- a/vm/src/builtins/mappingproxy.rs +++ b/vm/src/builtins/mappingproxy.rs @@ -12,7 +12,7 @@ use crate::{ Representable, }, }; -use once_cell::sync::Lazy; +use std::sync::LazyLock; #[pyclass(module = false, name = "mappingproxy", traverse)] #[derive(Debug)] @@ -221,7 +221,7 @@ impl Comparable for PyMappingProxy { impl AsMapping for PyMappingProxy { fn as_mapping() -> &'static PyMappingMethods { - static AS_MAPPING: Lazy = Lazy::new(|| PyMappingMethods { + static AS_MAPPING: LazyLock = LazyLock::new(|| PyMappingMethods { length: atomic_func!(|mapping, vm| PyMappingProxy::mapping_downcast(mapping).len(vm)), subscript: atomic_func!(|mapping, needle, vm| { PyMappingProxy::mapping_downcast(mapping).getitem(needle.to_owned(), vm) @@ -234,7 +234,7 @@ impl AsMapping for PyMappingProxy { impl AsSequence for PyMappingProxy { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { contains: atomic_func!( |seq, target, vm| PyMappingProxy::sequence_downcast(seq)._contains(target, vm) ), diff --git a/vm/src/builtins/memory.rs b/vm/src/builtins/memory.rs index e411d312db..c5af12dc1f 100644 --- a/vm/src/builtins/memory.rs +++ b/vm/src/builtins/memory.rs @@ -28,8 +28,8 @@ use crate::{ }; use crossbeam_utils::atomic::AtomicCell; use itertools::Itertools; -use once_cell::sync::Lazy; use rustpython_common::lock::PyMutex; +use std::sync::LazyLock; use std::{cmp::Ordering, fmt::Debug, mem::ManuallyDrop, ops::Range}; #[derive(FromArgs)] @@ -993,7 +993,7 @@ impl AsMapping for PyMemoryView { impl AsSequence for PyMemoryView { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, vm| { let zelf = PyMemoryView::sequence_downcast(seq); zelf.try_not_released(vm)?; diff --git a/vm/src/builtins/range.rs b/vm/src/builtins/range.rs index b542a5f191..2878e5f053 100644 --- a/vm/src/builtins/range.rs +++ b/vm/src/builtins/range.rs @@ -17,8 +17,8 @@ use crossbeam_utils::atomic::AtomicCell; use malachite_bigint::{BigInt, Sign}; use num_integer::Integer; use num_traits::{One, Signed, ToPrimitive, Zero}; -use once_cell::sync::Lazy; use std::cmp::max; +use std::sync::LazyLock; // Search flag passed to iter_search enum SearchType { @@ -385,7 +385,7 @@ impl PyRange { impl AsMapping for PyRange { fn as_mapping() -> &'static PyMappingMethods { - static AS_MAPPING: Lazy = Lazy::new(|| PyMappingMethods { + static AS_MAPPING: LazyLock = LazyLock::new(|| PyMappingMethods { length: atomic_func!( |mapping, vm| PyRange::mapping_downcast(mapping).protocol_length(vm) ), @@ -400,7 +400,7 @@ impl AsMapping for PyRange { impl AsSequence for PyRange { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, vm| PyRange::sequence_downcast(seq).protocol_length(vm)), item: atomic_func!(|seq, i, vm| { PyRange::sequence_downcast(seq) diff --git a/vm/src/builtins/set.rs b/vm/src/builtins/set.rs index 40823aa37b..3e10e5c6b7 100644 --- a/vm/src/builtins/set.rs +++ b/vm/src/builtins/set.rs @@ -23,11 +23,11 @@ use crate::{ utils::collection_repr, vm::VirtualMachine, }; -use once_cell::sync::Lazy; use rustpython_common::{ atomic::{Ordering, PyAtomic, Radium}, hash, }; +use std::sync::LazyLock; use std::{fmt, ops::Deref}; pub type SetContentType = dictdatatype::Dict<()>; @@ -794,7 +794,7 @@ impl Initializer for PySet { impl AsSequence for PySet { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, _vm| Ok(PySet::sequence_downcast(seq).len())), contains: atomic_func!(|seq, needle, vm| PySet::sequence_downcast(seq) .inner @@ -1112,7 +1112,7 @@ impl PyFrozenSet { impl AsSequence for PyFrozenSet { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, _vm| Ok(PyFrozenSet::sequence_downcast(seq).len())), contains: atomic_func!(|seq, needle, vm| PyFrozenSet::sequence_downcast(seq) .inner diff --git a/vm/src/builtins/str.rs b/vm/src/builtins/str.rs index 55cefae4f7..c0bd556bf1 100644 --- a/vm/src/builtins/str.rs +++ b/vm/src/builtins/str.rs @@ -28,7 +28,6 @@ use ascii::{AsciiChar, AsciiStr, AsciiString}; use bstr::ByteSlice; use itertools::Itertools; use num_traits::ToPrimitive; -use once_cell::sync::Lazy; use rustpython_common::{ ascii, atomic::{self, PyAtomic, Radium}, @@ -38,6 +37,7 @@ use rustpython_common::{ str::DeduceStrKind, wtf8::{CodePoint, Wtf8, Wtf8Buf, Wtf8Chunk}, }; +use std::sync::LazyLock; use std::{borrow::Cow, char, fmt, ops::Range}; use unic_ucd_bidi::BidiClass; use unic_ucd_category::GeneralCategory; @@ -1495,7 +1495,7 @@ impl Iterable for PyStr { impl AsMapping for PyStr { fn as_mapping() -> &'static PyMappingMethods { - static AS_MAPPING: Lazy = Lazy::new(|| PyMappingMethods { + static AS_MAPPING: LazyLock = LazyLock::new(|| PyMappingMethods { length: atomic_func!(|mapping, _vm| Ok(PyStr::mapping_downcast(mapping).len())), subscript: atomic_func!( |mapping, needle, vm| PyStr::mapping_downcast(mapping)._getitem(needle, vm) @@ -1524,7 +1524,7 @@ impl AsNumber for PyStr { impl AsSequence for PyStr { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, _vm| Ok(PyStr::sequence_downcast(seq).len())), concat: atomic_func!(|seq, other, vm| { let zelf = PyStr::sequence_downcast(seq); diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs index c9af04d300..52577f0e2e 100644 --- a/vm/src/builtins/tuple.rs +++ b/vm/src/builtins/tuple.rs @@ -19,8 +19,7 @@ use crate::{ utils::collection_repr, vm::VirtualMachine, }; -use once_cell::sync::Lazy; -use std::{fmt, marker::PhantomData}; +use std::{fmt, marker::PhantomData, sync::LazyLock}; #[pyclass(module = false, name = "tuple", traverse)] pub struct PyTuple { @@ -351,7 +350,7 @@ impl PyTuple { impl AsMapping for PyTuple { fn as_mapping() -> &'static PyMappingMethods { - static AS_MAPPING: Lazy = Lazy::new(|| PyMappingMethods { + static AS_MAPPING: LazyLock = LazyLock::new(|| PyMappingMethods { length: atomic_func!(|mapping, _vm| Ok(PyTuple::mapping_downcast(mapping).len())), subscript: atomic_func!( |mapping, needle, vm| PyTuple::mapping_downcast(mapping)._getitem(needle, vm) @@ -364,7 +363,7 @@ impl AsMapping for PyTuple { impl AsSequence for PyTuple { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, _vm| Ok(PyTuple::sequence_downcast(seq).len())), concat: atomic_func!(|seq, other, vm| { let zelf = PyTuple::sequence_downcast(seq); diff --git a/vm/src/builtins/union.rs b/vm/src/builtins/union.rs index 165113e216..83e2c86f08 100644 --- a/vm/src/builtins/union.rs +++ b/vm/src/builtins/union.rs @@ -10,8 +10,8 @@ use crate::{ protocol::{PyMappingMethods, PyNumberMethods}, types::{AsMapping, AsNumber, Comparable, GetAttr, Hashable, PyComparisonOp, Representable}, }; -use once_cell::sync::Lazy; use std::fmt; +use std::sync::LazyLock; const CLS_ATTRS: &[&str] = &["__module__"]; @@ -219,7 +219,7 @@ impl PyUnion { impl AsMapping for PyUnion { fn as_mapping() -> &'static PyMappingMethods { - static AS_MAPPING: Lazy = Lazy::new(|| PyMappingMethods { + static AS_MAPPING: LazyLock = LazyLock::new(|| PyMappingMethods { subscript: atomic_func!(|mapping, needle, vm| { PyUnion::mapping_downcast(mapping).getitem(needle.to_owned(), vm) }), diff --git a/vm/src/builtins/weakproxy.rs b/vm/src/builtins/weakproxy.rs index d17bc75118..49e38d2d66 100644 --- a/vm/src/builtins/weakproxy.rs +++ b/vm/src/builtins/weakproxy.rs @@ -11,7 +11,7 @@ use crate::{ PyComparisonOp, Representable, SetAttr, }, }; -use once_cell::sync::Lazy; +use std::sync::LazyLock; #[pyclass(module = false, name = "weakproxy", unhashable = true, traverse)] #[derive(Debug)] @@ -186,7 +186,7 @@ impl Comparable for PyWeakProxy { impl AsSequence for PyWeakProxy { fn as_sequence() -> &'static PySequenceMethods { - static AS_SEQUENCE: Lazy = Lazy::new(|| PySequenceMethods { + static AS_SEQUENCE: LazyLock = LazyLock::new(|| PySequenceMethods { length: atomic_func!(|seq, vm| PyWeakProxy::sequence_downcast(seq).len(vm)), contains: atomic_func!(|seq, needle, vm| { PyWeakProxy::sequence_downcast(seq).contains(needle.to_owned(), vm) diff --git a/vm/src/stdlib/sre.rs b/vm/src/stdlib/sre.rs index 038ac9934a..6a0a618e2f 100644 --- a/vm/src/stdlib/sre.rs +++ b/vm/src/stdlib/sre.rs @@ -814,8 +814,8 @@ mod _sre { impl AsMapping for Match { fn as_mapping() -> &'static PyMappingMethods { - static AS_MAPPING: once_cell::sync::Lazy = - once_cell::sync::Lazy::new(|| PyMappingMethods { + static AS_MAPPING: std::sync::LazyLock = + std::sync::LazyLock::new(|| PyMappingMethods { subscript: atomic_func!(|mapping, needle, vm| { Match::mapping_downcast(mapping) .getitem(needle.to_owned(), vm) From ad5788589bc5f6b058347ae0a7b4e76dfc9d476d Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Wed, 26 Mar 2025 18:20:43 +0900 Subject: [PATCH 2/2] Remove more direct use of OnceCell --- stdlib/src/uuid.rs | 4 ++-- vm/src/vm/mod.rs | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/stdlib/src/uuid.rs b/stdlib/src/uuid.rs index 0bd7d0db8a..872f5bde0a 100644 --- a/stdlib/src/uuid.rs +++ b/stdlib/src/uuid.rs @@ -4,7 +4,7 @@ pub(crate) use _uuid::make_module; mod _uuid { use crate::{builtins::PyNone, vm::VirtualMachine}; use mac_address::get_mac_address; - use once_cell::sync::OnceCell; + use std::sync::OnceLock; use uuid::{Context, Uuid, timestamp::Timestamp}; fn get_node_id() -> [u8; 6] { @@ -19,7 +19,7 @@ mod _uuid { static CONTEXT: Context = Context::new(0); let ts = Timestamp::now(&CONTEXT); - static NODE_ID: OnceCell<[u8; 6]> = OnceCell::new(); + static NODE_ID: OnceLock<[u8; 6]> = OnceLock::new(); let unique_node_id = NODE_ID.get_or_init(get_node_id); (Uuid::new_v1(ts, unique_node_id).as_bytes().to_vec(), PyNone) diff --git a/vm/src/vm/mod.rs b/vm/src/vm/mod.rs index 493789f510..9aec244529 100644 --- a/vm/src/vm/mod.rs +++ b/vm/src/vm/mod.rs @@ -107,8 +107,8 @@ pub struct PyGlobalState { } pub fn process_hash_secret_seed() -> u32 { - use once_cell::sync::OnceCell; - static SEED: OnceCell = OnceCell::new(); + use std::sync::OnceLock; + static SEED: OnceLock = OnceLock::new(); *SEED.get_or_init(rand::random) }