Better testing

Author: laurmaedje

.github/workflows/rust.yml

@@ -0,0 +1,23 @@
+name: Continuous integration
+
+on: [push, pull_request]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        rust: [stable]
+
+    steps:
+      - name: Checkout source code
+        uses: actions/checkout@v2
+
+      - name: Build
+        run: cargo build
+
+      - name: Test
+        run: cargo test

README.md

@@ -58,9 +58,9 @@ with more fine-grained access tracking. To use it, we can just:
 - Wrap the `files` argument in comemo's `Tracked` container.
 
 This instructs comemo to memoize the evaluation and to automatically track all
-file accesses during a memoization call. As a result, we can reuse the result of
-a `.calc` script evaluation as as long as its dependencies stay the same—even
-if other files change.
+file accesses during a memoized call. As a result, we can reuse the result of a
+`.calc` script evaluation as as long as its dependencies stay the same—even if
+other files change.
 
 ```rust
 use comemo::{memoize, track, Tracked};
@@ -82,7 +82,7 @@ impl Files {
 
 For the full example see [`examples/calc.rs`][calc].
 
-[calc]: (https://github.com/typst/comemo/blob/main/examples/calc.rs)
+[calc]: https://github.com/typst/comemo/blob/main/examples/calc.rs
 
 ## License
 This crate is dual-licensed under the MIT and Apache 2.0 licenses.

examples/calc.rs

@@ -9,7 +9,7 @@ use comemo::{memoize, track, Track, Tracked};
 
 fn main() {
     // Create some scripts in the calc language. This language supports addition
-    // and `eval` statements refering to other files.
+    // and `eval` statements referring to other files.
     let mut files = Files(HashMap::new());
     files.write("alpha.calc", "2 + eval beta.calc");
     files.write("beta.calc", "2 + 3");
@@ -19,7 +19,7 @@ fn main() {
     assert_eq!(evaluate("eval alpha.calc", files.track()), 7);
 
     // [Miss] This is not a top-level hit because this exact string was never
-    // passed to `evalaute`, but this does not compute "2 + 3" again.
+    // passed to `evaluate`, but this does not compute "2 + 3" again.
     assert_eq!(evaluate("eval beta.calc", files.track()), 5);
 
     // Modify the gamma file.

macros/src/lib.rs

@@ -54,7 +54,7 @@ use syn::{parse_quote, Error, Result};
 /// There are certain restrictions that apply to memoized functions. Most of
 /// these are checked by comemo, but some are your responsibility:
 /// - They must be **pure**, that is, **free of observable side effects**. This
-///   is **your reponsibility** as comemo can't check it.
+///   is **your responsibility** as comemo can't check it.
 /// - They must have an explicit return type.
 /// - They cannot have mutable parameters (conflicts with purity).
 /// - They cannot use destructuring patterns in their arguments.
@@ -68,7 +68,7 @@ pub fn memoize(_: BoundaryStream, stream: BoundaryStream) -> BoundaryStream {
 
 /// Make a type trackable.
 ///
-/// Adding this to an impl block of a type `T`, implements the `Track` trait for
+/// Adding this to an impl block of a type `T` implements the `Track` trait for
 /// `T`. This lets you call `.track()` on that type, producing a `Tracked<T>`.
 /// When such a tracked type is used an argument to a memoized function it
 /// enjoys fine-grained access tracking instead of being bluntly hashed.
@@ -102,8 +102,11 @@ pub fn memoize(_: BoundaryStream, stream: BoundaryStream) -> BoundaryStream {
 /// methods. Just like with memoized functions, certain restrictions apply to
 /// tracked methods:
 /// - They must be **pure**, that is, **free of observable side effects**. This
-///   is **your reponsibility** as comemo can't check it. You can use interior
+///   is **your responsibility** as comemo can't check it. You can use interior
 ///   mutability as long as the method stays idempotent.
+/// - Their **return values must implement `Hash`** and **must feed all the
+///   information they expose to the hasher**. Otherwise, memoized results might
+///   get reused invalidly.
 /// - They cannot be generic.
 /// - They can only be private or public not `pub(...)`.
 /// - They cannot be `unsafe`, `async` or `const`.

src/cache.rs

@@ -34,27 +34,38 @@ where
         let constraint = In::Constraint::default();
 
         // Check if there is a cached output.
-        if let Some(constrained) = cache.borrow_mut().lookup::<In, Out>(key, &input) {
+        let mut borrow = cache.borrow_mut();
+        if let Some(constrained) = borrow.lookup::<In, Out>(key, &input) {
             // Add the cached constraints to the outer ones.
             let (_, outer) = input.retrack(&constraint);
             outer.join(&constrained.constraint);
-            return constrained.output.clone();
+            let value = constrained.output.clone();
+            borrow.last_was_hit = true;
+            return value;
         }
 
         // Execute the function with the new constraints hooked in.
+        drop(borrow);
         let (input, outer) = input.retrack(&constraint);
         let output = func(input);
 
         // Add the new constraints to the outer ones.
         outer.join(&constraint);
 
         // Insert the result into the cache.
-        cache.borrow_mut().insert::<In, Out>(key, constraint, output.clone());
+        borrow = cache.borrow_mut();
+        borrow.insert::<In, Out>(key, constraint, output.clone());
+        borrow.last_was_hit = false;
 
         output
     })
 }
 
+/// Whether the last call was a hit.
+pub fn last_was_hit() -> bool {
+    CACHE.with(|cache| cache.borrow().last_was_hit)
+}
+
 /// Evict the cache.
 ///
 /// This removes all memoized results from the cache whose age is larger than or
@@ -82,6 +93,8 @@ pub fn evict(max_age: usize) {
 struct Cache {
     /// Maps from function IDs + hashes to memoized results.
     map: HashMap<(TypeId, u128), Vec<Entry>>,
+    /// Whether the last call was a hit.
+    last_was_hit: bool,
 }
 
 impl Cache {

src/lib.rs

@@ -49,13 +49,13 @@ This is where comemo comes into play. It implements _constrained memoization_
 with more fine-grained access tracking. To use it, we can just:
 
 - Add the [`#[memoize]`](macro@memoize) attribute to the `evaluate` function.
