remove DirtyState

Author: sokra

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

@@ -567,9 +567,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                 }
             }
 
-            let is_dirty = task
-                .dirty_state()
-                .map_or(false, |dirty_state| dirty_state.get(self.session_id));
+            let is_dirty = task.is_dirty(self.session_id);
 
             // Check the dirty count of the root node
             let dirty_tasks = get!(task, AggregatedDirtyContainerCount)
@@ -625,9 +623,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                             visited: &mut FxHashSet<TaskId>,
                         ) -> String {
                             let task = ctx.task(task_id, TaskDataCategory::Data);
-                            let is_dirty = task
-                                .dirty_state()
-                                .map_or(false, |dirty_state| dirty_state.get(ctx.session_id()));
+                            let is_dirty = task.is_dirty(ctx.session_id());
                             let in_progress =
                                 get!(task, InProgress).map_or("not in progress", |p| match p {
                                     InProgressState::InProgress(_) => "in progress",
@@ -2892,9 +2888,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
 
         let mut ctx = self.execute_context(turbo_tasks);
         let mut task = ctx.task(task_id, TaskDataCategory::All);
-        let is_dirty = task
-            .dirty_state()
-            .map_or(false, |dirty| dirty.get(self.session_id));
+        let is_dirty = task.is_dirty(self.session_id);
         let has_dirty_containers = get!(task, AggregatedDirtyContainerCount)
             .map_or(false, |dirty_containers| {
                 dirty_containers.get(self.session_id) > 0
@@ -2987,9 +2981,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
                     }
                 }
 
-                let is_dirty = task
-                    .dirty_state()
-                    .is_some_and(|dirty| dirty.get(self.session_id));
+                let is_dirty = task.is_dirty(self.session_id);
                 let has_dirty_container = get!(task, AggregatedDirtyContainerCount)
                     .is_some_and(|count| count.get(self.session_id) > 0);
                 let should_be_in_upper = is_dirty || has_dirty_container;

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

@@ -1209,7 +1209,7 @@ impl AggregationUpdateQueue {
     ) {
         let session_id = ctx.session_id();
         // Task need to be scheduled if it's dirty or doesn't have output
-        let dirty = task.dirty_state().map_or(false, |d| d.get(session_id));
+        let dirty = task.is_dirty(session_id);
         let should_schedule = if dirty {
             Some(TaskExecutionReason::ActivateDirty)
         } else if !task.has_key(&CachedDataItemKey::Output {}) {

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

@@ -25,7 +25,7 @@ use crate::{
     backing_storage::BackingStorage,
     data::{
         CachedDataItem, CachedDataItemKey, CachedDataItemType, CachedDataItemValue,
-        CachedDataItemValueRef, CachedDataItemValueRefMut, DirtyState, Dirtyness,
+        CachedDataItemValueRef, CachedDataItemValueRefMut, Dirtyness,
     },
 };
 
@@ -415,6 +415,12 @@ pub trait TaskGuard: Debug {
     fn invalidate_serialization(&mut self);
     fn prefetch(&mut self) -> Option<FxIndexMap<TaskId, bool>>;
     fn is_immutable(&self) -> bool;
+    fn is_dirty(&self, session_id: SessionId) -> bool {
+        get!(self, Dirty).is_some_and(|dirtyness| match dirtyness {
+            Dirtyness::Dirty => true,
+            Dirtyness::SessionDependent => get!(self, CleanInSession).copied() != Some(session_id),
+        })
+    }
     fn dirtyness_and_session(&self) -> Option<(Dirtyness, Option<SessionId>)> {
         match get!(self, Dirty)? {
             Dirtyness::Dirty => Some((Dirtyness::Dirty, None)),
@@ -424,21 +430,6 @@ pub trait TaskGuard: Debug {
             )),
         }
     }
-    fn dirty_state(&self) -> Option<DirtyState> {
-        match get!(self, Dirty)? {
-            Dirtyness::Dirty => Some(DirtyState {
-                clean_in_session: None,
-            }),
-            Dirtyness::SessionDependent => match get!(self, CleanInSession) {
-                None => Some(DirtyState {
-                    clean_in_session: None,
-                }),
-                Some(session) => Some(DirtyState {
-                    clean_in_session: Some(*session),
-                }),
-            },
-        }
-    }
 }
 
 pub struct TaskGuardImpl<'a, B: BackingStorage> {

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

@@ -149,17 +149,6 @@ pub enum Dirtyness {
     SessionDependent,
 }
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
-pub struct DirtyState {
-    pub clean_in_session: Option<SessionId>,
-}
-
-impl DirtyState {
-    pub fn get(&self, session: SessionId) -> bool {
-        self.clean_in_session != Some(session)
-    }
-}
-
 fn add_with_diff(v: &mut i32, u: i32) -> i32 {
     let old = *v;
     *v += u;