Implement inputs builder

Author: MichaReiser

components/salsa-macro-rules/src/setup_input_struct.rs

@@ -48,6 +48,7 @@ macro_rules! setup_input_struct {
             $zalsa:ident,
             $zalsa_struct:ident,
             $Configuration:ident,
+            $Builder:ident,
             $CACHE:ident,
             $Db:ident,
         ]
@@ -121,14 +122,33 @@ macro_rules! setup_input_struct {
             }
 
             impl $Struct {
+                #[inline]
                 pub fn $new_fn<$Db>(db: &$Db, $($field_id: $field_ty),*) -> Self
                 where
                     // FIXME(rust-lang/rust#65991): The `db` argument *should* have the type `dyn Database`
                     $Db: ?Sized + salsa::Database,
                 {
-                    let current_revision = $zalsa::current_revision(db);
-                    let stamps = $zalsa::Array::new([$zalsa::stamp(current_revision, Default::default()); $N]);
-                    $Configuration::ingredient(db.as_salsa_database()).new_input(($($field_id,)*), stamps)
+                    Self::builder($($field_id,)*).new(db)
+                }
+
+                pub fn builder($($field_id: $field_ty),*) -> <Self as $zalsa_struct::HasBuilder>::Builder
+                {
+                    // Implement `new` here instead of inside the builder module
+                    // because $Configuration can't be named in `builder`.
+                    impl builder::$Builder {
+                        pub fn new<$Db>(self, db: &$Db) -> $Struct
+                        where
+                            // FIXME(rust-lang/rust#65991): The `db` argument *should* have the type `dyn Database`
+                            $Db: ?Sized + salsa::Database
+                        {
+                            let current_revision = $zalsa::current_revision(db);
+                            let ingredient = $Configuration::ingredient(db.as_salsa_database());
+                            let (fields, stamps) = builder::builder_into_inner(self, current_revision);
+                            ingredient.new_input(fields, stamps)
+                        }
+                    }
+
+                    builder::new_builder($($field_id,)*)
                 }
 
                 $(
@@ -204,6 +224,40 @@ macro_rules! setup_input_struct {
                     })
                 }
             }
+
+            mod builder {
+                use super::*;
+                use salsa::plumbing as $zalsa;
+                use $zalsa::input as $zalsa_struct;
+
+                impl $zalsa_struct::HasBuilder for $Struct {
+                    type Builder = $Builder;
+                }
+
+                // These are standalone functions instead of methods on `Builder` to prevent
+                // that the enclosing module can call them.
+                pub(super) fn new_builder($($field_id: $field_ty),*) -> $Builder {
+                    $Builder { fields: ($($field_id,)*), durability: $zalsa::Durability::default() }
+                }
+
+                pub(super) fn builder_into_inner(builder: $Builder, revision: $zalsa::Revision) -> (($($field_ty,)*), $zalsa::Array<$zalsa::Stamp, $N>) {
+                    let stamps = $zalsa::Array::new([$zalsa::stamp(revision, builder.durability); $N]);
+                    (builder.fields, stamps)
+                }
+
+                pub struct $Builder {
+                    fields: ($($field_ty,)*),
+                    durability: $zalsa::Durability,
+                }
+
+                impl $Builder {
+                    /// Sets the durability of all fields
+                    pub fn durability(mut self, durability: $zalsa::Durability) -> Self {
+                        self.durability = durability;
+                        self
+                    }
+                }
+            }
         };
     };
 }

components/salsa-macro-rules/src/setup_struct_fn.rs