-- Add the [`#[track]`](macro@memoize) attribute to the impl block of `Files`.
+- Add the [`#[track]`](macro@track) attribute to the impl block of `Files`.
 - Wrap the `files` argument in comemo's [`Tracked`] container.
 
 This instructs comemo to memoize the evaluation and to automatically track all
-file accesses during a memoization call. As a result, we can reuse the result of
-a `.calc` script evaluation as as long as its dependencies stay the same—even
-if other files change.
+file accesses during a memoized call. As a result, we can reuse the result of a
+`.calc` script evaluation as as long as its dependencies stay the same—even if
+other files change.
 
 ```
 # /*
@@ -79,7 +79,7 @@ impl Files {
 
 For the full example see [`examples/calc.rs`][calc].
 
-[calc]: (https://github.com/typst/comemo/blob/main/examples/calc.rs)
+[calc]: https://github.com/typst/comemo/blob/main/examples/calc.rs
 */
 
 mod cache;
@@ -96,7 +96,7 @@ pub use comemo_macros::{memoize, track};
 /// These are implementation details. Do not rely on them!
 #[doc(hidden)]
 pub mod internal {
-    pub use crate::cache::memoized;
+    pub use crate::cache::{last_was_hit, memoized};
     pub use crate::constraint::{hash, Join, MultiConstraint, SoloConstraint};
     pub use crate::input::{assert_hashable_or_trackable, Args};
     pub use crate::track::{to_parts, Trackable};

src/prehashed.rs

@@ -23,7 +23,8 @@ use siphasher::sip128::{Hasher128, SipHasher};
 /// hash collision is reduced to an absolute minimum. Therefore, this type
 /// additionally provides `PartialEq` and `Eq` implementations that compare by
 /// hash instead of by value. For this to be correct, your hash implementation
-/// **must feed all information relevant to the `PartialEq` impl to the hasher.**
+/// **must feed all information relevant to the `PartialEq` impl to the
+/// hasher.**
 #[derive(Copy, Clone)]
 pub struct Prehashed<T: ?Sized> {
     /// The precomputed hash.

src/track.rs

@@ -6,9 +6,9 @@ use crate::internal::Family;
 
 /// A trackable type.
 ///
-/// This is implemented by types that have an implementation block annoted with
-/// `#[track]` and for trait objects whose traits are annotated with `#[track]`.
-/// For more details, see [its documentation](macro@crate::track).
+/// This is implemented by types that have an implementation block annotated
+/// with `#[track]` and for trait objects whose traits are annotated with
+/// `#[track]`. For more details, see [its documentation](macro@crate::track).
 pub trait Track: Trackable {
     /// Start tracking a value.
     #[inline]