Remove `once_cell` dependency and replace with `OnceLock`

7 files changed, 56 insertions, 42 deletions

diff --git a/mingling_macros/Cargo.toml b/mingling_macros/Cargo.toml
index 1464d54..4f2b094 100644
--- a/mingling_macros/Cargo.toml
+++ b/mingling_macros/Cargo.toml
@@ -26,4 +26,3 @@ quote.workspace = true
 proc-macro2.workspace = true
 
 just_fmt.workspace = true
-once_cell.workspace = true
diff --git a/mingling_macros/src/chain.rs b/mingling_macros/src/chain.rs
index 5ec5635..6e5fd64 100644
--- a/mingling_macros/src/chain.rs
+++ b/mingling_macros/src/chain.rs
@@ -628,8 +628,8 @@ pub fn register_chain(input: TokenStream) -> TokenStream {
     // Record the chain existence check
     let chain_exist_entry = build_chain_exist_arm(&previous_type);
 
-    let mut chains = crate::CHAINS.lock().unwrap();
-    let mut chain_exist = crate::CHAINS_EXIST.lock().unwrap();
+    let mut chains = crate::get_global_set(&crate::CHAINS).lock().unwrap();
+    let mut chain_exist = crate::get_global_set(&crate::CHAINS_EXIST).lock().unwrap();
 
     let chain_entry_str = chain_entry.to_string();
     let chain_exist_entry_str = chain_exist_entry.to_string();
diff --git a/mingling_macros/src/completion.rs b/mingling_macros/src/completion.rs
index cd4a9ad..ba0de2e 100644
--- a/mingling_macros/src/completion.rs
+++ b/mingling_macros/src/completion.rs
@@ -6,6 +6,8 @@ use syn::{FnArg, Ident, ItemFn, PatType, Type, parse_macro_input};
 #[cfg(feature = "comp")]
 pub fn completion_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
     // Parse the attribute arguments (e.g., HelloEntry from #[completion(HelloEntry)])
+
+    use crate::get_global_set;
     let previous_type_ident = if attr.is_empty() {
         return syn::Error::new(
             proc_macro2::Span::call_site(),
@@ -109,7 +111,7 @@ pub fn completion_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
         Self::#previous_type_ident => <#struct_name as ::mingling::Completion>::comp(ctx),
     };
 
-    let mut completions = crate::COMPLETIONS.lock().unwrap();
+    let mut completions = get_global_set(&crate::COMPLETIONS).lock().unwrap();
     let completion_str = completion_entry.to_string();
     completions.insert(completion_str);
 
diff --git a/mingling_macros/src/dispatcher.rs b/mingling_macros/src/dispatcher.rs
index 9724fd1..e327d6b 100644
--- a/mingling_macros/src/dispatcher.rs
+++ b/mingling_macros/src/dispatcher.rs
@@ -208,10 +208,13 @@ pub fn register_dispatcher(input: TokenStream) -> TokenStream {
 
     // Register node info in the global collection at compile time
     // Format: "node.name:DispatcherType:EntryName"
-    COMPILE_TIME_DISPATCHERS.lock().unwrap().insert(format!(
-        "{}:{}:{}",
-        node_name_str, dispatcher_type, entry_name
-    ));
+    crate::get_global_set(&COMPILE_TIME_DISPATCHERS)
+        .lock()
+        .unwrap()
+        .insert(format!(
+            "{}:{}:{}",
+            node_name_str, dispatcher_type, entry_name
+        ));
 
     let expanded = quote! {
         #[doc(hidden)]
diff --git a/mingling_macros/src/help.rs b/mingling_macros/src/help.rs
index 6667ae0..7ce9e83 100644
--- a/mingling_macros/src/help.rs
+++ b/mingling_macros/src/help.rs
@@ -5,6 +5,8 @@ use syn::{
     FnArg, Ident, ItemFn, Pat, PatType, ReturnType, Signature, Type, TypePath, parse_macro_input,
 };
 
+use crate::get_global_set;
+
 /// Extracts the previous type and parameter name from function arguments
 fn extract_previous_info(sig: &Signature) -> syn::Result<(Pat, TypePath)> {
     // The function should have exactly one parameter
@@ -102,7 +104,10 @@ pub fn help_attr(item: TokenStream) -> TokenStream {
     // Register the help request mapping
     let help_entry = build_help_entry(&struct_name, &entry_type);
     let entry_str = help_entry.to_string();
-    crate::HELP_REQUESTS.lock().unwrap().insert(entry_str);
+    get_global_set(&crate::HELP_REQUESTS)
+        .lock()
+        .unwrap()
+        .insert(entry_str);
 
     // Generate the struct and HelpRequest implementation
     let expanded = quote! {
@@ -186,7 +191,10 @@ pub fn register_help(input: TokenStream) -> TokenStream {
     // Register the help request mapping
     let help_entry = build_help_entry(&struct_name, &entry_type);
     let entry_str = help_entry.to_string();
-    crate::HELP_REQUESTS.lock().unwrap().insert(entry_str);
+    get_global_set(&crate::HELP_REQUESTS)
+        .lock()
+        .unwrap()
+        .insert(entry_str);
 
     quote! {}.into()
 }
diff --git a/mingling_macros/src/lib.rs b/mingling_macros/src/lib.rs
index badb117..29c46b4 100644
--- a/mingling_macros/src/lib.rs
+++ b/mingling_macros/src/lib.rs
@@ -17,12 +17,12 @@
 //! - **Internal registration**: `register_type!`, `register_chain!`, `register_renderer!`,
 //!   `program_fallback_gen!`, `program_final_gen!`, `program_comp_gen!`
 
-use once_cell::sync::Lazy;
 use proc_macro::TokenStream;
 use proc_macro2::Ident;
 use quote::quote;
 use std::collections::BTreeSet;
 use std::sync::Mutex;
+use std::sync::OnceLock;
 use syn::parse_macro_input;
 
 mod chain;
@@ -55,29 +55,26 @@ pub(crate) fn default_program_path() -> proc_macro2::TokenStream {
     quote::quote! { crate::ThisProgram }
 }
 
+// Helper to get or init a OnceLock<Mutex<BTreeSet<String>>>
+pub(crate) fn get_global_set(lock: &OnceLock<Mutex<BTreeSet<String>>>) -> &Mutex<BTreeSet<String>> {
+    lock.get_or_init(|| Mutex::new(BTreeSet::new()))
+}
+
 // Global variables
 #[cfg(feature = "general_renderer")]
-pub(crate) static GENERAL_RENDERERS: Lazy<Mutex<BTreeSet<String>>> =
-    Lazy::new(|| Mutex::new(BTreeSet::new()));
+pub(crate) static GENERAL_RENDERERS: OnceLock<Mutex<BTreeSet<String>>> = OnceLock::new();
 #[cfg(feature = "comp")]
-pub(crate) static COMPLETIONS: Lazy<Mutex<BTreeSet<String>>> =
-    Lazy::new(|| Mutex::new(BTreeSet::new()));
+pub(crate) static COMPLETIONS: OnceLock<Mutex<BTreeSet<String>>> = OnceLock::new();
 
 #[cfg(feature = "dispatch_tree")]
-pub(crate) static COMPILE_TIME_DISPATCHERS: Lazy<Mutex<BTreeSet<String>>> =
-    Lazy::new(|| Mutex::new(BTreeSet::new()));
-
-pub(crate) static PACKED_TYPES: Lazy<Mutex<BTreeSet<String>>> =
-    Lazy::new(|| Mutex::new(BTreeSet::new()));
-pub(crate) static CHAINS: Lazy<Mutex<BTreeSet<String>>> = Lazy::new(|| Mutex::new(BTreeSet::new()));
-pub(crate) static RENDERERS: Lazy<Mutex<BTreeSet<String>>> =
-    Lazy::new(|| Mutex::new(BTreeSet::new()));
-pub(crate) static CHAINS_EXIST: Lazy<Mutex<BTreeSet<String>>> =
-    Lazy::new(|| Mutex::new(BTreeSet::new()));
-pub(crate) static RENDERERS_EXIST: Lazy<Mutex<BTreeSet<String>>> =
-    Lazy::new(|| Mutex::new(BTreeSet::new()));
-pub(crate) static HELP_REQUESTS: Lazy<Mutex<BTreeSet<String>>> =
-    Lazy::new(|| Mutex::new(BTreeSet::new()));
+pub(crate) static COMPILE_TIME_DISPATCHERS: OnceLock<Mutex<BTreeSet<String>>> = OnceLock::new();
+
+pub(crate) static PACKED_TYPES: OnceLock<Mutex<BTreeSet<String>>> = OnceLock::new();
+pub(crate) static CHAINS: OnceLock<Mutex<BTreeSet<String>>> = OnceLock::new();
+pub(crate) static RENDERERS: OnceLock<Mutex<BTreeSet<String>>> = OnceLock::new();
+pub(crate) static CHAINS_EXIST: OnceLock<Mutex<BTreeSet<String>>> = OnceLock::new();
+pub(crate) static RENDERERS_EXIST: OnceLock<Mutex<BTreeSet<String>>> = OnceLock::new();
+pub(crate) static HELP_REQUESTS: OnceLock<Mutex<BTreeSet<String>>> = OnceLock::new();
 
 /// Checks that a TypePath is a simple single-segment identifier (no `::` in the path).
 ///
@@ -1137,7 +1134,10 @@ pub fn register_type(input: TokenStream) -> TokenStream {
     let type_ident = parse_macro_input!(input as syn::Ident);
     let entry_str = type_ident.to_string();
 
-    PACKED_TYPES.lock().unwrap().insert(entry_str);
+    get_global_set(&PACKED_TYPES)
+        .lock()
+        .unwrap()
+        .insert(entry_str);
 
     TokenStream::new()
 }
@@ -1280,18 +1280,18 @@ pub fn program_fallback_gen(input: TokenStream) -> TokenStream {
 pub fn program_final_gen(input: TokenStream) -> TokenStream {
     let name = read_name(&input);
 
-    let packed_types = PACKED_TYPES.lock().unwrap().clone();
+    let packed_types = get_global_set(&PACKED_TYPES).lock().unwrap().clone();
 
-    let renderers = RENDERERS.lock().unwrap().clone();
-    let chains = CHAINS.lock().unwrap().clone();
-    let renderer_exist = RENDERERS_EXIST.lock().unwrap().clone();
-    let chain_exist = CHAINS_EXIST.lock().unwrap().clone();
+    let renderers = get_global_set(&RENDERERS).lock().unwrap().clone();
+    let chains = get_global_set(&CHAINS).lock().unwrap().clone();
+    let renderer_exist = get_global_set(&RENDERERS_EXIST).lock().unwrap().clone();
+    let chain_exist = get_global_set(&CHAINS_EXIST).lock().unwrap().clone();
 
     #[cfg(feature = "general_renderer")]
-    let general_renderers = GENERAL_RENDERERS.lock().unwrap().clone();
+    let general_renderers = get_global_set(&GENERAL_RENDERERS).lock().unwrap().clone();
 
     #[cfg(feature = "comp")]
-    let completions = COMPLETIONS.lock().unwrap().clone();
+    let completions = get_global_set(&COMPLETIONS).lock().unwrap().clone();
 
     let packed_types: Vec<proc_macro2::TokenStream> = packed_types
         .iter()
@@ -1341,7 +1341,7 @@ pub fn program_final_gen(input: TokenStream) -> TokenStream {
     let general_render = quote! {};
 
     #[cfg(feature = "dispatch_tree")]
-    let compile_time_dispatchers: Vec<String> = COMPILE_TIME_DISPATCHERS
+    let compile_time_dispatchers: Vec<String> = get_global_set(&COMPILE_TIME_DISPATCHERS)
         .lock()
         .unwrap()
         .clone()
@@ -1398,7 +1398,7 @@ pub fn program_final_gen(input: TokenStream) -> TokenStream {
     #[cfg(not(feature = "comp"))]
     let comp = quote! {};
 
-    let help_tokens: Vec<proc_macro2::TokenStream> = HELP_REQUESTS
+    let help_tokens: Vec<proc_macro2::TokenStream> = get_global_set(&HELP_REQUESTS)
         .lock()
         .unwrap()
         .clone()
diff --git a/mingling_macros/src/renderer.rs b/mingling_macros/src/renderer.rs
index 36ebf54..d2c2221 100644
--- a/mingling_macros/src/renderer.rs
+++ b/mingling_macros/src/renderer.rs
@@ -3,6 +3,8 @@ use quote::{ToTokens, quote};
 use syn::spanned::Spanned;
 use syn::{FnArg, ItemFn, Pat, PatType, ReturnType, Signature, Type, TypePath, parse_macro_input};
 
+use crate::get_global_set;
+
 /// Extracts the previous type and parameter name from function arguments
 fn extract_previous_info(sig: &Signature) -> syn::Result<(Pat, TypePath)> {
     // The function should have exactly one parameter
@@ -212,11 +214,11 @@ pub fn register_renderer(input: TokenStream) -> TokenStream {
     #[cfg(feature = "general_renderer")]
     let general_renderer_entry = build_general_renderer_entry(&previous_type);
 
-    let mut renderers = crate::RENDERERS.lock().unwrap();
-    let mut renderer_exist = crate::RENDERERS_EXIST.lock().unwrap();
+    let mut renderers = get_global_set(&crate::RENDERERS).lock().unwrap();
+    let mut renderer_exist = get_global_set(&crate::RENDERERS_EXIST).lock().unwrap();
 
     #[cfg(feature = "general_renderer")]
-    let mut general_renderers = crate::GENERAL_RENDERERS.lock().unwrap();
+    let mut general_renderers = get_global_set(&crate::GENERAL_RENDERERS).lock().unwrap();
 
     let renderer_entry_str = renderer_entry.to_string();
     let renderer_exist_entry_str = renderer_exist_entry.to_string();