Track revisions for tracked fields only

Author: MichaReiser

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

@@ -50,7 +50,7 @@ macro_rules! setup_tracked_struct {
         // Absolute indices of any untracked fields.
         absolute_untracked_indices: [$($absolute_untracked_index:tt),*],
 
-        // A set of "field options" for each field.
+        // A set of "field options" for each tracked field.
         //
         // Each field option is a tuple `(maybe_clone, maybe_backdate)` where:
         //
@@ -59,16 +59,21 @@ macro_rules! setup_tracked_struct {
         //
         // These are used to drive conditional logic for each field via recursive macro invocation
         // (see e.g. @maybe_clone below).
-        field_options: [$($field_option:tt),*],
-
-        // A set of "field options" for each tracked field.
         tracked_options: [$($tracked_option:tt),*],
 
         // A set of "field options" for each untracked field.
+        //
+        // Each field option is a tuple `(maybe_clone, maybe_backdate)` where:
+        //
+        // * `maybe_clone` is either the identifier `clone` or `no_clone`
+        // * `maybe_backdate` is either the identifier `backdate` or `no_backdate`
+        //
+        // These are used to drive conditional logic for each field via recursive macro invocation
+        // (see e.g. @maybe_clone below).
         untracked_options: [$($untracked_option:tt),*],
 
-        // Number of fields.
-        num_fields: $N:literal,
+        // Number of tracked fields.
+        num_tracked_fields: $N:literal,
 
         // If true, generate a debug impl.
         generate_debug_impl: $generate_debug_impl:tt,
@@ -111,7 +116,7 @@ macro_rules! setup_tracked_struct {
                 ];
 
                 const TRACKED_FIELD_INDICES: &'static [usize] = &[
-                    $($absolute_tracked_index,)*
+                    $($relative_tracked_index,)*
                 ];
 
                 type Fields<$db_lt> = ($($field_ty,)*);
@@ -141,21 +146,33 @@ macro_rules! setup_tracked_struct {
                     revisions: &mut Self::Revisions,
                     old_fields: *mut Self::Fields<$db_lt>,
                     new_fields: Self::Fields<$db_lt>,
-                ) {
+                ) -> bool {
                     use $zalsa::UpdateFallback as _;
                     unsafe {
                         $(
                             $crate::maybe_backdate!(
-                                $field_option,
-                                $field_ty,
-                                (*old_fields).$field_index,
-                                new_fields.$field_index,
-                                revisions[$field_index],
+                                $tracked_option,
+                                $tracked_ty,
+                                (*old_fields).$absolute_tracked_index,
+                                new_fields.$absolute_tracked_index,
+                                revisions[$relative_tracked_index],
                                 current_revision,
                                 $zalsa,
                             );
                         )*
                     }
+
+                    // If any untracked field has changed, return `true`, indicating that the tracked struct
+                    // itself should be considered changed.
+                    unsafe {
+                        $(
+                            $zalsa::UpdateDispatch::<$untracked_ty>::maybe_update(
+                                &mut (*old_fields).$absolute_untracked_index,
+                                new_fields.$absolute_untracked_index,
+                            )
+                            |
+                        )* false
+                    }
                 }
             }
 
