Merge #326

326: Salsa 2022 tests r=nikomatsakis a=nikomatsakis

Convert the `salsa-2022-tests` crate into a utility crate, and make a `tests` directory so that we can add tests one by one.

Fixes #325 

Co-authored-by: Niko Matsakis <niko@alum.mit.edu>

salsa-2022-tests/Cargo.toml

@@ -7,10 +7,5 @@ edition = "2021"
 
 [dependencies]
 salsa = { path = "../components/salsa-2022", package = "salsa-2022" }
-
-[dev-dependencies]
 expect-test = "1.4.0"
 
-[[bin]]
-name = "salsa-2022-tests"
-path = "main.rs"

salsa-2022-tests/main.rs

@@ -1,8 +0,0 @@
-//! This crate has the beginning of various unit tests on salsa 2022
-//! code.
-
-mod tracked_fn_on_input;
-mod tracked_fn_on_tracked;
-mod tracked_fn_on_tracked_specify;
-
-fn main() {}

salsa-2022-tests/src/lib.rs

@@ -0,0 +1,24 @@
+/// Utility for tests that lets us log when notable events happen.
+#[derive(Default)]
+pub struct Logger {
+    logs: std::sync::Mutex<Vec<String>>,
+}
+
+/// Trait implemented by databases that lets them log events.
+pub trait HasLogger {
+    /// Return a reference to the logger from the database.
+    fn logger(&self) -> &Logger;
+
+    /// Log an event from inside a tracked function.
+    fn push_log(&self, string: String) {
+        self.logger().logs.lock().unwrap().push(string);
+    }
+
+    /// Asserts what the (formatted) logs should look like,
+    /// clearing the logged events. This takes `&mut self` because
+    /// it is meant to be run from outside any tracked functions.
+    fn assert_logs(&mut self, expected: expect_test::Expect) {
+        let logs = std::mem::replace(&mut *self.logger().logs.lock().unwrap(), vec![]);
+        expected.assert_eq(&format!("{:#?}", logs));
+    }
+}

salsa-2022-tests/tests/hello_world.rs

