Extracts cache and call stack logic into separate modules for better code organization and reusability.

Removes unused feature `vec_peek_mut` to streamline dependencies.

Author: fxdmhtt

cache/src/cache.rs

@@ -0,0 +1,33 @@
+use lru::LruCache;
+use std::{any::Any, num::NonZeroUsize, rc::Rc};
+
+use crate::OperatorFunc;
+
+const CACHE_CAP: usize = 128;
+
+static mut CACHE: Option<LruCache<OperatorFunc, Rc<dyn Any>>> = None;
+
+fn cache() -> &'static mut LruCache<OperatorFunc, Rc<dyn Any>> {
+    #[allow(static_mut_refs)]
+    unsafe {
+        CACHE.get_or_insert_with(|| LruCache::new(NonZeroUsize::new(CACHE_CAP).unwrap()))
+    }
+}
+
+pub fn touch<T: 'static>(key: OperatorFunc) -> Option<Rc<T>> {
+    cache()
+        .get(&key)
+        .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: OperatorFunc, val: T) -> Rc<T> {
+    let rc = Rc::new(val);
+    cache().put(key, Rc::clone(&rc) as _);
+    rc
+}
+
+pub fn remove_from_cache(key: OperatorFunc) {
+    cache().pop(&key);
+}

cache/src/call_stack.rs

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

cache/src/lib.rs

@@ -1,6 +1,3 @@
-use lru::LruCache;
-use std::{any::Any, num::NonZeroUsize, rc::Rc};
-
 pub enum Trace {
     Push,
     Pop,
@@ -13,40 +10,7 @@ pub enum MemoOperator {
 
 pub type OperatorFunc = fn(MemoOperator);
 
-const CACHE_CAP: usize = 128;
-
-static mut CACHE: Option<LruCache<OperatorFunc, Rc<dyn Any>>> = None;
-
-static mut CALL_STACK: Option<Vec<OperatorFunc>> = None;
-
-fn cache() -> &'static mut LruCache<OperatorFunc, Rc<dyn Any>> {
-    #[allow(static_mut_refs)]
-    unsafe {
-        CACHE.get_or_insert_with(|| LruCache::new(NonZeroUsize::new(CACHE_CAP).unwrap()))
-    }
-}
-
-pub fn call_stack() -> &'static mut Vec<OperatorFunc> {
-    #[allow(static_mut_refs)]
-    unsafe {
-        CALL_STACK.get_or_insert_with(|| Vec::new())
-    }
-}
-
-pub fn touch<T: 'static>(key: OperatorFunc) -> Option<Rc<T>> {
-    cache()
-        .get(&key)
-        .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: OperatorFunc, val: T) -> Rc<T> {
-    let rc = Rc::new(val);
-    cache().put(key, Rc::clone(&rc) as _);
-    rc
-}
+pub mod cache;
+pub mod call_stack;
 
-pub fn remove_from_cache(key: OperatorFunc) {
-    cache().pop(&key);
-}
+pub use cache::{remove_from_cache, store_in_cache, touch};

macros/src/lib.rs

@@ -61,13 +61,13 @@ pub fn memo(_attr: TokenStream, item: TokenStream) -> TokenStream {
             static mut dependents: Vec<cache::OperatorFunc> = Vec::new();
             match op {
                 cache::MemoOperator::Memo(cache::Trace::Push) => {
-                    if let Some(last) = cache::call_stack().peek_mut() {
-                        unsafe { dependents.push(*last) };
+                    if let Some(last) = cache::call_stack::last() {
+                        unsafe { dependents.push(last.clone()) };
                     }
-                    cache::call_stack().push(#op_ident);
+                    cache::call_stack::push(#op_ident);
                 },
                 cache::MemoOperator::Memo(cache::Trace::Pop) => {
-                    cache::call_stack().pop();
+                    cache::call_stack::pop();
                 },
                 cache::MemoOperator::Pop => {
                     for dependent in unsafe { dependents.iter() } {

macros/tests/basic.rs

@@ -1,5 +1,3 @@
-#![feature(vec_peek_mut)]
-
 use macros::memo;
 
 #[memo]

macros/tests/dep.rs

@@ -1,5 +1,3 @@
-#![feature(vec_peek_mut)]
-
 use macros::memo;
 
 static mut SOURCE_A_CALLED: bool = false;