@@ -236,7 +253,7 @@ macro_rules! setup_tracked_struct {
                         $Db: ?Sized + $zalsa::Database,
                     {
                         let db = db.as_dyn_database();
-                        let fields = $Configuration::ingredient(db).tracked_field(db, self, $absolute_tracked_index, $relative_tracked_index);
+                        let fields = $Configuration::ingredient(db).tracked_field(db, self, $relative_tracked_index);
                         $crate::maybe_clone!(
                             $tracked_option,
                             $tracked_ty,

components/salsa-macros/src/salsa_struct.rs

@@ -227,6 +227,10 @@ where
         Literal::usize_unsuffixed(self.fields.len())
     }
 
+    pub(crate) fn num_tracked_fields(&self) -> Literal {
+        Literal::usize_unsuffixed(self.tracked_fields_iter().count())
+    }
+
     pub(crate) fn required_fields(&self) -> Vec<TokenStream> {
         self.fields
             .iter()

components/salsa-macros/src/tracked_struct.rs

@@ -101,15 +101,14 @@ impl Macro {
 
         let absolute_untracked_indices = salsa_struct.untracked_field_indices();
 
-        let field_options = salsa_struct.field_options();
         let tracked_options = salsa_struct.tracked_options();
         let untracked_options = salsa_struct.untracked_options();
 
         let field_tys = salsa_struct.field_tys();
         let tracked_tys = salsa_struct.tracked_tys();
         let untracked_tys = salsa_struct.untracked_tys();
 
-        let num_fields = salsa_struct.num_fields();
+        let num_tracked_fields = salsa_struct.num_tracked_fields();
         let generate_debug_impl = salsa_struct.generate_debug_impl();
 
         let zalsa = self.hygiene.ident("zalsa");
@@ -147,11 +146,10 @@ impl Macro {
 
                     absolute_untracked_indices: [#(#absolute_untracked_indices),*],
 
-                    field_options: [#(#field_options),*],
                     tracked_options: [#(#tracked_options),*],
                     untracked_options: [#(#untracked_options),*],
 
-                    num_fields: #num_fields,
+                    num_tracked_fields: #num_tracked_fields,
                     generate_debug_impl: #generate_debug_impl,
                     unused_names: [
                         #zalsa,

src/tracked_struct.rs

@@ -31,13 +31,13 @@ pub trait Configuration: Sized + 'static {
     /// The debug names of any fields.
     const FIELD_DEBUG_NAMES: &'static [&'static str];
 
-    /// The absolute indices of any tracked fields.
+    /// The relative indices of any tracked fields.
     const TRACKED_FIELD_INDICES: &'static [usize];
 
     /// A (possibly empty) tuple of the fields for this struct.
     type Fields<'db>: Send + Sync;
 
-    /// A array of [`Revision`][] values, one per each of the value fields.
+    /// A array of [`Revision`][] values, one per each of the tracked value fields.
     /// When a struct is re-recreated in a new revision, the corresponding
     /// entries for each field are updated to the new revision if their
     /// values have changed (or if the field is marked as `#[no_eq]`).
@@ -62,7 +62,10 @@ pub trait Configuration: Sized + 'static {
     fn new_revisions(current_revision: Revision) -> Self::Revisions;
 
     /// Update the field data and, if the value has changed,
-    /// the appropriate entry in the `revisions` array.
+    /// the appropriate entry in the `revisions` array (for tracked fields only).
+    ///
+    /// Returns `true` if any untracked field was updated and
+    /// the struct should be considered changed.
     ///
     /// # Safety
     ///
@@ -87,7 +90,7 @@ pub trait Configuration: Sized + 'static {
         revisions: &mut Self::Revisions,
         old_fields: *mut Self::Fields<'db>,
         new_fields: Self::Fields<'db>,
-    );
+    ) -> bool;
 }
 // ANCHOR_END: Configuration
 
@@ -114,14 +117,16 @@ impl<C: Configuration> Jar for JarImpl<C> {
     ) -> Vec<Box<dyn Ingredient>> {
         let struct_ingredient = <IngredientImpl<C>>::new(struct_index);
 
-        let tracked_field_ingredients = C::TRACKED_FIELD_INDICES.iter().enumerate().map(
-            |(relative_tracked_index, &field_index)| {
-                Box::new(<FieldIngredientImpl<C>>::new(
-                    field_index,
-                    struct_index.successor(relative_tracked_index),
-                )) as _
-            },
-        );
+        let tracked_field_ingredients =
+            C::TRACKED_FIELD_INDICES
+                .iter()
+                .copied()
+                .map(|relative_tracked_index| {
+                    Box::new(<FieldIngredientImpl<C>>::new(
+                        relative_tracked_index,
+                        struct_index.successor(relative_tracked_index),
+                    )) as _
+                });
 
         std::iter::once(Box::new(struct_ingredient) as _)
             .chain(tracked_field_ingredients)
@@ -398,7 +403,7 @@ where
             Some(id) => {
                 // The struct already exists in the intern map.
                 zalsa_local.add_output(self.database_key_index(id).into());
-                self.update(zalsa, current_revision, id, &current_deps, fields);
+                self.update_fields(zalsa, current_revision, id, &current_deps, fields);
                 C::struct_from_id(id)
             }
 
@@ -457,7 +462,7 @@ where
     ///
     /// * If the value is not present in the map.
     /// * If the value is already updated in this revision.
-    fn update<'db>(
+    fn update_fields<'db>(
         &'db self,
         zalsa: &'db Zalsa,
         current_revision: Revision,
@@ -535,15 +540,18 @@ where
         // its validity invariant and any owned content also continues
         // to meet its safety invariant.
         unsafe {
-            C::update_fields(
+            if C::update_fields(
                 current_revision,
                 &mut data.revisions,
                 self.to_self_ptr(std::ptr::addr_of_mut!(data.fields)),
                 fields,
-            );
+            ) {
+                data.created_at = current_revision;
+            }
         }
         if current_deps.durability < data.durability {
             data.revisions = C::new_revisions(current_revision);
+            data.created_at = current_revision;
         }
         data.durability = current_deps.durability;
         let swapped_out = data.updated_at.swap(Some(current_revision));
@@ -649,7 +657,6 @@ where
         &'db self,
         db: &'db dyn crate::Database,
         s: C::Struct<'db>,
-        field_index: usize,
         relative_tracked_index: usize,
     ) -> &'db C::Fields<'db> {
         let (zalsa, zalsa_local) = db.zalsas();
@@ -659,7 +666,7 @@ where
 
         data.read_lock(zalsa.current_revision());
 
-        let field_changed_at = data.revisions[field_index];
+        let field_changed_at = data.revisions[relative_tracked_index];
 
         zalsa_local.report_tracked_read(
             InputDependencyIndex::new(field_ingredient_index, id),