Replace unsafe static mut patterns with once_cell

Author: fxdmhtt

Cargo.lock

@@ -5,3 +5,4 @@ edition = "2024"
 
 [dependencies]
 lru = "0.16.0"
+once_cell = "1.21.3"

cache/Cargo.toml

@@ -1,4 +1,5 @@
 use lru::LruCache;
+use once_cell::unsync::Lazy;
 use std::{any::Any, num::NonZeroUsize, rc::Rc};
 
 use crate::Observable;
@@ -7,29 +8,22 @@ type CacheKey = *const dyn Observable;
 
 const CACHE_CAP: usize = 128;
 
-static mut CACHE: Option<LruCache<CacheKey, Rc<dyn Any>>> = None;
-
-fn cache() -> &'static mut LruCache<CacheKey, Rc<dyn Any>> {
-    #[allow(static_mut_refs)]
-    unsafe {
-        CACHE.get_or_insert_with(|| LruCache::new(NonZeroUsize::new(CACHE_CAP).unwrap()))
-    }
-}
+static mut CACHE: Lazy<LruCache<CacheKey, Rc<dyn Any>>> =
+    Lazy::new(|| LruCache::new(NonZeroUsize::new(CACHE_CAP).unwrap()));
 
 pub fn touch<T: 'static>(key: &'static dyn Observable) -> Option<Rc<T>> {
-    cache()
-        .get(&(key as _))
+    unsafe { (*CACHE).get(&(key as _)) }
         .map(Rc::clone)
         .filter(|rc| rc.is::<T>())
         .map(|rc| unsafe { Rc::from_raw(Rc::into_raw(rc) as *const T) })
 }
 
 pub fn store_in_cache<T: 'static>(key: &'static dyn Observable, val: T) -> Rc<T> {
     let rc = Rc::new(val);
-    cache().put(key, Rc::clone(&rc) as _);
+    unsafe { (*CACHE).put(key, Rc::clone(&rc) as _) };
     rc
 }
 
 pub fn remove_from_cache(key: &'static dyn Observable) {
-    cache().pop(&(key as _));
+    unsafe { (*CACHE).pop(&(key as _)) };
 }

cache/src/cache.rs

@@ -1,22 +1,17 @@
-use crate::Observable;
+use once_cell::sync::Lazy;
 
-static mut CALL_STACK: Option<Vec<&'static dyn Observable>> = None;
+use crate::Observable;
 
-fn call_stack() -> &'static mut Vec<&'static dyn Observable> {
-    #[allow(static_mut_refs)]
-    unsafe {
-        CALL_STACK.get_or_insert_with(Vec::new)
-    }
-}
+static mut CALL_STACK: Lazy<Vec<&'static dyn Observable>> = Lazy::new(Vec::new);
 
 pub fn push(op: &'static dyn Observable) {
-    call_stack().push(op)
+    unsafe { (*CALL_STACK).push(op) }
 }
 
 pub fn last() -> Option<&'static &'static dyn Observable> {
-    call_stack().last()
+    unsafe { (*CALL_STACK).last() }
 }
 
 pub fn pop() -> Option<&'static dyn Observable> {
-    call_stack().pop()
+    unsafe { (*CALL_STACK).pop() }
 }

cache/src/call_stack.rs

@@ -7,6 +7,7 @@ edition = "2024"
 proc-macro = true
 
 [dependencies]
+once_cell = "1.21.3"
 proc-macro2 = "1.0.95"
 quote = "1.0.40"
 syn = { version = "2.0.104", features = ["full"] }

macros/Cargo.toml

@@ -32,13 +32,12 @@ pub fn memo(_attr: TokenStream, item: TokenStream) -> TokenStream {
     let memo_ident = format_ident!("{}", ident.to_string().to_uppercase());
 
     let expanded = quote! {
-        static mut #memo_ident: Option<cache::Memo<#output_ty, fn() -> #output_ty>> = None;
+        static mut #memo_ident: once_cell::unsync::Lazy<cache::Memo<#output_ty, fn() -> #output_ty>> = once_cell::unsync::Lazy::new(|| cache::Memo::new(|| #block));
 
         #vis #sig
         where #output_ty: Clone + 'static
         {
-            #[allow(static_mut_refs)]
-            unsafe { &mut #memo_ident }.get_or_insert_with(|| cache::Memo::new(|| #block)).get()
+            unsafe { (*#memo_ident).get() }
         }
     };
 

macros/src/lib.rs

@@ -71,10 +71,7 @@ fn complex_dependency_memo_test() {
     assert_eq!(d2, d1);
     assert_eq!(e2, e1);
 
-    #[allow(static_mut_refs)]
-    if let Some(memo) = unsafe { &SOURCE_A } {
-        memo.invalidate();
-    }
+    unsafe { (*SOURCE_A).invalidate() };
 
     unsafe { SOURCE_A_CALLED = false };
     unsafe { SOURCE_C_CALLED = false };