statefulness is important to track

Author: lukesandberg

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

@@ -1887,6 +1887,10 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
             )));
             debug_assert!(old.is_none(), "InProgress already exists");
 
+            // Reset session-stateful flag; it will be re-set during execution if the task
+            // still writes session-stateful cells.
+            task.set_has_session_stateful_cells(false);
+
             // Make all current collectibles outdated (remove left-over outdated collectibles)
             enum Collectible {
                 Current(CollectibleRef, i32),
@@ -3045,6 +3049,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
         task_id: TaskId,
         cell: CellId,
         is_serializable_cell_content: bool,
+        is_session_stateful: bool,
         content: CellContent,
         updated_key_hashes: Option<SmallVec<[u64; 2]>>,
         verification_mode: VerificationMode,
@@ -3055,6 +3060,7 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
             cell,
             content,
             is_serializable_cell_content,
+            is_session_stateful,
             updated_key_hashes,
             verification_mode,
             self.execute_context(turbo_tasks),
@@ -3607,6 +3613,7 @@ impl<B: BackingStorage> Backend for TurboTasksBackend<B> {
         task_id: TaskId,
         cell: CellId,
         is_serializable_cell_content: bool,
+        is_session_stateful: bool,
         content: CellContent,
         updated_key_hashes: Option<SmallVec<[u64; 2]>>,
         verification_mode: VerificationMode,
@@ -3616,6 +3623,7 @@ impl<B: BackingStorage> Backend for TurboTasksBackend<B> {
             task_id,
             cell,
             is_serializable_cell_content,
+            is_session_stateful,
             content,
             updated_key_hashes,
             verification_mode,

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

@@ -55,6 +55,7 @@ impl UpdateCellOperation {
         cell: CellId,
         content: CellContent,
         is_serializable_cell_content: bool,
+        is_session_stateful: bool,
         updated_key_hashes: Option<SmallVec<[u64; 2]>>,
         #[cfg(feature = "verify_determinism")] verification_mode: VerificationMode,
         #[cfg(not(feature = "verify_determinism"))] _verification_mode: VerificationMode,
@@ -68,6 +69,10 @@ impl UpdateCellOperation {
 
         let mut task = ctx.task(task_id, TaskDataCategory::All);
 
+        if is_session_stateful {
+            task.set_has_session_stateful_cells(true);
+        }
+
         // We need to detect recomputation, because here the content has not actually changed (even
         // if it's not equal to the old content, as not all values implement Eq). We have to
         // assume that tasks are deterministic and pure.

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

@@ -187,6 +187,12 @@ struct TaskStorageSchema {
     #[field(storage = "flag", category = "transient")]
     stateful: bool,
 
+    /// Whether this task has cells containing session-stateful values (values with
+    /// non-serializable interior state that accumulates during a session). Tasks with
+    /// this flag set cannot be evicted mid-session.
+    #[field(storage = "flag", category = "transient")]
+    has_session_stateful_cells: bool,
+
     // =========================================================================
     // CHILDREN & AGGREGATION (meta)
     // =========================================================================
@@ -391,7 +397,9 @@ pub enum UnevictableReason {
     TransientData,
     TransientUppers,
     SessionState,
+    SessionStateful,
     Modified,
+    NothingToEvict,
 }
 
 /// Eviction level for a task after a snapshot.
@@ -447,7 +455,11 @@ impl TaskStorage {
             && !flags.data_modified()
             && !flags.data_modified_during_snapshot();
         if !data_evictable {
-            return Evictability::No(UnevictableReason::Modified);
+            return Evictability::No(if flags.data_restored() {
+                UnevictableReason::Modified
+            } else {
+                UnevictableReason::NothingToEvict
+            });
         }
 
         // Data-category fields with `filter_transient` lose entries referencing transient
@@ -497,6 +509,9 @@ impl TaskStorage {
         {
             return Evictability::No(UnevictableReason::SessionState);
         }
+        if flags.has_session_stateful_cells() {
+            return Evictability::No(UnevictableReason::SessionStateful);
+        }
         if meta_evictable {
             // Session-dependent tasks have transient state (current_session_clean flag,
             // Dirtyness::SessionDependent) that would be lost on full eviction.

turbopack/crates/turbo-tasks-fs/src/lib.rs

@@ -557,7 +557,7 @@ impl DiskFileSystemInner {
 
 #[derive(Clone, ValueToString)]
 #[value_to_string(self.inner.name)]
-#[turbo_tasks::value(cell = "new", eq = "manual")]
+#[turbo_tasks::value(cell = "new", eq = "manual", session_stateful)]
 pub struct DiskFileSystem {
     inner: Arc<DiskFileSystemInner>,
 }

turbopack/crates/turbo-tasks-macros/src/primitive_macro.rs

@@ -66,6 +66,7 @@ pub fn primitive(input: TokenStream) -> TokenStream {
         },
         new_value_type,
         /* has_serialization */ quote! { true },
+        /* session_stateful */ false,
     );
 
     let value_default_impl = quote! {

turbopack/crates/turbo-tasks-macros/src/value_macro.rs

@@ -80,6 +80,9 @@ struct ValueArguments {
     transparent: bool,
     /// Should we `#[derive(turbo_tasks::OperationValue)]`?
     operation: Option<Span>,
+    /// Whether this value has session-dependent interior state that survives serialization
+    /// but would be lost on eviction/restore mid-session.
+    session_stateful: bool,
 }
 
 impl Parse for ValueArguments {
@@ -91,6 +94,7 @@ impl Parse for ValueArguments {
             manual_eq: false,
             transparent: false,
             operation: None,
+            session_stateful: false,
         };
         let punctuated = input.parse_terminated(Meta::parse, Token![,])?;
         for meta in punctuated {
@@ -148,6 +152,9 @@ impl Parse for ValueArguments {
                 ("transparent", Meta::Path(_)) => {
                     result.transparent = true;
                 }
+                ("session_stateful", Meta::Path(_)) => {
+                    result.session_stateful = true;
+                }
                 ("operation", Meta::Path(path)) => {
                     result.operation = Some(path.span());
                 }
@@ -156,8 +163,8 @@ impl Parse for ValueArguments {
                         &meta,
                         format!(
                             "unexpected {meta:?}, expected \"shared\", \"into\", \
-                             \"serialization\", \"cell\", \"eq\", \"transparent\", or \
-                             \"operation\""
+                             \"serialization\", \"cell\", \"eq\", \"transparent\", \
+                             \"session_stateful\", or \"operation\""
                         ),
                     ));
                 }
@@ -177,6 +184,7 @@ pub fn value(args: TokenStream, input: TokenStream) -> TokenStream {
         manual_eq,
         transparent,
         operation,
+        session_stateful,
     } = parse_macro_input!(args as ValueArguments);
 
     let mut struct_attributes = vec![quote! {
@@ -388,6 +396,7 @@ pub fn value(args: TokenStream, input: TokenStream) -> TokenStream {
         cell_mode,
         new_value_type,
         has_serialization,
+        session_stateful,
     );
 
     let expanded = quote! {
@@ -414,6 +423,7 @@ pub fn value_type_and_register(
     cell_mode: proc_macro2::TokenStream,
     new_value_type: proc_macro2::TokenStream,
     has_serialization: proc_macro2::TokenStream,
+    session_stateful: bool,
 ) -> proc_macro2::TokenStream {
     let value_type_ident = get_value_type_ident(ident);
 
@@ -441,6 +451,10 @@ pub fn value_type_and_register(
             fn has_serialization() -> bool {
                 #has_serialization
             }
+
+            fn is_session_stateful() -> bool {
+                #session_stateful
+            }
         }
     }
 }

turbopack/crates/turbo-tasks-testing/src/lib.rs

@@ -277,6 +277,7 @@ impl TurboTasksApi for VcStorage {
         task: TaskId,
         index: CellId,
         _is_serializable_cell_content: bool,
+        _is_session_stateful: bool,
         content: CellContent,
         _updated_key_hashes: Option<SmallVec<[u64; 2]>>,
         _verification_mode: VerificationMode,

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

@@ -589,6 +589,7 @@ pub trait Backend: Sync + Send {
         task: TaskId,
         index: CellId,
         is_serializable_cell_content: bool,
+        is_session_stateful: bool,
         content: CellContent,
         updated_key_hashes: Option<SmallVec<[u64; 2]>>,
         verification_mode: VerificationMode,

turbopack/crates/turbo-tasks/src/manager.rs

@@ -172,6 +172,7 @@ pub trait TurboTasksApi: TurboTasksCallApi + Sync + Send {
         task: TaskId,
         index: CellId,
         is_serializable_cell_content: bool,
+        is_session_stateful: bool,
         content: CellContent,
         updated_key_hashes: Option<SmallVec<[u64; 2]>>,
         verification_mode: VerificationMode,
@@ -1568,6 +1569,7 @@ impl<B: Backend + 'static> TurboTasksApi for TurboTasks<B> {
         task: TaskId,
         index: CellId,
         is_serializable_cell_content: bool,
+        is_session_stateful: bool,
         content: CellContent,
         updated_key_hashes: Option<SmallVec<[u64; 2]>>,
         verification_mode: VerificationMode,
@@ -1576,6 +1578,7 @@ impl<B: Backend + 'static> TurboTasksApi for TurboTasks<B> {
             task,
             index,
             is_serializable_cell_content,
+            is_session_stateful,
             content,
             updated_key_hashes,
             verification_mode,
@@ -2021,6 +2024,7 @@ pub struct CurrentCellRef {
     current_task: TaskId,
     index: CellId,
     is_serializable_cell_content: bool,
+    is_session_stateful: bool,
 }
 
 type VcReadTarget<T> = <<T as VcValueType>::Read as VcRead<T>>::Target;
@@ -2069,6 +2073,7 @@ impl CurrentCellRef {
                 self.current_task,
                 self.index,
                 self.is_serializable_cell_content,
+                self.is_session_stateful,
                 CellContent(Some(update)),
                 updated_key_hashes,
                 VerificationMode::EqualityCheck,
@@ -2213,6 +2218,7 @@ impl CurrentCellRef {
             self.current_task,
             self.index,
             self.is_serializable_cell_content,
+            self.is_session_stateful,
             CellContent(Some(SharedReference::new(triomphe::Arc::new(new_value)))),
             None,
             verification_mode,
@@ -2259,6 +2265,7 @@ impl CurrentCellRef {
                 self.current_task,
                 self.index,
                 self.is_serializable_cell_content,
+                self.is_session_stateful,
                 CellContent(Some(shared_ref)),
                 None,
                 verification_mode,
@@ -2279,10 +2286,18 @@ fn extract_sr_value<T: VcValueType>(sr: &SharedReference) -> &T {
 }
 
 pub fn find_cell_by_type<T: VcValueType>() -> CurrentCellRef {
-    find_cell_by_id(T::get_value_type_id(), T::has_serialization())
+    find_cell_by_id(
+        T::get_value_type_id(),
+        T::has_serialization(),
+        T::is_session_stateful(),
+    )
 }
 
-pub fn find_cell_by_id(ty: ValueTypeId, is_serializable_cell_content: bool) -> CurrentCellRef {
+pub fn find_cell_by_id(
+    ty: ValueTypeId,
+    is_serializable_cell_content: bool,
+    is_session_stateful: bool,
+) -> CurrentCellRef {
     CURRENT_TASK_STATE.with(|ts| {
         let current_task = current_task("celling turbo_tasks values");
         let mut ts = ts.write().unwrap();
@@ -2294,6 +2309,7 @@ pub fn find_cell_by_id(ty: ValueTypeId, is_serializable_cell_content: bool) -> C
             current_task,
             index: CellId { type_id: ty, index },
             is_serializable_cell_content,
+            is_session_stateful,
         }
     })
 }

turbopack/crates/turbo-tasks/src/task/function.rs

@@ -433,6 +433,10 @@ mod tests {
             fn has_serialization() -> bool {
                 false
             }
+
+            fn is_session_stateful() -> bool {
+                false
+            }
         }
 
         trait AsyncTrait {