persist and compare errors and panics

sokra · sokra · commit ee978ee24d6b · 2025-04-09T09:58:55.000+02:00
diff --git a/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs b/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs
@@ -16,7 +16,7 @@ use std::{
     thread::available_parallelism,
 };
 
-use anyhow::{bail, Result};
+use anyhow::{anyhow, bail, Result};
 use auto_hash_map::{AutoMap, AutoSet};
 use parking_lot::{Condvar, Mutex};
 use rustc_hash::{FxHashMap, FxHashSet, FxHasher};
@@ -560,38 +560,46 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
 
         if let Some(output) = get!(task, Output) {
             let result = match output {
-                OutputValue::Cell(cell) => Some(Ok(Ok(RawVc::TaskCell(cell.task, cell.cell)))),
-                OutputValue::Output(task) => Some(Ok(Ok(RawVc::TaskOutput(*task)))),
-                OutputValue::Error | OutputValue::Panic => {
-                    get!(task, Error).map(|error| Err(error.clone().into()))
+                OutputValue::Cell(cell) => Ok(Ok(RawVc::TaskCell(cell.task, cell.cell))),
+                OutputValue::Output(task) => Ok(Ok(RawVc::TaskOutput(*task))),
+                OutputValue::Error(error) => {
+                    let err: anyhow::Error = error.clone().into();
+                    Err(err.context(format!(
+                        "Execution of {} failed",
+                        ctx.get_task_description(task_id)
+                    )))
+                }
+                OutputValue::Panic(Some(panic)) => Err(anyhow!(
+                    "Panic in {}: {}",
+                    ctx.get_task_description(task_id),
+                    panic
+                )),
+                OutputValue::Panic(None) => {
+                    Err(anyhow!("Panic in {}", ctx.get_task_description(task_id)))
                 }
             };
-            if let Some(result) = result {
-                if self.should_track_dependencies() {
-                    if let Some(reader) = reader {
-                        let _ = task.add(CachedDataItem::OutputDependent {
-                            task: reader,
+            if self.should_track_dependencies() {
+                if let Some(reader) = reader {
+                    let _ = task.add(CachedDataItem::OutputDependent {
+                        task: reader,
+                        value: (),
+                    });
+                    drop(task);
+
+                    let mut reader_task = ctx.task(reader, TaskDataCategory::Data);
+                    if reader_task
+                        .remove(&CachedDataItemKey::OutdatedOutputDependency { target: task_id })
+                        .is_none()
+                    {
+                        let _ = reader_task.add(CachedDataItem::OutputDependency {
+                            target: task_id,
                             value: (),
                         });
-                        drop(task);
-
-                        let mut reader_task = ctx.task(reader, TaskDataCategory::Data);
-                        if reader_task
-                            .remove(&CachedDataItemKey::OutdatedOutputDependency {
-                                target: task_id,
-                            })
-                            .is_none()
-                        {
-                            let _ = reader_task.add(CachedDataItem::OutputDependency {
-                                target: task_id,
-                                value: (),
-                            });
-                        }
                     }
                 }
-
-                return result;
             }
+
+            return result;
         }
 
         let reader_desc = reader.map(|r| self.get_task_desc_fn(r));
diff --git a/turbopack/crates/turbo-tasks-backend/src/backend/operation/update_output.rs b/turbopack/crates/turbo-tasks-backend/src/backend/operation/update_output.rs
@@ -1,6 +1,6 @@
 use std::{borrow::Cow, mem::take};
 
-use anyhow::{anyhow, Result};
+use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use turbo_tasks::{util::SharedError, RawVc, TaskId};
 
@@ -65,7 +65,6 @@ impl UpdateOutputOperation {
             .then(|| new_children.iter().copied().collect())
             .unwrap_or_default();
 
-        let old_error = task.remove(&CachedDataItemKey::Error {});
         let current_output = get!(task, Output);
         let output_value = match output {
             Ok(Ok(RawVc::TaskOutput(output_task_id))) => {
@@ -95,23 +94,20 @@ impl UpdateOutputOperation {
                 panic!("LocalOutput must not be output of a task");
             }
             Ok(Err(err)) => {
-                task.insert(CachedDataItem::Error {
-                    value: SharedError::new(err.context(format!(
-                        "Execution of {} failed",
-                        ctx.get_task_description(task_id)
-                    ))),
-                });
-                OutputValue::Error
+                if let Some(OutputValue::Error(old_error)) = current_output {
+                    if old_error.eq_stack(&err) {
+                        return;
+                    }
+                }
+                OutputValue::Error(SharedError::new(err))
             }
             Err(panic) => {
-                task.insert(CachedDataItem::Error {
-                    value: SharedError::new(anyhow!(
-                        "Panic in {}: {:?}",
-                        ctx.get_task_description(task_id),
-                        panic
-                    )),
-                });
-                OutputValue::Panic
+                if let Some(OutputValue::Panic(old_panic)) = current_output {
+                    if old_panic.as_deref() == panic.as_deref() {
+                        return;
+                    }
+                }
+                OutputValue::Panic(panic.map(|s| s.into()))
             }
         };
         let old_content = task.insert(CachedDataItem::Output {
@@ -137,7 +133,6 @@ impl UpdateOutputOperation {
 
         drop(task);
         drop(old_content);
-        drop(old_error);
 
         UpdateOutputOperation::MakeDependentTasksDirty {
             #[cfg(feature = "trace_task_dirty")]
diff --git a/turbopack/crates/turbo-tasks-backend/src/data.rs b/turbopack/crates/turbo-tasks-backend/src/data.rs
@@ -2,6 +2,7 @@ use std::cmp::Ordering;
 
 use rustc_hash::FxHashSet;
 use serde::{Deserialize, Serialize};
+use turbo_rcstr::RcStr;
 use turbo_tasks::{
     event::{Event, EventListener},
     registry,
@@ -52,20 +53,20 @@ pub struct CollectiblesRef {
     pub collectible_type: TraitTypeId,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum OutputValue {
     Cell(CellRef),
     Output(TaskId),
-    Error,
-    Panic,
+    Error(SharedError),
+    Panic(Option<RcStr>),
 }
 impl OutputValue {
     fn is_transient(&self) -> bool {
         match self {
             OutputValue::Cell(cell) => cell.task.is_transient(),
             OutputValue::Output(task) => task.is_transient(),
-            OutputValue::Error => false,
-            OutputValue::Panic => false,
+            OutputValue::Error(_) => false,
+            OutputValue::Panic(_) => false,
         }
     }
 }
@@ -482,12 +483,6 @@ pub enum CachedDataItem {
         target: CollectiblesRef,
         value: (),
     },
-
-    // Transient Error State
-    #[serde(skip)]
-    Error {
-        value: SharedError,
-    },
 }
 
 impl CachedDataItem {
@@ -523,7 +518,6 @@ impl CachedDataItem {
             CachedDataItem::OutdatedOutputDependency { .. } => false,
             CachedDataItem::OutdatedCellDependency { .. } => false,
             CachedDataItem::OutdatedCollectiblesDependency { .. } => false,
-            CachedDataItem::Error { .. } => false,
         }
     }
 
@@ -578,7 +572,6 @@ impl CachedDataItem {
             | Self::OutdatedCollectiblesDependency { .. }
             | Self::InProgressCell { .. }
             | Self::InProgress { .. }
-            | Self::Error { .. }
             | Self::Activeness { .. } => TaskDataCategory::All,
         }
     }
@@ -617,7 +610,6 @@ impl CachedDataItemKey {
             CachedDataItemKey::OutdatedOutputDependency { .. } => false,
             CachedDataItemKey::OutdatedCellDependency { .. } => false,
             CachedDataItemKey::OutdatedCollectiblesDependency { .. } => false,
-            CachedDataItemKey::Error { .. } => false,
         }
     }
 
@@ -660,7 +652,6 @@ impl CachedDataItemType {
             | Self::OutdatedCollectiblesDependency { .. }
             | Self::InProgressCell { .. }
             | Self::InProgress { .. }
-            | Self::Error { .. }
             | Self::Activeness { .. } => TaskDataCategory::All,
         }
     }
diff --git a/turbopack/crates/turbo-tasks/src/util.rs b/turbopack/crates/turbo-tasks/src/util.rs
@@ -32,6 +32,27 @@ impl SharedError {
             inner: Arc::new(err),
         }
     }
+
+    pub fn eq_stack(&self, other: &anyhow::Error) -> bool {
+        if self.to_string() != other.to_string() {
+            return false;
+        }
+        let mut source = self.source();
+        let mut other_source = other.source();
+        loop {
+            if source.is_none() && other_source.is_none() {
+                return true;
+            }
+            let (Some(source_err), Some(other_source_err)) = (source, other_source) else {
+                return false;
+            };
+            if source_err.to_string() != other_source_err.to_string() {
+                return false;
+            }
+            source = source_err.source();
+            other_source = other_source_err.source();
+        }
+    }
 }
 
 impl StdError for SharedError {

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@ use std::cmp::Ordering;`
`2`	`2`
`3`	`3`	`use rustc_hash::FxHashSet;`
`4`	`4`	`use serde::{Deserialize, Serialize};`
	`5`	`+use turbo_rcstr::RcStr;`
`5`	`6`	`use turbo_tasks::{`
`6`	`7`	`event::{Event, EventListener},`
`7`	`8`	`registry,`
`@@ -52,20 +53,20 @@ pub struct CollectiblesRef {`
`52`	`53`	`pub collectible_type: TraitTypeId,`
`53`	`54`	`}`
`54`	`55`
`55`		`-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]`
	`56`	`+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]`
`56`	`57`	`pub enum OutputValue {`
`57`	`58`	`Cell(CellRef),`
`58`	`59`	`Output(TaskId),`
`59`		`- Error,`
`60`		`- Panic,`
	`60`	`+ Error(SharedError),`
	`61`	`+ Panic(Option<RcStr>),`
`61`	`62`	`}`
`62`	`63`	`impl OutputValue {`
`63`	`64`	`fn is_transient(&self) -> bool {`
`64`	`65`	`match self {`
`65`	`66`	`OutputValue::Cell(cell) => cell.task.is_transient(),`
`66`	`67`	`OutputValue::Output(task) => task.is_transient(),`
`67`		`- OutputValue::Error => false,`
`68`		`- OutputValue::Panic => false,`
	`68`	`+ OutputValue::Error(_) => false,`
	`69`	`+ OutputValue::Panic(_) => false,`
`69`	`70`	`}`
`70`	`71`	`}`
`71`	`72`	`}`
`@@ -482,12 +483,6 @@ pub enum CachedDataItem {`
`482`	`483`	`target: CollectiblesRef,`
`483`	`484`	`value: (),`
`484`	`485`	`},`
`485`		`-`
`486`		`- // Transient Error State`
`487`		`- #[serde(skip)]`
`488`		`- Error {`
`489`		`- value: SharedError,`
`490`		`- },`
`491`	`486`	`}`
`492`	`487`
`493`	`488`	`impl CachedDataItem {`
`@@ -523,7 +518,6 @@ impl CachedDataItem {`
`523`	`518`	`CachedDataItem::OutdatedOutputDependency { .. } => false,`
`524`	`519`	`CachedDataItem::OutdatedCellDependency { .. } => false,`
`525`	`520`	`CachedDataItem::OutdatedCollectiblesDependency { .. } => false,`
`526`		`- CachedDataItem::Error { .. } => false,`
`527`	`521`	`}`
`528`	`522`	`}`
`529`	`523`
`@@ -578,7 +572,6 @@ impl CachedDataItem {`
`578`	`572`	`\| Self::OutdatedCollectiblesDependency { .. }`
`579`	`573`	`\| Self::InProgressCell { .. }`
`580`	`574`	`\| Self::InProgress { .. }`
`581`		`- \| Self::Error { .. }`
`582`	`575`	`\| Self::Activeness { .. } => TaskDataCategory::All,`
`583`	`576`	`}`
`584`	`577`	`}`
`@@ -617,7 +610,6 @@ impl CachedDataItemKey {`
`617`	`610`	`CachedDataItemKey::OutdatedOutputDependency { .. } => false,`
`618`	`611`	`CachedDataItemKey::OutdatedCellDependency { .. } => false,`
`619`	`612`	`CachedDataItemKey::OutdatedCollectiblesDependency { .. } => false,`
`620`		`- CachedDataItemKey::Error { .. } => false,`
`621`	`613`	`}`
`622`	`614`	`}`
`623`	`615`
`@@ -660,7 +652,6 @@ impl CachedDataItemType {`
`660`	`652`	`\| Self::OutdatedCollectiblesDependency { .. }`
`661`	`653`	`\| Self::InProgressCell { .. }`
`662`	`654`	`\| Self::InProgress { .. }`
`663`		`- \| Self::Error { .. }`
`664`	`655`	`\| Self::Activeness { .. } => TaskDataCategory::All,`
`665`	`656`	`}`
`666`	`657`	`}`