Tracking prototype

Author: laurmaedje

examples/image.rs

@@ -0,0 +1,66 @@
+use comemo::{Track, Tracked};
+
+fn main() {
+    let mut image = Image::new(20, 40);
+
+    // [Miss] The cache is empty.
+    describe(image.track());
+
+    // [Hit] Everything stayed the same.
+    describe(image.track());
+
+    image.resize(80, 30);
+
+    // [Miss] The image's width and height are different.
+    describe(image.track());
+
+    image.resize(80, 70);
+    image.pixels.fill(255);
+
+    // [Hit] The last call only read the width and it stayed the same.
+    describe(image.track());
+}
+
+/// Format the image's size humanly readable.
+#[comemo::memoize]
+fn describe(image: Tracked<Image>) -> &'static str {
+    if image.width() > 50 || image.height() > 50 {
+        "The image is big!"
+    } else {
+        "The image is small!"
+    }
+}
+
+/// A raster image.
+struct Image {
+    width: u32,
+    height: u32,
+    pixels: Vec<u8>,
+}
+
+impl Image {
+    fn new(width: u32, height: u32) -> Self {
+        Self {
+            width,
+            height,
+            pixels: vec![0; (width * height) as usize],
+        }
+    }
+
+    fn resize(&mut self, width: u32, height: u32) {
+        self.width = width;
+        self.height = height;
+        // Resize the actual image ...
+    }
+}
+
+#[comemo::track]
+impl Image {
+    fn width(&self) -> u32 {
+        self.width
+    }
+
+    fn height(&self) -> u32 {
+        self.height
+    }
+}

macros/src/lib.rs

@@ -14,8 +14,7 @@ mod track;
 
 use proc_macro::TokenStream;
 use proc_macro2::Span;
-use quote::{quote, quote_spanned};
-use syn::spanned::Spanned;
+use quote::quote;
 use syn::{parse_quote, Error, Result};
 
 /// Memoize a pure function.
@@ -31,7 +30,7 @@ use syn::{parse_quote, Error, Result};
 #[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()
 }
@@ -62,7 +61,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::*;
 
 /// Make a type trackable.
