persist and compare errors and panics

sokra · sokra · commit 893a2908d041 · 2025-04-10T08:24:30.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,
         }
     }
 }
@@ -488,12 +489,6 @@ pub enum CachedDataItem {
         target: CollectiblesRef,
         value: (),
     },
-
-    // Transient Error State
-    #[serde(skip)]
-    Error {
-        value: SharedError,
-    },
 }
 
 impl CachedDataItem {
@@ -529,7 +524,6 @@ impl CachedDataItem {
             CachedDataItem::OutdatedOutputDependency { .. } => false,
             CachedDataItem::OutdatedCellDependency { .. } => false,
             CachedDataItem::OutdatedCollectiblesDependency { .. } => false,
-            CachedDataItem::Error { .. } => false,
         }
     }
 
@@ -584,7 +578,6 @@ impl CachedDataItem {
             | Self::OutdatedCollectiblesDependency { .. }
             | Self::InProgressCell { .. }
             | Self::InProgress { .. }
-            | Self::Error { .. }
             | Self::Activeness { .. } => TaskDataCategory::All,
         }
     }
@@ -623,7 +616,6 @@ impl CachedDataItemKey {
             CachedDataItemKey::OutdatedOutputDependency { .. } => false,
             CachedDataItemKey::OutdatedCellDependency { .. } => false,
             CachedDataItemKey::OutdatedCollectiblesDependency { .. } => false,
-            CachedDataItemKey::Error { .. } => false,
         }
     }
 
@@ -666,7 +658,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`	`}`
`@@ -488,12 +489,6 @@ pub enum CachedDataItem {`
`488`	`489`	`target: CollectiblesRef,`
`489`	`490`	`value: (),`
`490`	`491`	`},`
`491`		`-`
`492`		`- // Transient Error State`
`493`		`- #[serde(skip)]`
`494`		`- Error {`
`495`		`- value: SharedError,`
`496`		`- },`
`497`	`492`	`}`
`498`	`493`
`499`	`494`	`impl CachedDataItem {`
`@@ -529,7 +524,6 @@ impl CachedDataItem {`
`529`	`524`	`CachedDataItem::OutdatedOutputDependency { .. } => false,`
`530`	`525`	`CachedDataItem::OutdatedCellDependency { .. } => false,`
`531`	`526`	`CachedDataItem::OutdatedCollectiblesDependency { .. } => false,`
`532`		`- CachedDataItem::Error { .. } => false,`
`533`	`527`	`}`
`534`	`528`	`}`
`535`	`529`
`@@ -584,7 +578,6 @@ impl CachedDataItem {`
`584`	`578`	`\| Self::OutdatedCollectiblesDependency { .. }`
`585`	`579`	`\| Self::InProgressCell { .. }`
`586`	`580`	`\| Self::InProgress { .. }`
`587`		`- \| Self::Error { .. }`
`588`	`581`	`\| Self::Activeness { .. } => TaskDataCategory::All,`
`589`	`582`	`}`
`590`	`583`	`}`
`@@ -623,7 +616,6 @@ impl CachedDataItemKey {`
`623`	`616`	`CachedDataItemKey::OutdatedOutputDependency { .. } => false,`
`624`	`617`	`CachedDataItemKey::OutdatedCellDependency { .. } => false,`
`625`	`618`	`CachedDataItemKey::OutdatedCollectiblesDependency { .. } => false,`
`626`		`- CachedDataItemKey::Error { .. } => false,`
`627`	`619`	`}`
`628`	`620`	`}`
`629`	`621`
`@@ -666,7 +658,6 @@ impl CachedDataItemType {`
`666`	`658`	`\| Self::OutdatedCollectiblesDependency { .. }`
`667`	`659`	`\| Self::InProgressCell { .. }`
`668`	`660`	`\| Self::InProgress { .. }`
`669`		`- \| Self::Error { .. }`
`670`	`661`	`\| Self::Activeness { .. } => TaskDataCategory::All,`
`671`	`662`	`}`
`672`	`663`	`}`