review fixups

Author: sokra

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

@@ -31,7 +31,7 @@ use turbo_tasks::{
     TraitTypeId, TurboTasksBackendApi, ValueTypeId,
     backend::{
         Backend, CachedTaskType, CellContent, TaskExecutionSpec, TransientTaskRoot,
-        TransientTaskType, TurboTasksExecutionError, TypedCellContent,
+        TransientTaskType, TurboTasksExecutionError, TypedCellContent, VerificationMode,
     },
     event::{Event, EventListener},
     message_queue::TimingEvent,
@@ -2681,14 +2681,14 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
         task_id: TaskId,
         cell: CellId,
         content: CellContent,
-        never_equal: bool,
+        verification_mode: VerificationMode,
         turbo_tasks: &dyn TurboTasksBackendApi<TurboTasksBackend<B>>,
     ) {
         operation::UpdateCellOperation::run(
             task_id,
             cell,
             content,
-            never_equal,
+            verification_mode,
             self.execute_context(turbo_tasks),
         );
     }
@@ -3282,11 +3282,11 @@ impl<B: BackingStorage> Backend for TurboTasksBackend<B> {
         task_id: TaskId,
         cell: CellId,
         content: CellContent,
-        never_equal: bool,
+        verification_mode: VerificationMode,
         turbo_tasks: &dyn TurboTasksBackendApi<Self>,
     ) {
         self.0
-            .update_task_cell(task_id, cell, content, never_equal, turbo_tasks);
+            .update_task_cell(task_id, cell, content, verification_mode, turbo_tasks);
     }
 
     fn mark_own_task_as_finished(

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

@@ -2,6 +2,8 @@ use std::mem::take;
 
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
+#[cfg(not(feature = "verify_determinism"))]
+use turbo_tasks::backend::VerificationMode;
 use turbo_tasks::{CellId, TaskId, TypedSharedReference, backend::CellContent};
 
 #[cfg(feature = "trace_task_dirty")]
@@ -44,8 +46,8 @@ impl UpdateCellOperation {
         task_id: TaskId,
         cell: CellId,
         content: CellContent,
-        #[cfg(feature = "verify_determinism")] never_equal: bool,
-        #[cfg(not(feature = "verify_determinism"))] _never_equal: bool,
+        #[cfg(feature = "verify_determinism")] verification_mode: VerificationMode,
+        #[cfg(not(feature = "verify_determinism"))] _verification_mode: VerificationMode,
         mut ctx: impl ExecuteContext,
     ) {
         let content = if let CellContent(Some(new_content)) = content {
@@ -74,10 +76,13 @@ impl UpdateCellOperation {
 
                 // Check if this assumption holds.
                 #[cfg(feature = "verify_determinism")]
-                if !is_stateful && !never_equal && content.as_ref() != old_content {
+                if !is_stateful
+                    && matches!(verification_mode, VerificationMode::EqualityCheck)
+                    && content.as_ref() != old_content
+                {
                     let task_description = ctx.get_task_description(task_id);
                     let cell_type = turbo_tasks::registry::get_value_type(cell.type_id).global_name;
-                    println!(
+                    eprintln!(
                         "Task {} updated cell #{} (type: {}) while recomputing",
                         task_description, cell.index, cell_type
                     );

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

@@ -18,7 +18,7 @@ use tokio::sync::mpsc::Receiver;
 use turbo_tasks::{
     CellId, ExecutionId, InvalidationReason, LocalTaskId, MagicAny, RawVc, ReadCellOptions,
     ReadOutputOptions, TaskId, TaskPersistence, TraitTypeId, TurboTasksApi, TurboTasksCallApi,
-    backend::{CellContent, TaskCollectiblesMap, TypedCellContent},
+    backend::{CellContent, TaskCollectiblesMap, TypedCellContent, VerificationMode},
     event::{Event, EventListener},
     message_queue::CompilationEvent,
     test_helpers::with_turbo_tasks_for_testing,
@@ -266,7 +266,7 @@ impl TurboTasksApi for VcStorage {
         task: TaskId,
         index: CellId,
         content: CellContent,
-        _never_equal: bool,
+        _verification_mode: VerificationMode,
     ) {
         let mut map = self.cells.lock().unwrap();
         let cell = map.entry((task, index)).or_default();

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

@@ -497,6 +497,11 @@ impl From<anyhow::Error> for TurboTasksExecutionError {
     }
 }
 
+pub enum VerificationMode {
+    EqualityCheck,
+    Skip,
+}
+
 pub trait Backend: Sync + Send {
     #[allow(unused_variables)]
     fn startup(&self, turbo_tasks: &dyn TurboTasksBackendApi<Self>) {}
@@ -621,7 +626,7 @@ pub trait Backend: Sync + Send {
         task: TaskId,
         index: CellId,
         content: CellContent,
-        never_equal: bool,
+        verification_mode: VerificationMode,
         turbo_tasks: &dyn TurboTasksBackendApi<Self>,
     );
 

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

@@ -25,7 +25,7 @@ use crate::{
     VcValueTrait, VcValueType,
     backend::{
         Backend, CachedTaskType, CellContent, TaskCollectiblesMap, TaskExecutionSpec,
-        TransientTaskType, TurboTasksExecutionError, TypedCellContent,
+        TransientTaskType, TurboTasksExecutionError, TypedCellContent, VerificationMode,
     },
     capture_future::CaptureFuture,
     event::{Event, EventListener},
@@ -160,7 +160,7 @@ pub trait TurboTasksApi: TurboTasksCallApi + Sync + Send {
         task: TaskId,
         index: CellId,
         content: CellContent,
-        never_equal: bool,
+        verification_mode: VerificationMode,
     );
     fn mark_own_task_as_finished(&self, task: TaskId);
     fn set_own_task_aggregation_number(&self, task: TaskId, aggregation_number: u32);
@@ -1365,10 +1365,10 @@ impl<B: Backend + 'static> TurboTasksApi for TurboTasks<B> {
         task: TaskId,
         index: CellId,
         content: CellContent,
-        never_equal: bool,
+        verification_mode: VerificationMode,
     ) {
         self.backend
-            .update_task_cell(task, index, content, never_equal, self);
+            .update_task_cell(task, index, content, verification_mode, self);
     }
 
     fn connect_task(&self, task: TaskId) {
@@ -1786,7 +1786,7 @@ impl CurrentCellRef {
                 self.current_task,
                 self.index,
                 CellContent(Some(update)),
-                false,
+                VerificationMode::EqualityCheck,
             )
         }
     }
@@ -1869,7 +1869,7 @@ impl CurrentCellRef {
     }
 
     /// Unconditionally updates the content of the cell.
-    pub fn update<T>(&self, new_value: T, never_equal: bool)
+    pub fn update<T>(&self, new_value: T, verification_mode: VerificationMode)
     where
         T: VcValueType,
     {
@@ -1880,7 +1880,7 @@ impl CurrentCellRef {
             CellContent(Some(SharedReference::new(triomphe::Arc::new(
                 <T::Read as VcRead<T>>::value_to_repr(new_value),
             )))),
-            never_equal,
+            verification_mode,
         )
     }
 
@@ -1892,9 +1892,13 @@ impl CurrentCellRef {
     ///
     /// The [`SharedReference`] is expected to use the `<T::Read as
     /// VcRead<T>>::Repr` type for its representation of the value.
-    pub fn update_with_shared_reference(&self, shared_ref: SharedReference, never_equal: bool) {
+    pub fn update_with_shared_reference(
+        &self,
+        shared_ref: SharedReference,
+        verification_mode: VerificationMode,
+    ) {
         let tt = turbo_tasks();
-        let update = if !never_equal {
+        let update = if matches!(verification_mode, VerificationMode::EqualityCheck) {
             let content = tt
                 .read_own_task_cell(
                     self.current_task,
@@ -1920,7 +1924,7 @@ impl CurrentCellRef {
                 self.current_task,
                 self.index,
                 CellContent(Some(shared_ref)),
-                never_equal,
+                verification_mode,
             )
         }
     }

turbopack/crates/turbo-tasks/src/vc/cell_mode.rs

@@ -1,7 +1,10 @@
 use std::{any::type_name, marker::PhantomData};
 
 use super::{read::VcRead, traits::VcValueType};
-use crate::{RawVc, Vc, manager::find_cell_by_type, task::shared_reference::TypedSharedReference};
+use crate::{
+    RawVc, Vc, backend::VerificationMode, manager::find_cell_by_type,
+    task::shared_reference::TypedSharedReference,
+};
 
 type VcReadTarget<T> = <<T as VcValueType>::Read as VcRead<T>>::Target;
 type VcReadRepr<T> = <<T as VcValueType>::Read as VcRead<T>>::Repr;
@@ -37,7 +40,10 @@ where
 {
     fn cell(inner: VcReadTarget<T>) -> Vc<T> {
         let cell = find_cell_by_type(T::get_value_type_id());
-        cell.update(<T::Read as VcRead<T>>::target_to_value(inner), true);
+        cell.update(
+            <T::Read as VcRead<T>>::target_to_value(inner),
+            VerificationMode::Skip,
+        );
         Vc {
             node: cell.into(),
             _t: PhantomData,
@@ -47,7 +53,7 @@ where
     fn raw_cell(content: TypedSharedReference) -> RawVc {
         debug_assert_repr::<T>(&content);
         let cell = find_cell_by_type(content.type_id);
-        cell.update_with_shared_reference(content.reference, true);
+        cell.update_with_shared_reference(content.reference, VerificationMode::Skip);
         cell.into()
     }
 }

turbopack/crates/turbopack-node/src/evaluate.rs

@@ -16,8 +16,8 @@ use serde_json::Value as JsonValue;
 use turbo_rcstr::rcstr;
 use turbo_tasks::{
     Completion, Effects, FxIndexMap, NonLocalValue, OperationVc, RawVc, ReadRef, ResolvedVc,
-    TaskInput, TryJoinIterExt, Vc, VcValueType, duration_span, fxindexmap, get_effects,
-    mark_finished, prevent_gc, trace::TraceRawVcs, util::SharedError,
+    TaskInput, TryJoinIterExt, Vc, VcValueType, backend::VerificationMode, duration_span,
+    fxindexmap, get_effects, mark_finished, prevent_gc, trace::TraceRawVcs, util::SharedError,
 };
 use turbo_tasks_bytes::{Bytes, Stream};
 use turbo_tasks_env::{EnvMap, ProcessEnv};
@@ -403,7 +403,7 @@ pub async fn custom_evaluate(
     let (sender, receiver) = unbounded();
     cell.update(
         JavaScriptEvaluation(JavaScriptStream::new_open(vec![], Box::new(receiver))),
-        true,
+        VerificationMode::Skip,
     );
     let initial = Mutex::new(Some(sender));
 
@@ -423,7 +423,7 @@ pub async fn custom_evaluate(
                                 vec![],
                                 Box::new(receiver),
                             )),
-                            true,
+                            VerificationMode::Skip,
                         );
                         sender
                     }