@@ -93,6 +93,7 @@ impl Macro {
         let zalsa = self.hygiene.ident("zalsa");
         let zalsa_struct = self.hygiene.ident("zalsa_struct");
         let Configuration = self.hygiene.ident("Configuration");
+        let Builder = self.hygiene.ident("Builder");
         let CACHE = self.hygiene.ident("CACHE");
         let Db = self.hygiene.ident("Db");
 
@@ -117,6 +118,7 @@ impl Macro {
                         #zalsa,
                         #zalsa_struct,
                         #Configuration,
+                        #Builder,
                         #CACHE,
                         #Db,
                     ]

components/salsa-macros/src/input.rs

@@ -0,0 +1,41 @@
+use super::{Configuration, IngredientImpl};
+use crate::array::Array;
+use crate::runtime::{stamp, StampedValue};
+use crate::{array, Durability, Revision};
+
+pub trait HasBuilder {
+    type Builder;
+}
+
+#[derive(Debug)]
+pub struct BuilderImpl<Fields> {
+    fields: Fields,
+    durability: Durability,
+}
+
+impl<F> BuilderImpl<F> {
+    /// Creates a new builder.
+    pub fn create(fields: F) -> Self {
+        Self {
+            fields,
+            durability: Durability::default(),
+        }
+    }
+
+    /// Sets the durability of all fields
+    pub fn durability(&mut self, durability: Durability) {
+        self.durability = durability;
+    }
+
+    pub fn new<const N: usize, C>(
+        self,
+        revision: Revision,
+        ingredient: &IngredientImpl<C>,
+    ) -> C::Struct
+    where
+        C: Configuration<Fields = F, Stamps = array::Array<StampedValue<()>, N>>,
+    {
+        let stamps = Array::new([stamp(revision, self.durability); N]);
+        ingredient.new_input(self.fields, stamps)
+    }
+}

src/input/builder.rs

@@ -106,6 +106,7 @@ pub mod plumbing {
     pub use crate::update::helper::Dispatch as UpdateDispatch;
     pub use crate::update::helper::Fallback as UpdateFallback;
     pub use crate::update::Update;
+    pub use crate::Durability;
 
     pub use salsa_macro_rules::macro_if;
     pub use salsa_macro_rules::maybe_backdate;
@@ -125,6 +126,7 @@ pub mod plumbing {
     }
 
     pub mod input {
+        pub use crate::input::{HasBuilder};
         pub use crate::input::input_field::FieldIngredientImpl;
         pub use crate::input::setter::SetterImpl;
         pub use crate::input::Configuration;

src/lib.rs

@@ -2,13 +2,13 @@
 //! Then mutate the values so that the tracked function re-executes.
 //! Check that we accumulate the appropriate, new values.
 
-mod common;
-use common::{HasLogger, Logger};
-
 use expect_test::expect;
-use salsa::{Accumulator, Setter};
 use test_log::test;
 
+use common::{HasLogger, Logger};
+use salsa::{Accumulator, Setter};
+
+mod common;
 #[salsa::db]
 trait Db: salsa::Database + HasLogger {}
 

tests/accumulate-from-tracked-fn.rs

@@ -0,0 +1,77 @@
+//! Test that a `tracked` fn on a `salsa::input`
+//! compiles and executes successfully.
+#![allow(warnings)]
+
+use expect_test::expect;
+
+use common::{HasLogger, Logger};
+use salsa::plumbing::HasStorage;
+use salsa::{Database, Durability, Event, EventKind, Setter};
+
+mod common;
+#[salsa::input]
+struct MyInput {
+    field: u32,
+}
+
+#[salsa::tracked]
+fn tracked_fn(db: &dyn salsa::Database, input: MyInput) -> u32 {
+    input.field(db) * 2
+}
+
+#[test]
+fn execute() {
+    #[salsa::db]
+    #[derive(Default)]
+    struct Database {
+        storage: salsa::Storage<Self>,
+        logger: Logger,
+    }
+
+    #[salsa::db]
+    impl salsa::Database for Database {
+        fn salsa_event(&self, event: Event) {
+            match event.kind {
+                EventKind::WillCheckCancellation => {}
+                _ => {
+                    self.push_log(format!("salsa_event({:?})", event.kind));
+                }
+            }
+        }
+    }
+
+    impl HasLogger for Database {
+        fn logger(&self) -> &Logger {
+            &self.logger
+        }
+    }
+
+    let mut db = Database::default();
+    let input_low = MyInput::new(&db, 22);
+    let input_high = MyInput::builder(2200).durability(Durability::HIGH).new(&db);
+
+    assert_eq!(tracked_fn(&db, input_low), 44);
+    assert_eq!(tracked_fn(&db, input_high), 4400);
+
+    db.assert_logs(expect![[r#"
+        [
+            "salsa_event(WillExecute { database_key: tracked_fn(0) })",
+            "salsa_event(WillExecute { database_key: tracked_fn(1) })",
+        ]"#]]);
+
+    db.synthetic_write(Durability::LOW);
+
+    assert_eq!(tracked_fn(&db, input_low), 44);
+    assert_eq!(tracked_fn(&db, input_high), 4400);
+
+    // There's currently no good way to verify whether an input was validated using shallow or deep comparison.
+    // All we can do for now is verify that the values were validated.
+    // Note: It maybe confusing why it validates `input_high` when the write has `Durability::LOW`.
+    // This is because all values must be validated whenever a write occurs. It doesn't mean that it
+    // executed the query.
+    db.assert_logs(expect![[r#"
+        [
+            "salsa_event(DidValidateMemoizedValue { database_key: tracked_fn(0) })",
+            "salsa_event(DidValidateMemoizedValue { database_key: tracked_fn(1) })",
+        ]"#]]);
+}