Pass CompletedQuery to diff_outputs

Author: MichaReiser

src/function/diff_outputs.rs

@@ -1,8 +1,9 @@
+use crate::active_query::CompletedQuery;
 use crate::function::memo::Memo;
 use crate::function::{Configuration, IngredientImpl};
 use crate::hash::FxIndexSet;
 use crate::zalsa::Zalsa;
-use crate::zalsa_local::{output_edges, QueryOriginRef, QueryRevisions};
+use crate::zalsa_local::{output_edges, QueryOriginRef};
 use crate::{DatabaseKeyIndex, Event, EventKind};
 
 impl<C> IngredientImpl<C>
@@ -16,54 +17,28 @@ where
         zalsa: &Zalsa,
         key: DatabaseKeyIndex,
         old_memo: &Memo<'_, C>,
-        revisions: &QueryRevisions,
-        stale_tracked_structs: Vec<DatabaseKeyIndex>,
+        completed_query: &CompletedQuery,
     ) {
         let (QueryOriginRef::Derived(edges) | QueryOriginRef::DerivedUntracked(edges)) =
             old_memo.revisions.origin.as_ref()
         else {
             return;
         };
 
-        let stale_outputs = output_edges(edges).collect::<FxIndexSet<_>>();
-
-        if stale_tracked_structs.is_empty() && stale_outputs.is_empty() {
-            return;
+        // Note that tracked structs are not stored as direct query outputs, but they are still outputs
+        // that need to be reported as stale.
+        for output in &completed_query.stale_tracked_structs {
+            Self::report_stale_output(zalsa, key, *output);
         }
 
-        Self::diff_outputs_cold(zalsa, key, revisions, stale_outputs, stale_tracked_structs);
-    }
-
-    #[cold]
-    fn diff_outputs_cold(
-        zalsa: &Zalsa,
-        key: DatabaseKeyIndex,
-        revisions: &QueryRevisions,
-        mut stale_outputs: FxIndexSet<DatabaseKeyIndex>,
-        mut stale_tracked_structs: Vec<DatabaseKeyIndex>,
-    ) {
-        if !stale_tracked_structs.is_empty() {
-            // Removing a stale tracked struct ID shows up in the event logs, so make sure
-            // the order is stable here.
-            stale_tracked_structs.sort_unstable_by(|a, b| {
-                a.ingredient_index()
-                    .cmp(&b.ingredient_index())
-                    .then(a.key_index().cmp(&b.key_index()))
-            });
-
-            // Note that tracked structs are not stored as direct query outputs, but they are still outputs
-            // that need to be reported as stale.
-            for output in stale_tracked_structs {
-                Self::report_stale_output(zalsa, key, output);
-            }
-        }
+        let mut stale_outputs = output_edges(edges).collect::<FxIndexSet<_>>();
 
         if stale_outputs.is_empty() {
             return;
         }
 
         // Preserve any outputs that were recreated in the current revision.
-        for new_output in revisions.origin.as_ref().outputs() {
+        for new_output in completed_query.revisions.origin.as_ref().outputs() {
             stale_outputs.swap_remove(&new_output);
         }
 

src/function/execute.rs

@@ -107,13 +107,7 @@ where
 
             // Diff the new outputs with the old, to discard any no-longer-emitted
             // outputs and update the tracked struct IDs for seeding the next revision.
-            self.diff_outputs(
-                zalsa,
-                database_key_index,
-                old_memo,
-                &completed_query.revisions,
-                completed_query.stale_tracked_structs,
-            );
+            self.diff_outputs(zalsa, database_key_index, old_memo, &completed_query);
         }
         self.insert_memo(
             zalsa,

src/function/specify.rs

@@ -1,5 +1,6 @@
 #[cfg(feature = "accumulator")]
 use crate::accumulator::accumulated_map::InputAccumulatedValues;
+use crate::active_query::CompletedQuery;
 use crate::function::memo::Memo;
 use crate::function::{Configuration, IngredientImpl};
 use crate::revision::AtomicRevision;
@@ -63,26 +64,34 @@ where
         // - a result that is NOT verified and has untracked inputs, which will re-execute (and likely panic)
 
         let revision = zalsa.current_revision();
-        let mut revisions = QueryRevisions {
-            changed_at: current_deps.changed_at,
-            durability: current_deps.durability,
-            origin: QueryOrigin::assigned(active_query_key),
-            #[cfg(feature = "accumulator")]
-            accumulated_inputs: Default::default(),
-            verified_final: AtomicBool::new(true),
-            extra: QueryRevisionsExtra::default(),
+        let mut completed_query = CompletedQuery {
+            revisions: QueryRevisions {
+                changed_at: current_deps.changed_at,
+                durability: current_deps.durability,
+                origin: QueryOrigin::assigned(active_query_key),
+                #[cfg(feature = "accumulator")]
+                accumulated_inputs: Default::default(),
+                verified_final: AtomicBool::new(true),
+                extra: QueryRevisionsExtra::default(),
+            },
+            stale_tracked_structs: Vec::new(),
         };
 
         let memo_ingredient_index = self.memo_ingredient_index(zalsa, key);
         if let Some(old_memo) = self.get_memo_from_table_for(zalsa, key, memo_ingredient_index) {
-            self.backdate_if_appropriate(old_memo, database_key_index, &mut revisions, &value);
-            self.diff_outputs(zalsa, database_key_index, old_memo, &revisions, Vec::new());
+            self.backdate_if_appropriate(
+                old_memo,
+                database_key_index,
+                &mut completed_query.revisions,
+                &value,
+            );
+            self.diff_outputs(zalsa, database_key_index, old_memo, &completed_query);
         }
 
         let memo = Memo {
             value: Some(value),
             verified_at: AtomicRevision::from(revision),
-            revisions,
+            revisions: completed_query.revisions,
         };
 
         crate::tracing::debug!(

src/tracked_struct.rs

@@ -347,6 +347,14 @@ impl IdentityMap {
             }
         }
 
+        // Removing a stale tracked struct ID shows up in the event logs, so make sure
+        // the order is stable here.
+        stale.sort_unstable_by(|a, b| {
+            a.ingredient_index()
+                .cmp(&b.ingredient_index())
+                .then(a.key_index().cmp(&b.key_index()))
+        });
+
         (active, stale)
     }