@@ -0,0 +1,85 @@
+//! Test that a `tracked` fn on a `salsa::input`
+//! compiles and executes successfully.
+#![allow(dead_code)]
+
+use salsa_2022_tests::{HasLogger, Logger};
+
+use expect_test::expect;
+
+#[salsa::jar(db = Db)]
+struct Jar(MyInput, MyTracked, final_result, intermediate_result);
+
+trait Db: salsa::DbWithJar<Jar> + HasLogger {}
+
+#[salsa::input(jar = Jar)]
+struct MyInput {
+    field: u32,
+}
+
+#[salsa::tracked(jar = Jar)]
+fn final_result(db: &dyn Db, input: MyInput) -> u32 {
+    db.push_log(format!("final_result({:?})", input));
+    intermediate_result(db, input).field(db) * 2
+}
+
+#[salsa::tracked(jar = Jar)]
+struct MyTracked {
+    field: u32,
+}
+
+#[salsa::tracked(jar = Jar)]
+fn intermediate_result(db: &dyn Db, input: MyInput) -> MyTracked {
+    db.push_log(format!("intermediate_result({:?})", input));
+    MyTracked::new(db, input.field(db) / 2)
+}
+
+#[salsa::db(Jar)]
+#[derive(Default)]
+struct Database {
+    storage: salsa::Storage<Self>,
+    logger: Logger,
+}
+
+impl salsa::Database for Database {
+    fn salsa_runtime(&self) -> &salsa::Runtime {
+        self.storage.runtime()
+    }
+}
+
+impl Db for Database {}
+
+impl HasLogger for Database {
+    fn logger(&self) -> &Logger {
+        &self.logger
+    }
+}
+
+#[test]
+fn execute() {
+    let mut db = Database::default();
+
+    let input = MyInput::new(&mut db, 22);
+    assert_eq!(final_result(&db, input), 22);
+    db.assert_logs(expect![[r#"
+        [
+            "final_result(MyInput(Id { value: 1 }))",
+            "intermediate_result(MyInput(Id { value: 1 }))",
+        ]"#]]);
+
+    // Intermediate result is the same, so final result does
+    // not need to be recomputed:
+    input.set_field(&mut db, 23);
+    assert_eq!(final_result(&db, input), 22);
+    db.assert_logs(expect![[r#"
+        [
+            "intermediate_result(MyInput(Id { value: 1 }))",
+        ]"#]]);
+
+    input.set_field(&mut db, 24);
+    assert_eq!(final_result(&db, input), 24);
+    db.assert_logs(expect![[r#"
+        [
+            "intermediate_result(MyInput(Id { value: 1 }))",
+            "final_result(MyInput(Id { value: 1 }))",
+        ]"#]]);
+}

salsa-2022-tests/tests/tracked_fn_on_tracked.rs

@@ -22,22 +22,22 @@ fn tracked_fn(db: &dyn Db, input: MyInput) -> MyTracked {
     MyTracked::new(db, input.field(db) * 2)
 }
 
+#[salsa::db(Jar)]
+#[derive(Default)]
+struct Database {
+    storage: salsa::Storage<Self>,
+}
+
+impl salsa::Database for Database {
+    fn salsa_runtime(&self) -> &salsa::Runtime {
+        self.storage.runtime()
+    }
+}
+
+impl Db for Database {}
+
 #[test]
 fn execute() {
-    #[salsa::db(Jar)]
-    #[derive(Default)]
-    struct Database {
-        storage: salsa::Storage<Self>,
-    }
-
-    impl salsa::Database for Database {
-        fn salsa_runtime(&self) -> &salsa::Runtime {
-            self.storage.runtime()
-        }
-    }
-
-    impl Db for Database {}
-
     let mut db = Database::default();
     let input = MyInput::new(&mut db, 22);
     assert_eq!(tracked_fn(&db, input).field(&db), 44);

salsa-2022-tests/tests/tracked_fn_read_own_entity.rs

@@ -0,0 +1,87 @@
+//! Test that a `tracked` fn on a `salsa::input`
+//! compiles and executes successfully.
+#![allow(dead_code)]
+
+use salsa_2022_tests::{HasLogger, Logger};
+
+use expect_test::expect;
+
+#[salsa::jar(db = Db)]
+struct Jar(MyInput, MyTracked, final_result, intermediate_result);
+
+trait Db: salsa::DbWithJar<Jar> + HasLogger {}
+
+#[salsa::input(jar = Jar)]
+struct MyInput {
+    field: u32,
+}
+
+#[salsa::tracked(jar = Jar)]
+fn final_result(db: &dyn Db, input: MyInput) -> u32 {
+    db.push_log(format!("final_result({:?})", input));
+    intermediate_result(db, input).field(db) * 2
+}
+
+#[salsa::tracked(jar = Jar)]
+struct MyTracked {
+    field: u32,
+}
+
+#[salsa::tracked(jar = Jar)]
+fn intermediate_result(db: &dyn Db, input: MyInput) -> MyTracked {
+    db.push_log(format!("intermediate_result({:?})", input));
+    let tracked = MyTracked::new(db, input.field(db) / 2);
+    let _ = tracked.field(db); // read the field of an entity we created
+    tracked
+}
+
+#[salsa::db(Jar)]
+#[derive(Default)]
+struct Database {
+    storage: salsa::Storage<Self>,
+    logger: Logger,
+}
+
+impl salsa::Database for Database {
+    fn salsa_runtime(&self) -> &salsa::Runtime {
+        self.storage.runtime()
+    }
+}
+
+impl Db for Database {}
+
+impl HasLogger for Database {
+    fn logger(&self) -> &Logger {
+        &self.logger
+    }
+}
+
+#[test]
+fn execute() {
+    let mut db = Database::default();
+
+    let input = MyInput::new(&mut db, 22);
+    assert_eq!(final_result(&db, input), 22);
+    db.assert_logs(expect![[r#"
+        [
+            "final_result(MyInput(Id { value: 1 }))",
+            "intermediate_result(MyInput(Id { value: 1 }))",
+        ]"#]]);
+
+    // Intermediate result is the same, so final result does
+    // not need to be recomputed:
+    input.set_field(&mut db, 23);
+    assert_eq!(final_result(&db, input), 22);
+    db.assert_logs(expect![[r#"
+        [
+            "intermediate_result(MyInput(Id { value: 1 }))",
+        ]"#]]);
+
+    input.set_field(&mut db, 24);
+    assert_eq!(final_result(&db, input), 24);
+    db.assert_logs(expect![[r#"
+        [
+            "intermediate_result(MyInput(Id { value: 1 }))",
+            "final_result(MyInput(Id { value: 1 }))",
+        ]"#]]);
+}