Improve diagnostics

Author: laurmaedje

macros/src/lib.rs

@@ -14,13 +14,14 @@ mod track;
 
 use proc_macro::TokenStream;
 use quote::{quote, quote_spanned};
-use syn::{parse_quote, spanned::Spanned, Error, Result};
+use syn::spanned::Spanned;
+use syn::{parse_quote, Error, Result};
 
 /// Memoize a pure function.
 #[proc_macro_attribute]
 pub fn memoize(_: TokenStream, stream: TokenStream) -> TokenStream {
     let func = syn::parse_macro_input!(stream as syn::ItemFn);
-    memoize::expand(&func)
+    memoize::expand(func)
         .unwrap_or_else(|err| err.to_compile_error())
         .into()
 }
@@ -29,7 +30,7 @@ pub fn memoize(_: TokenStream, stream: TokenStream) -> TokenStream {
 #[proc_macro_attribute]
 pub fn track(_: TokenStream, stream: TokenStream) -> TokenStream {
     let block = syn::parse_macro_input!(stream as syn::ItemImpl);
-    track::expand(&block)
+    track::expand(block)
         .unwrap_or_else(|err| err.to_compile_error())
         .into()
 }

macros/src/memoize.rs

@@ -1,7 +1,7 @@
 use super::*;
 
 /// Memoize a function.
-pub fn expand(func: &syn::ItemFn) -> Result<proc_macro2::TokenStream> {
+pub fn expand(mut func: syn::ItemFn) -> Result<proc_macro2::TokenStream> {
     let mut args = vec![];
     let mut types = vec![];
     for input in &func.sig.inputs {
@@ -21,30 +21,30 @@ pub fn expand(func: &syn::ItemFn) -> Result<proc_macro2::TokenStream> {
         types.push(typed.ty.as_ref());
     }
 
-    let mut inner = func.clone();
+    // Construct a tuple from all arguments.
     let arg_tuple = quote! { (#(#args,)*) };
-    let type_tuple = quote! { (#(#types,)*) };
-    inner.sig.inputs = parse_quote! { #arg_tuple: #type_tuple };
 
+    // Construct assertions that the arguments fulfill the necessary bounds.
     let bounds = args.iter().zip(&types).map(|(arg, ty)| {
         quote_spanned! {
             arg.span() => ::comemo::internal::assert_hashable_or_trackable::<#ty>();
         }
     });
 
-    let mut outer = func.clone();
-    let name = &func.sig.ident;
-    outer.block = parse_quote! { {
-        #inner
+    // Construct the inner closure.
+    let body = &func.block;
+    let inner = quote! { |#arg_tuple| #body };
+
+    // Adjust the function's body.
+    let name = func.sig.ident.to_string();
+    func.block = parse_quote! { {
         #(#bounds;)*
-        ::comemo::internal::CACHE.with(|cache|
-            cache.query(
-                stringify!(#name),
-                ::comemo::internal::Args(#arg_tuple),
-                #name,
-            )
+        ::comemo::internal::cached(
+            #name,
+            ::comemo::internal::Args(#arg_tuple),
+            #inner,
         )
     } };
 
-    Ok(quote! { #outer })
+    Ok(quote! { #func })
 }

macros/src/track.rs

@@ -1,7 +1,7 @@
 use super::*;
 
 /// Make a type trackable.
-pub fn expand(block: &syn::ItemImpl) -> Result<proc_macro2::TokenStream> {
+pub fn expand(block: syn::ItemImpl) -> Result<proc_macro2::TokenStream> {
     let ty = &block.self_ty;
 
     // Extract and validate the methods.

src/cache.rs

@@ -1,12 +1,46 @@
-use std::any::Any;
+use std::any::{Any, TypeId};
 use std::cell::RefCell;
 use std::fmt::Debug;
+use std::hash::Hash;
 
 use siphasher::sip128::{Hasher128, SipHasher};
 
 use crate::input::Input;
 use crate::internal::Family;
 
+/// Execute a function or use a cached result for it.
+pub fn cached<In, Out, F>(name: &str, input: In, func: F) -> Out
+where
+    In: Input,
+    Out: Debug + Clone + 'static,
+    F: for<'f> Fn(<In::Tracked as Family<'f>>::Out) -> Out + 'static,
+{
+    // Compute the hash of the input's key part.
+    let hash = {
+        let mut state = SipHasher::new();
+        TypeId::of::<F>().hash(&mut state);
+        input.key(&mut state);
+        state.finish128().as_u128()
+    };
+
+    let mut hit = true;
+    let output = CACHE.with(|cache| {
+        cache.lookup::<In, Out>(hash, &input).unwrap_or_else(|| {
+            let constraint = In::Constraint::default();
+            let value = func(input.track(&constraint));
+            let constrained = Constrained { value: value.clone(), constraint };
+            cache.insert::<In, Out>(hash, constrained);
+            hit = false;
+            value
+        })
+    });
+
+    let label = if hit { "[hit]" } else { "[miss]" };
+    eprintln!("{name:<9} {label:<7} {output:?}");
+
+    output
+}
+
 thread_local! {
     /// The global, dynamic cache shared by all memoized functions.
     pub static CACHE: Cache = Cache::default();
@@ -31,36 +65,6 @@ struct Constrained<T, C> {
 }
 
 impl Cache {
-    /// Execute `f` or use a cached result for it.
-    pub fn query<In, Out, F>(&self, name: &str, input: In, func: F) -> Out
-    where
-        In: Input,
-        Out: Debug + Clone + 'static,
-        F: for<'f> Fn(<In::Tracked as Family<'f>>::Out) -> Out,
-    {
-        // Compute the hash of the input's key part.
-        let hash = {
-            let mut state = SipHasher::new();
-            input.key(&mut state);
-            state.finish128().as_u128()
-        };
-
-        let mut hit = true;
-        let output = self.lookup::<In, Out>(hash, &input).unwrap_or_else(|| {
-            let constraint = In::Constraint::default();
-            let value = func(input.track(&constraint));
-            let constrained = Constrained { value: value.clone(), constraint };
-            self.insert::<In, Out>(hash, constrained);
-            hit = false;
-            value
-        });
-
-        let label = if hit { "[hit]" } else { "[miss]" };
-        eprintln!("{name:<9} {label:<7} {output:?}");
-
-        output
-    }
-
     /// Look for a matching entry in the cache.
     fn lookup<In, Out>(&self, hash: u128, input: &In) -> Option<Out>
     where
@@ -75,7 +79,7 @@ impl Cache {
                 entry
                     .output
                     .downcast_ref::<Constrained<Out, In::Constraint>>()
-                    .expect("comemo: hash collision")
+                    .expect("comemo: a hash collision occurred")
             })
             .find(|output| input.valid(&output.constraint))
             .map(|output| output.value.clone())

src/hash.rs

@@ -24,7 +24,7 @@ impl<T: Hash> HashConstraint<T> {
 }
 
 /// Produce a non zero 128-bit hash of a value.
-pub fn hash<T: Hash>(value: &T) -> u128 {
+fn hash<T: Hash>(value: &T) -> u128 {
     let mut state = SipHasher::new();
     value.hash(&mut state);
     state.finish128().as_u128()

src/input.rs

@@ -8,6 +8,9 @@ use crate::track::{from_parts, to_parts, Track, Trackable, Tracked};
 pub fn assert_hashable_or_trackable<T: Input>() {}
 
 /// An input to a cached function.
+///
+/// This is implemented for hashable types, `Tracked<_>` types and `Args<(...)>`
+/// types containing tuples up to length twelve.
 pub trait Input {
     /// Describes an instance of this input.
     type Constraint: Default + 'static;
@@ -81,7 +84,7 @@ impl<'a, T: Track> Input for Tracked<'a, T> {
     }
 }
 
-/// 'f -> Tracked<'f, T> type constructor.
+/// Type constructor for `'f -> Tracked<'f, T>`.
 pub struct TrackedFamily<T>(PhantomData<T>);
 
 impl<'f, T: Track + 'f> Family<'f> for TrackedFamily<T> {
@@ -91,17 +94,17 @@ impl<'f, T: Track + 'f> Family<'f> for TrackedFamily<T> {
 /// Wrapper for multiple inputs.
 pub struct Args<T>(pub T);
 
-/// Lifetime to tuple of arguments type constructor.
+/// Type constructor that maps a lifetime to tuple of arguments.
 pub struct ArgsFamily<T>(PhantomData<T>);
 
 macro_rules! args_input {
-    ($($idx:tt: $letter:ident),*) => {
+    ($($param:tt $idx:tt ),*) => {
         #[allow(unused_variables)]
-        impl<$($letter: Input),*> Input for Args<($($letter,)*)> {
-            type Constraint = ($($letter::Constraint,)*);
-            type Tracked = ArgsFamily<($($letter,)*)>;
+        impl<$($param: Input),*> Input for Args<($($param,)*)> {
+            type Constraint = ($($param::Constraint,)*);
+            type Tracked = ArgsFamily<($($param,)*)>;
 
-            fn key<H: Hasher>(&self, state: &mut H) {
+            fn key<T: Hasher>(&self, state: &mut T) {
                 $((self.0).$idx.key(state);)*
             }
 
@@ -121,17 +124,22 @@ macro_rules! args_input {
         }
 
         #[allow(unused_parens)]
-        impl<'f, $($letter: Input),*> Family<'f> for ArgsFamily<($($letter,)*)> {
-            type Out = ($(<$letter::Tracked as Family<'f>>::Out,)*);
+        impl<'f, $($param: Input),*> Family<'f> for ArgsFamily<($($param,)*)> {
+            type Out = ($(<$param::Tracked as Family<'f>>::Out,)*);
         }
     };
 }
 
 args_input! {}
-args_input! { 0: A }
-args_input! { 0: A, 1: B }
-args_input! { 0: A, 1: B, 2: C }
-args_input! { 0: A, 1: B, 2: C, 3: D }
-args_input! { 0: A, 1: B, 2: C, 3: D, 4: E }
-args_input! { 0: A, 1: B, 2: C, 3: D, 4: E, 5: F }
-args_input! { 0: A, 1: B, 2: C, 3: D, 4: E, 5: F, 6: G }
+args_input! { A 0 }
+args_input! { A 0, B 1 }
+args_input! { A 0, B 1, C 2 }
+args_input! { A 0, B 1, C 2, D 3 }
+args_input! { A 0, B 1, C 2, D 3, E 4 }
+args_input! { A 0, B 1, C 2, D 3, E 4, F 5 }
+args_input! { A 0, B 1, C 2, D 3, E 4, F 5, G 6 }
+args_input! { A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7 }
+args_input! { A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8 }
+args_input! { A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9 }
+args_input! { A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10 }
+args_input! { A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11 }

src/lib.rs

@@ -11,10 +11,10 @@ pub use comemo_macros::{memoize, track};
 /// These are implementation details. Do not rely on them!
 #[doc(hidden)]
 pub mod internal {
-    pub use crate::cache::CACHE;
+    pub use crate::cache::cached;
     pub use crate::hash::HashConstraint;
     pub use crate::input::{assert_hashable_or_trackable, Args};
-    pub use crate::track::{from_parts, to_parts, Trackable};
+    pub use crate::track::{to_parts, Trackable};
 
     /// Helper trait for lifetime type families.
     pub trait Family<'a> {

src/main.rs

@@ -29,21 +29,18 @@ fn main() {
 
 /// Format the image's size humanly readable.
 fn describe(image: Tracked<Image>) -> &'static str {
-    fn describe((image,): (Tracked<Image>,)) -> &'static str {
-        if image.width() > 50 || image.height() > 50 {
-            "The image is big!"
-        } else {
-            "The image is small!"
-        }
-    }
-
-    ::comemo::internal::CACHE.with(|cache| {
-        cache.query(
-            stringify!(describe),
-            ::comemo::internal::Args((image,)),
-            describe,
-        )
-    })
+    ::comemo::internal::assert_hashable_or_trackable::<Tracked<Image>>();
+    ::comemo::internal::cached(
+        "describe",
+        ::comemo::internal::Args((image,)),
+        |(image,)| {
+            if image.width() > 50 || image.height() > 50 {
+                "The image is big!"
+            } else {
+                "The image is small!"
+            }
+        },
+    )
 }
 
 const _: () = {

tests/image.rs

@@ -11,7 +11,7 @@ fn test_image() {
 
     describe(image.track()); // [Miss] Width and height changed.
     select(image.track(), "width"); // [Miss] First call.
-    select(image.track(), "height"); // [Miss]
+    select(image.track(), "height"); // [Miss] Different 2nd argument.
 
     image.resize(80, 70);
     image.pixels.fill(255);