Rename DisambiguationKey to IdentityHash, KeyStruct to Identity

src/active_query.rs

@@ -1,13 +1,13 @@
 use rustc_hash::FxHashMap;
 
 use super::zalsa_local::{EdgeKind, QueryEdges, QueryOrigin, QueryRevisions};
-use crate::tracked_struct::DisambiguationKey;
+use crate::tracked_struct::IdentityHash;
 use crate::{
     accumulator::accumulated_map::AccumulatedMap,
     durability::Durability,
     hash::FxIndexSet,
     key::{DatabaseKeyIndex, DependencyIndex},
-    tracked_struct::{Disambiguator, KeyStruct},
+    tracked_struct::{Disambiguator, Identity},
     zalsa_local::EMPTY_DEPENDENCIES,
     Cycle, Id, Revision,
 };
@@ -45,11 +45,11 @@ pub(crate) struct ActiveQuery {
     /// This table starts empty as the query begins and is gradually populated.
     /// Note that if a query executes in 2 different revisions but creates the same
     /// set of tracked structs, they will get the same disambiguator values.
-    disambiguator_map: FxHashMap<DisambiguationKey, Disambiguator>,
+    disambiguator_map: FxHashMap<IdentityHash, Disambiguator>,
 
     /// Map from tracked struct keys (which include the hash + disambiguator) to their
     /// final id.
-    pub(crate) tracked_struct_ids: FxHashMap<KeyStruct, Id>,
+    pub(crate) tracked_struct_ids: FxHashMap<Identity, Id>,
 
     /// Stores the values accumulated to the given ingredient.
     /// The type of accumulated value is erased but known to the ingredient.
@@ -155,7 +155,7 @@ impl ActiveQuery {
         self.input_outputs.clone_from(&cycle_query.input_outputs);
     }
 
-    pub(super) fn disambiguate(&mut self, key: DisambiguationKey) -> Disambiguator {
+    pub(super) fn disambiguate(&mut self, key: IdentityHash) -> Disambiguator {
         let disambiguator = self
             .disambiguator_map
             .entry(key)

src/tracked_struct.rs

@@ -147,18 +147,18 @@ where
 /// stored in the [`ActiveQuery`](`crate::active_query::ActiveQuery`)
 /// struct and later moved to the [`Memo`](`crate::function::memo::Memo`).
 #[derive(Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Copy, Clone)]
-pub(crate) struct KeyStruct {
-    /// Tracked struct key
-    disambiguation_key: DisambiguationKey,
+pub(crate) struct Identity {
+    /// Hash of fields with id attribute
+    identity_hash: IdentityHash,
 
     /// The unique disambiguator assigned within the active query
-    /// to distinguish distinct tracked structs with the same key.
+    /// to distinguish distinct tracked structs with the same identity_hash.
     disambiguator: Disambiguator,
 }
 
-impl KeyStruct {
+impl Identity {
     pub(crate) fn ingredient_index(&self) -> IngredientIndex {
-        self.disambiguation_key.ingredient_index
+        self.identity_hash.ingredient_index
     }
 }
 
@@ -168,7 +168,7 @@ impl KeyStruct {
 /// allowing for multiple tracked structs with the same hash and ingredient_index
 /// created within the query to each have a unique id.
 #[derive(Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Copy, Clone)]
-pub struct DisambiguationKey {
+pub struct IdentityHash {
     /// Index of the tracked struct ingredient.
     ingredient_index: IngredientIndex,
 
@@ -274,20 +274,21 @@ where
     ) -> C::Struct<'db> {
         let (zalsa, zalsa_local) = db.zalsas();
 
-        let disambiguation_key = DisambiguationKey {
+        let identity_hash = IdentityHash {
             ingredient_index: self.ingredient_index,
             hash: crate::hash::hash(&C::id_fields(&fields)),
         };
 
-        let (current_deps, disambiguator) = zalsa_local.disambiguate(disambiguation_key);
+        let (current_deps, disambiguator) = zalsa_local.disambiguate(identity_hash);
+
+        let identity = Identity {
+            identity_hash,
 
-        let key_struct = KeyStruct {
-            disambiguation_key,
             disambiguator,
         };
 
         let current_revision = zalsa.current_revision();
-        match zalsa_local.tracked_struct_id(&key_struct) {
+        match zalsa_local.tracked_struct_id(&identity) {
             Some(id) => {
                 // The struct already exists in the intern map.
                 zalsa_local.add_output(self.database_key_index(id).into());
@@ -300,7 +301,7 @@ where
                 let id = self.allocate(zalsa, zalsa_local, current_revision, &current_deps, fields);
                 let key = self.database_key_index(id);
                 zalsa_local.add_output(key.into());
-                zalsa_local.store_tracked_struct_id(key_struct, id);
+                zalsa_local.store_tracked_struct_id(identity, id);
                 C::struct_from_id(id)
             }
         }

src/zalsa_local.rs

@@ -10,8 +10,7 @@ use crate::runtime::StampedValue;
 use crate::table::PageIndex;
 use crate::table::Slot;
 use crate::table::Table;
-use crate::tracked_struct::KeyStruct;
-use crate::tracked_struct::{DisambiguationKey, Disambiguator};
+use crate::tracked_struct::{Disambiguator, Identity, IdentityHash};
 use crate::zalsa::IngredientIndex;
 use crate::Accumulator;
 use crate::Cancelled;
@@ -262,7 +261,7 @@ impl ZalsaLocal {
     ///   * the current dependencies (durability, changed_at) of current query
     ///   * the disambiguator index
     #[track_caller]
-    pub(crate) fn disambiguate(&self, key: DisambiguationKey) -> (StampedValue<()>, Disambiguator) {
+    pub(crate) fn disambiguate(&self, key: IdentityHash) -> (StampedValue<()>, Disambiguator) {
         assert!(
             self.query_in_progress(),
             "cannot create a tracked struct disambiguator outside of a tracked function"
@@ -283,7 +282,7 @@ impl ZalsaLocal {
     }
 
     #[track_caller]
-    pub(crate) fn tracked_struct_id(&self, key_struct: &KeyStruct) -> Option<Id> {
+    pub(crate) fn tracked_struct_id(&self, identity: &Identity) -> Option<Id> {
         debug_assert!(
             self.query_in_progress(),
             "cannot create a tracked struct disambiguator outside of a tracked function"
@@ -291,22 +290,22 @@ impl ZalsaLocal {
 
         self.with_query_stack(|stack| {
             let top_query = stack.last().unwrap();
-            top_query.tracked_struct_ids.get(key_struct).copied()
+            top_query.tracked_struct_ids.get(identity).copied()
         })
     }
 
     #[track_caller]
-    pub(crate) fn store_tracked_struct_id(&self, key_struct: KeyStruct, id: Id) {
+    pub(crate) fn store_tracked_struct_id(&self, identity: Identity, id: Id) {
         debug_assert!(
             self.query_in_progress(),
             "cannot create a tracked struct disambiguator outside of a tracked function"
         );
         self.with_query_stack(|stack| {
             let top_query = stack.last_mut().unwrap();
-            let old_id = top_query.tracked_struct_ids.insert(key_struct, id);
+            let old_id = top_query.tracked_struct_ids.insert(identity, id);
             assert!(
                 old_id.is_none(),
-                "overwrote a previous id for `{key_struct:?}`"
+                "overwrote a previous id for `{identity:?}`"
             );
         })
     }
@@ -375,7 +374,7 @@ pub(crate) struct QueryRevisions {
     ///   previous revision. To handle this, `diff_outputs` compares
     ///   the structs from the old/new revision and retains
     ///   only entries that appeared in the new revision.
-    pub(super) tracked_struct_ids: FxHashMap<KeyStruct, Id>,
+    pub(super) tracked_struct_ids: FxHashMap<Identity, Id>,
 
     pub(super) accumulated: AccumulatedMap,
 }
@@ -534,7 +533,7 @@ impl ActiveQueryGuard<'_> {
     }
 
     /// Initialize the tracked struct ids with the values from the prior execution.
-    pub(crate) fn seed_tracked_struct_ids(&self, tracked_struct_ids: &FxHashMap<KeyStruct, Id>) {
+    pub(crate) fn seed_tracked_struct_ids(&self, tracked_struct_ids: &FxHashMap<Identity, Id>) {
         self.local_state.with_query_stack(|stack| {
             assert_eq!(stack.len(), self.push_len);
             let frame = stack.last_mut().unwrap();