-pub fn expand(mut func: syn::ItemFn) -> Result<proc_macro2::TokenStream> {
+pub fn expand(func: &syn::ItemFn) -> Result<proc_macro2::TokenStream> {
     let name = func.sig.ident.to_string();
 
     let mut args = vec![];
@@ -24,51 +24,25 @@ pub fn expand(mut func: syn::ItemFn) -> Result<proc_macro2::TokenStream> {
     let mut inner = func.clone();
     inner.sig.ident = syn::Ident::new("inner", Span::call_site());
 
-    let asserts = args.iter().map(|ident| {
-        quote_spanned! {
-            ident.span() =>
-            argument_must_be_hash_or_tracked(&#ident);
-        }
-    });
-
-    let hashes = args.iter().map(|ident| {
+    let cts = args.iter().map(|arg| {
         quote! {
-            #ident.hash(&mut state);
+            Validate::constraint(&#arg)
         }
     });
 
-    func.block = parse_quote! { { #inner {
-        fn argument_must_be_hash_or_tracked<T: std::hash::Hash>(_: &T) {}
-        #(#asserts)*
-
-        use std::collections::HashMap;
-        use std::hash::Hash;
+    let mut outer = func.clone();
+    outer.block = parse_quote! { { #inner {
         use std::sync::atomic::{AtomicUsize, Ordering};
-        use std::sync::Mutex;
-        use comemo::once_cell::sync::Lazy;
-        use comemo::siphasher::sip128::{Hasher128, SipHasher};
+        use comemo::Validate;
 
         static NR: AtomicUsize = AtomicUsize::new(1);
-        static MAP: Lazy<Mutex<HashMap<u128, String>>> =
-            Lazy::new(|| Mutex::new(HashMap::new()));
-
         let nr = NR.fetch_add(1, Ordering::SeqCst);
-        let hash = {
-            let mut state = SipHasher::new();
-            #(#hashes)*
-            state.finish128().as_u128()
-        };
+        let cts = (#(#cts,)*);
+
+        println!("{:?}", cts);
 
-        let mut hit = true;
-        let result = MAP
-            .lock()
-            .unwrap()
-            .entry(hash)
-            .or_insert_with(|| {
-                hit = false;
-                inner(#(#args),*)
-            })
-            .clone();
+        let mut hit = false;
+        let result = inner(#(#args),*);
 
         println!(
             "{} {} {} {}",
@@ -81,5 +55,5 @@ pub fn expand(mut func: syn::ItemFn) -> Result<proc_macro2::TokenStream> {
         result
     } } };
 
-    Ok(quote! { #func })
+    Ok(quote! { #outer })
 }

macros/src/track.rs

@@ -1,62 +1,67 @@
 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;
 
-    let mut tracked_methods = vec![];
+    // Extract and validate the methods.
+    let mut methods = vec![];
     for item in &block.items {
-        let method = match item {
-            syn::ImplItem::Method(method) => method,
-            _ => bail!(item, "only methods are supported"),
-        };
+        methods.push(method(&item)?);
+    }
 
-        let mut tracked = method.clone();
-        let name = &tracked.sig.ident;
+    let tracked_methods = methods.iter().map(|method| {
+        let mut method = (*method).clone();
+        let name = &method.sig.ident;
+        method.block = parse_quote! { {
+            let output = self.0.#name();
+            let slot = &mut self.constraint().#name;
+            let ct = Validate::constraint(&output);
+            if slot.is_none() {
+                assert_eq!(*slot, Some(ct), "comemo: method is not pure");
+            }
+            *slot = Some(ct);
+            output
+        } };
+        method
+    });
 
-        let mut inputs = tracked.sig.inputs.iter();
-        let receiver = match inputs.next() {
-            Some(syn::FnArg::Receiver(recv)) => recv,
-            _ => bail!(tracked, "method must take self"),
+    let tracked_fields = methods.iter().map(|method| {
+        let name = &method.sig.ident;
+        let ty = match &method.sig.output {
+            syn::ReturnType::Default => unreachable!(),
+            syn::ReturnType::Type(_, ty) => ty.as_ref(),
         };
+        quote! { #name: Option<<#ty as Validate>::Constraint>, }
+    });
 
-        if receiver.reference.is_none() || receiver.mutability.is_some() {
-            bail!(receiver, "must take self by shared reference");
-        }
+    let track_impl = quote! {
+        use comemo::Validate;
 
-        let mut args = vec![];
-        for input in inputs {
-            let pat = match input {
-                syn::FnArg::Typed(typed) => &*typed.pat,
-                syn::FnArg::Receiver(_) => unreachable!("unexpected second self"),
-            };
+        struct Surface<'a>(&'a #ty);
 
-            let ident = match pat {
-                syn::Pat::Ident(ident) => ident,
-                _ => bail!(pat, "only simple identifiers are supported"),
-            };
+        impl Surface<'_> {
+            #(#tracked_methods)*
 
-            args.push(ident);
+            fn constraint(&self) -> &mut Constraint {
+                todo!()
+            }
         }
 
-        tracked.block = parse_quote! { { self.0.#name(#(#args),*) } };
-        tracked_methods.push(tracked);
-    }
-
-    let track_impl = quote! {
-        impl comemo::Track for #ty {
-            type Surface = Surface;
-
-            fn surface(&self) -> &Surface {
-                unsafe { &*(self as *const Self as *const Surface) }
+        impl<'a> From<&'a #ty> for Surface<'a> {
+            fn from(val: &'a #ty) -> Self {
+                Self(val)
             }
         }
 
-        #[repr(transparent)]
-        struct Surface(#ty);
+        #[derive(Debug, Default)]
+        struct Constraint {
+            #(#tracked_fields)*
+        }
 
-        impl Surface {
-            #(#tracked_methods)*
+        impl<'a> comemo::Track<'a> for #ty {
+            type Surface = Surface<'a>;
+            type Constraint = Constraint;
         }
     };
 
@@ -65,3 +70,38 @@ pub fn expand(block: syn::ItemImpl) -> Result<proc_macro2::TokenStream> {
         const _: () = { #track_impl };
     })
 }
+
+/// Extract and validate a method.
+fn method(item: &syn::ImplItem) -> Result<&syn::ImplItemMethod> {
+    let method = match item {
+        syn::ImplItem::Method(method) => method,
+        _ => bail!(item, "only methods are supported"),
+    };
+
+    let mut inputs = method.sig.inputs.iter();
+    let receiver = match inputs.next() {
+        Some(syn::FnArg::Receiver(recv)) => recv,
+        _ => bail!(method, "method must take self"),
+    };
+
+    if receiver.reference.is_none() || receiver.mutability.is_some() {
+        bail!(receiver, "must take self by shared reference");
+    }
+
+    if inputs.next().is_some() {
+        bail!(
+            method.sig,
+            "currently, only methods without extra arguments are supported"
+        );
+    }
+
+    let output = &method.sig.output;
+    match output {
+        syn::ReturnType::Default => {
+            bail!(method.sig, "method must have a return type")
+        }
+        syn::ReturnType::Type(..) => {}
+    }
+
+    Ok(method)
+}