migrate to new methods

Author: sokra

turbopack/crates/turbo-tasks-backend/src/backend/operation/aggregation_update.rs

@@ -323,18 +323,18 @@ impl AggregatedDataUpdate {
             );
 
             if !aggregated_update.is_zero() {
-                let dirty_state = task.dirty_state();
+                let dirtyness_and_session = task.dirtyness_and_session();
                 let task_id = task.id();
                 update!(task, AggregatedDirtyContainerCount, |old: Option<
                     DirtyContainerCount,
                 >| {
                     let mut new = old.unwrap_or_default();
-                    if let Some(dirty_state) = dirty_state {
-                        new.update_with_dirty_state(&dirty_state);
+                    if let Some((dirtyness, clean_in_session)) = dirtyness_and_session {
+                        new.update_with_dirtyness_and_session(dirtyness, clean_in_session);
                     }
                     let aggregated_update = new.update_count(&aggregated_update);
-                    if let Some(dirty_state) = dirty_state {
-                        new.undo_update_with_dirty_state(&dirty_state);
+                    if let Some((dirtyness, clean_in_session)) = dirtyness_and_session {
+                        new.undo_update_with_dirtyness_and_session(dirtyness, clean_in_session);
                     }
                     if !aggregated_update.is_zero() {
                         result.dirty_container_update = Some((task_id, aggregated_update));

turbopack/crates/turbo-tasks-backend/src/backend/operation/invalidate.rs

@@ -14,8 +14,8 @@ use crate::{
         storage::{get, get_mut, remove},
     },
     data::{
-        CachedDataItem, CachedDataItemKey, CachedDataItemValue, DirtyState, Dirtyness,
-        InProgressState, InProgressStateInner,
+        CachedDataItem, CachedDataItemKey, CachedDataItemValue, Dirtyness, InProgressState,
+        InProgressStateInner,
     },
 };
 
@@ -294,9 +294,8 @@ pub fn make_task_dirty_internal(
     .entered();
 
     let should_schedule = {
-        let aggregated_update = dirty_container.update_with_dirty_state(&DirtyState {
-            clean_in_session: None,
-        });
+        let aggregated_update =
+            dirty_container.update_with_dirtyness_and_session(Dirtyness::Dirty, None);
         if !aggregated_update.is_zero() {
             queue.extend(AggregationUpdateJob::data_update(
                 &mut task,

turbopack/crates/turbo-tasks-backend/src/data.rs

@@ -257,15 +257,6 @@ impl DirtyContainerCount {
         diff
     }
 
-    /// Applies a dirty state to the count. Returns an aggregated count that represents the change.
-    pub fn update_with_dirty_state(&mut self, dirty: &DirtyState) -> DirtyContainerCount {
-        if let Some(clean_in_session) = dirty.clean_in_session {
-            self.update_session_dependent(clean_in_session, 1)
-        } else {
-            self.update(1)
-        }
-    }
-
     /// Applies a dirtyness to the count. Returns an aggregated count that represents the change.
     pub fn update_with_dirtyness_and_session(
         &mut self,
@@ -279,16 +270,6 @@ impl DirtyContainerCount {
         }
     }
 
-    /// Undoes the effect of a dirty state on the count. Returns an aggregated count that represents
-    /// the change.
-    pub fn undo_update_with_dirty_state(&mut self, dirty: &DirtyState) -> DirtyContainerCount {
-        if let Some(clean_in_session) = dirty.clean_in_session {
-            self.update_session_dependent(clean_in_session, -1)
-        } else {
-            self.update(-1)
-        }
-    }
-
     /// Undoes the effect of a dirtyness on the count. Returns an aggregated count that represents
     /// the change.
     pub fn undo_update_with_dirtyness_and_session(
@@ -303,18 +284,6 @@ impl DirtyContainerCount {
         }
     }
 
-    /// Replaces the old dirty state with the new one. Returns an aggregated count that represents
-    /// the change.
-    pub fn replace_dirty_state(
-        &mut self,
-        old: &DirtyState,
-        new: &DirtyState,
-    ) -> DirtyContainerCount {
-        let mut diff = self.undo_update_with_dirty_state(old);
-        diff.update_count(&self.update_with_dirty_state(new));
-        diff
-    }
-
     /// Replaces the old dirtyness with the new one. Returns an aggregated count that represents
     /// the change.
     pub fn replace_dirtyness_and_session(
@@ -462,37 +431,33 @@ mod dirty_container_count_tests {
     }
 
     #[test]
-    fn test_update_with_dirty_state() {
+    fn test_update_with_dirtyness_and_session() {
         let mut count = DirtyContainerCount::default();
-        let dirty = DirtyState {
-            clean_in_session: None,
-        };
-        let diff = count.update_with_dirty_state(&dirty);
+        let diff = count.update_with_dirtyness_and_session(Dirtyness::Dirty, None);
         assert!(!count.is_zero());
         assert_eq!(count.get(SESSION_1), 1);
         assert_eq!(diff.get(SESSION_1), 1);
         assert_eq!(count.get(SESSION_2), 1);
         assert_eq!(diff.get(SESSION_2), 1);
 
-        let diff = count.undo_update_with_dirty_state(&dirty);
+        let diff = count.undo_update_with_dirtyness_and_session(Dirtyness::Dirty, None);
         assert!(count.is_zero());
         assert_eq!(count.get(SESSION_1), 0);
         assert_eq!(diff.get(SESSION_1), -1);
         assert_eq!(count.get(SESSION_2), 0);
         assert_eq!(diff.get(SESSION_2), -1);
 
         let mut count = DirtyContainerCount::default();
-        let dirty = DirtyState {
-            clean_in_session: Some(SESSION_1),
-        };
-        let diff = count.update_with_dirty_state(&dirty);
+        let diff =
+            count.update_with_dirtyness_and_session(Dirtyness::SessionDependent, Some(SESSION_1));
         assert!(!count.is_zero());
         assert_eq!(count.get(SESSION_1), 0);
         assert_eq!(diff.get(SESSION_1), 0);
         assert_eq!(count.get(SESSION_2), 1);
         assert_eq!(diff.get(SESSION_2), 1);
 
-        let diff = count.undo_update_with_dirty_state(&dirty);
+        let diff = count
+            .undo_update_with_dirtyness_and_session(Dirtyness::SessionDependent, Some(SESSION_1));
         assert!(count.is_zero());
         assert_eq!(count.get(SESSION_1), 0);
         assert_eq!(diff.get(SESSION_1), 0);
@@ -501,31 +466,29 @@ mod dirty_container_count_tests {
     }
 
     #[test]
-    fn test_replace_dirty_state() {
+    fn test_replace_dirtyness_and_session() {
         let mut count = DirtyContainerCount::default();
-        let old = DirtyState {
-            clean_in_session: None,
-        };
-        let new = DirtyState {
-            clean_in_session: Some(SESSION_1),
-        };
-        count.update_with_dirty_state(&old);
-        let diff = count.replace_dirty_state(&old, &new);
+        count.update_with_dirtyness_and_session(Dirtyness::Dirty, None);
+        let diff = count.replace_dirtyness_and_session(
+            Dirtyness::Dirty,
+            None,
+            Dirtyness::SessionDependent,
+            Some(SESSION_1),
+        );
         assert!(!count.is_zero());
         assert_eq!(count.get(SESSION_1), 0);
         assert_eq!(diff.get(SESSION_1), -1);
         assert_eq!(count.get(SESSION_2), 1);
         assert_eq!(diff.get(SESSION_2), 0);
 
         let mut count = DirtyContainerCount::default();
-        let old = DirtyState {
-            clean_in_session: Some(SESSION_1),
-        };
-        let new = DirtyState {
-            clean_in_session: None,
-        };
-        count.update_with_dirty_state(&old);
-        let diff = count.replace_dirty_state(&old, &new);
+        count.update_with_dirtyness_and_session(Dirtyness::SessionDependent, Some(SESSION_1));
+        let diff = count.replace_dirtyness_and_session(
+            Dirtyness::SessionDependent,
+            Some(SESSION_1),
+            Dirtyness::Dirty,
+            None,
+        );
         assert!(!count.is_zero());
         assert_eq!(count.get(SESSION_1), 1);
         assert_eq!(diff.get(SESSION_1), 1);