Bump to 2024 edition (#9)

Author: laurmaedje

.github/workflows/ci.yml

@@ -6,6 +6,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: dtolnay/rust-toolchain@1.88.0
       - run: cargo build --all-features
       - run: cargo test --all-features

Cargo.toml

@@ -5,7 +5,7 @@ resolver = "2"
 [workspace.package]
 version = "0.4.0"
 authors = ["Laurenz <[email protected]>"]
-edition = "2021"
+edition = "2024"
 repository = "https://github.com/typst/comemo"
 readme = "README.md"
 license = "MIT OR Apache-2.0"

examples/calc.rs

@@ -5,7 +5,7 @@
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
-use comemo::{memoize, track, Track, Tracked};
+use comemo::{Track, Tracked, memoize, track};
 
 fn main() {
     // Create some scripts in the calc language. This language supports addition

macros/src/lib.rs

@@ -18,7 +18,7 @@ use proc_macro::TokenStream as BoundaryStream;
 use proc_macro2::TokenStream;
 use quote::{quote, quote_spanned};
 use syn::spanned::Spanned;
-use syn::{parse_quote, Error, Result};
+use syn::{Error, Result, parse_quote};
 
 /// Memoize a function.
 ///

macros/src/track.rs

@@ -161,12 +161,11 @@ fn prepare_method(vis: syn::Visibility, sig: &syn::Signature) -> Result<Method>
         kinds.push(kind)
     }
 
-    if let syn::ReturnType::Type(_, ty) = &sig.output {
-        if let syn::Type::Reference(syn::TypeReference { mutability, .. }) = ty.as_ref() {
-            if mutability.is_some() {
-                bail!(ty, "tracked methods cannot return mutable references");
-            }
-        }
+    if let syn::ReturnType::Type(_, ty) = &sig.output
+        && let syn::Type::Reference(syn::TypeReference { mutability, .. }) = ty.as_ref()
+        && mutability.is_some()
+    {
+        bail!(ty, "tracked methods cannot return mutable references");
     }
 
     Ok(Method {
@@ -188,15 +187,15 @@ fn create_variants(methods: &[Method]) -> TokenStream {
         quote! { __ComemoVariant::#name(..) => #mutable }
     });
 
-    let is_mutable = (!methods.is_empty())
-        .then(|| {
-            quote! {
-                match &self.0 {
-                    #(#is_mutable_variants),*
-                }
+    let is_mutable = if !methods.is_empty() {
+        quote! {
+            match &self.0 {
+                #(#is_mutable_variants),*
             }
-        })
-        .unwrap_or_else(|| quote! { false });
+        }
+    } else {
+        quote! { false}
+    };
 
     quote! {
         #[derive(Clone, PartialEq, Hash)]

src/constraint.rs

@@ -1,6 +1,6 @@
 use std::borrow::Cow;
-use std::collections::hash_map::Entry;
 use std::collections::HashMap;
+use std::collections::hash_map::Entry;
 use std::hash::Hash;
 
 use parking_lot::RwLock;

src/input.rs

@@ -45,7 +45,10 @@ pub trait Input {
 impl<T: Hash> Input for T {
     // No constraint for hashed inputs.
     type Constraint = ();
-    type Tracked<'r> = Self where Self: 'r;
+    type Tracked<'r>
+        = Self
+    where
+        Self: 'r;
     type Outer = ();
 
     #[inline]
@@ -76,7 +79,10 @@ where
 {
     // Forward constraint from `Trackable` implementation.
     type Constraint = <T as Validate>::Constraint;
-    type Tracked<'r> = Tracked<'r, T> where Self: 'r;
+    type Tracked<'r>
+        = Tracked<'r, T>
+    where
+        Self: 'r;
     type Outer = Option<&'a Self::Constraint>;
 
     #[inline]
@@ -113,7 +119,10 @@ where
 {
     // Forward constraint from `Trackable` implementation.
     type Constraint = T::Constraint;
-    type Tracked<'r> = TrackedMut<'r, T> where Self: 'r;
+    type Tracked<'r>
+        = TrackedMut<'r, T>
+    where
+        Self: 'r;
     type Outer = Option<&'a Self::Constraint>;
 
     #[inline]

src/lib.rs

@@ -99,10 +99,10 @@ pub use comemo_macros::{memoize, track};
 pub mod internal {
     pub use parking_lot::RwLock;
 
-    pub use crate::cache::{memoized, register_evictor, Cache, CacheData};
-    pub use crate::constraint::{hash, Call, ImmutableConstraint, MutableConstraint};
-    pub use crate::input::{assert_hashable_or_trackable, Args, Input};
-    pub use crate::track::{to_parts_mut_mut, to_parts_mut_ref, to_parts_ref, Surfaces};
+    pub use crate::cache::{Cache, CacheData, memoized, register_evictor};
+    pub use crate::constraint::{Call, ImmutableConstraint, MutableConstraint, hash};
+    pub use crate::input::{Args, Input, assert_hashable_or_trackable};
+    pub use crate::track::{Surfaces, to_parts_mut_mut, to_parts_mut_ref, to_parts_ref};
 
     #[cfg(feature = "testing")]
     pub use crate::cache::last_was_hit;

src/track.rs

@@ -12,7 +12,7 @@ use crate::constraint::Join;
 pub trait Track: Validate + Surfaces {
     /// Start tracking all accesses to a value.
     #[inline]
-    fn track(&self) -> Tracked<Self> {
+    fn track(&self) -> Tracked<'_, Self> {
         Tracked {
             value: self,
             constraint: None,
@@ -22,7 +22,7 @@ pub trait Track: Validate + Surfaces {
 
     /// Start tracking all accesses and mutations to a value.
     #[inline]
-    fn track_mut(&mut self) -> TrackedMut<Self> {
+    fn track_mut(&mut self) -> TrackedMut<'_, Self> {
         TrackedMut { value: self, constraint: None }
     }
 
@@ -293,7 +293,7 @@ where
 
 /// Destructure a `Tracked<_>` into its parts.
 #[inline]
-pub fn to_parts_ref<T>(tracked: Tracked<T>) -> (&T, Option<&T::Constraint>)
+pub fn to_parts_ref<T>(tracked: Tracked<'_, T>) -> (&T, Option<&T::Constraint>)
 where
     T: Track + ?Sized,
 {

tests/tests.rs

@@ -4,7 +4,7 @@ use std::collections::HashMap;
 use std::hash::Hash;
 use std::path::{Path, PathBuf};
 
-use comemo::{evict, memoize, track, Track, Tracked, TrackedMut, Validate};
+use comemo::{Track, Tracked, TrackedMut, Validate, evict, memoize, track};
 use serial_test::serial;
 
 macro_rules! test {
@@ -39,11 +39,7 @@ fn test_basic() {
 
     #[memoize]
     fn fib(n: u32) -> u32 {
-        if n <= 2 {
-            1
-        } else {
-            fib(n - 1) + fib(n - 2)
-        }
+        if n <= 2 { 1 } else { fib(n - 1) + fib(n - 2) }
     }
 
     #[memoize]
@@ -213,11 +209,7 @@ fn test_kinds() {
 
     #[memoize]
     fn unconditional(tester: Tracky) -> &'static str {
-        if tester.by_value(Heavy("HEAVY".into())) > 10 {
-            "Long"
-        } else {
-            "Short"
-        }
+        if tester.by_value(Heavy("HEAVY".into())) > 10 { "Long" } else { "Short" }
     }
 
     let mut tester = Tester { data: "Hi".to_string() };
@@ -264,11 +256,7 @@ impl Tester {
 
     /// Return value can borrow from both.
     fn double_ref<'a>(&'a self, name: &'a str) -> &'a str {
-        if name.len() > self.data.len() {
-            name
-        } else {
-            &self.data
-        }
+        if name.len() > self.data.len() { name } else { &self.data }
     }
 
     /// Normal method with owned argument.
@@ -371,40 +359,40 @@ impl<'a> Chain<'a> {
 #[track]
 impl<'a> Chain<'a> {
     fn contains(&self, value: u32) -> bool {
-        self.value == value || self.outer.map_or(false, |outer| outer.contains(value))
+        self.value == value || self.outer.is_some_and(|outer| outer.contains(value))
     }
 }
 
 /// Test mutable tracking.
-    #[test]
-    #[serial]
-    #[rustfmt::skip]
-    fn test_mutable() {
-        #[comemo::memoize]
-        fn dump(mut sink: TrackedMut<Emitter>) {
-            sink.emit("a");
-            sink.emit("b");
-            let c = sink.len_or_ten().to_string();
-            sink.emit(&c);
-        }
-
-        let mut emitter = Emitter(vec![]);
-        test!(miss: dump(emitter.track_mut()), ());
-        test!(miss: dump(emitter.track_mut()), ());
-        test!(miss: dump(emitter.track_mut()), ());
-        test!(miss: dump(emitter.track_mut()), ());
-        test!(hit: dump(emitter.track_mut()), ());
-        test!(hit: dump(emitter.track_mut()), ());
-        assert_eq!(emitter.0, [
-            "a", "b", "2",
-            "a", "b", "5",
-            "a", "b", "8",
-            "a", "b", "10",
-            "a", "b", "10",
-            "a", "b", "10",
-        ])
+#[test]
+#[serial]
+#[rustfmt::skip]
+fn test_mutable() {
+    #[comemo::memoize]
+    fn dump(mut sink: TrackedMut<Emitter>) {
+        sink.emit("a");
+        sink.emit("b");
+        let c = sink.len_or_ten().to_string();
+        sink.emit(&c);
     }
 
+    let mut emitter = Emitter(vec![]);
+    test!(miss: dump(emitter.track_mut()), ());
+    test!(miss: dump(emitter.track_mut()), ());
+    test!(miss: dump(emitter.track_mut()), ());
+    test!(miss: dump(emitter.track_mut()), ());
+    test!(hit: dump(emitter.track_mut()), ());
+    test!(hit: dump(emitter.track_mut()), ());
+    assert_eq!(emitter.0, [
+        "a", "b", "2",
+        "a", "b", "5",
+        "a", "b", "8",
+        "a", "b", "10",
+        "a", "b", "10",
+        "a", "b", "10",
+    ])
+}
+
 /// A tracked type with a mutable and an immutable method.
 #[derive(Clone)]
 struct Emitter(Vec<String>);