improve error reporting for fatal errors (vercel/turborepo#3550)

This adds the turbo-tasks function name as `context` of all fatal errors
propagated from executing or reading turbo-tasks functions.

That should help in debugging fatal errors.

Author: sokra

crates/next-core/src/next_client_chunks/with_chunks.rs

@@ -105,6 +105,11 @@ impl EcmascriptChunkItem for WithChunksChunkItem {
         self.context
     }
 
+    #[turbo_tasks::function]
+    fn related_path(&self) -> FileSystemPathVc {
+        self.inner.path()
+    }
+
     #[turbo_tasks::function]
     async fn content(&self) -> Result<EcmascriptChunkItemContentVc> {
         let inner = self.inner.await?;

crates/next-core/src/next_client_component/with_client_chunks.rs

@@ -105,6 +105,11 @@ impl EcmascriptChunkItem for WithClientChunksChunkItem {
         self.context
     }
 
+    #[turbo_tasks::function]
+    fn related_path(&self) -> FileSystemPathVc {
+        self.inner.path()
+    }
+
     #[turbo_tasks::function]
     async fn content(&self) -> Result<EcmascriptChunkItemContentVc> {
         let inner = self.inner.await?;

crates/turbo-tasks-memory/src/output.rs

@@ -52,7 +52,7 @@ impl Output {
     pub fn read_untracked(&mut self) -> Result<RawVc> {
         match &self.content {
             OutputContent::Empty => Err(anyhow!("Output is empty")),
-            OutputContent::Error(err) => Err(err.clone().into()),
+            OutputContent::Error(err) => Err(anyhow::Error::new(err.clone())),
             OutputContent::Link(raw_vc) => Ok(*raw_vc),
             OutputContent::Panic(Some(message)) => Err(anyhow!("A task panicked: {message}")),
             OutputContent::Panic(None) => Err(anyhow!("A task panicked")),

crates/turbo-tasks-memory/src/task.rs

@@ -440,6 +440,19 @@ impl Task {
         }
     }
 
+    pub(crate) fn get_function_name(&self) -> Option<&'static str> {
+        if let TaskType::Persistent(ty) = &self.ty {
+            match &**ty {
+                PersistentTaskType::Native(native_fn, _)
+                | PersistentTaskType::ResolveNative(native_fn, _) => {
+                    return Some(&registry::get_function(*native_fn).name);
+                }
+                _ => {}
+            }
+        }
+        None
+    }
+
     pub(crate) fn get_description(&self) -> String {
         match &self.ty {
             TaskType::Root(..) => format!("[{}] root", self.id),
@@ -700,7 +713,12 @@ impl Task {
         match state.state_type {
             InProgress { .. } => match result {
                 Ok(Ok(result)) => state.output.link(result, turbo_tasks),
-                Ok(Err(err)) => state.output.error(err, turbo_tasks),
+                Ok(Err(mut err)) => {
+                    if let Some(name) = self.get_function_name() {
+                        err = err.context(format!("Execution of {} failed", name));
+                    }
+                    state.output.error(err, turbo_tasks)
+                }
                 Err(message) => state.output.panic(message, turbo_tasks),
             },
             InProgressDirty { .. } => {

crates/turbo-tasks/src/native_function.rs

@@ -6,7 +6,7 @@ use std::{
     sync::atomic::{AtomicUsize, Ordering},
 };
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 
 use crate::{
     self as turbo_tasks, registry::register_function, task_input::TaskInput, util::SharedError,
@@ -56,7 +56,9 @@ impl NativeFunction {
 
     /// Creates a functor for execution from a fixed set of inputs.
     pub fn bind(&'static self, inputs: &Vec<TaskInput>) -> NativeTaskFn {
-        match (self.bind_fn)(inputs) {
+        match (self.bind_fn)(inputs)
+            .with_context(|| format!("Error during argument binding of {}", self.name))
+        {
             Ok(native_fn) => Box::new(move || {
                 let r = native_fn();
                 if cfg!(feature = "log_function_stats") {

crates/turbo-tasks/src/util.rs

@@ -17,11 +17,8 @@ pub struct SharedError {
 
 impl SharedError {
     pub fn new(err: Error) -> Self {
-        match err.downcast::<SharedError>() {
-            Ok(shared) => shared,
-            Err(plain) => Self {
-                inner: Arc::new(plain),
-            },
+        Self {
+            inner: Arc::new(err),
         }
     }
 }

crates/turbopack-core/src/chunk/mod.rs

@@ -1,7 +1,10 @@
 pub mod dev;
 pub mod optimize;
 
-use std::{collections::VecDeque, fmt::Debug};
+use std::{
+    collections::VecDeque,
+    fmt::{Debug, Display},
+};
 
 use anyhow::{anyhow, Result};
 use indexmap::IndexSet;
@@ -32,6 +35,23 @@ pub enum ModuleId {
     String(String),
 }
 
+impl Display for ModuleId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ModuleId::Number(i) => write!(f, "{}", i),
+            ModuleId::String(s) => write!(f, "{}", s),
+        }
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl ValueToString for ModuleId {
+    #[turbo_tasks::function]
+    fn to_string(&self) -> StringVc {
+        StringVc::cell(self.to_string())
+    }
+}
+
 impl ModuleId {
     pub fn parse(id: &str) -> Result<ModuleId> {
         Ok(match id.parse::<u32>() {

crates/turbopack-css/src/module_asset.rs

@@ -173,6 +173,11 @@ impl EcmascriptChunkItem for ModuleChunkItem {
         self.context
     }
 
+    #[turbo_tasks::function]
+    fn related_path(&self) -> FileSystemPathVc {
+        self.module.path()
+    }
+
     #[turbo_tasks::function]
     async fn content(&self) -> Result<EcmascriptChunkItemContentVc> {
         let parsed = self.module.parse().await?;

crates/turbopack-ecmascript/src/chunk/mod.rs

@@ -32,6 +32,7 @@ use turbopack_core::{
         asset::{children_from_asset_references, content_to_details, IntrospectableAssetVc},
         Introspectable, IntrospectableChildrenVc, IntrospectableVc,
     },
+    issue::{code_gen::CodeGenerationIssue, IssueSeverity},
     reference::{AssetReferenceVc, AssetReferencesVc},
     source_map::{GenerateSourceMap, GenerateSourceMapVc, OptionSourceMapVc, SourceMapVc},
     version::{
@@ -490,7 +491,36 @@ impl EcmascriptChunkContentEntryVc {
     #[turbo_tasks::function]
     async fn new(chunk_item: EcmascriptChunkItemVc) -> Result<Self> {
         let content = chunk_item.content();
-        let factory = module_factory(content);
+        let factory = match module_factory(content).resolve().await {
+            Ok(factory) => factory,
+            Err(error) => {
+                let id = chunk_item.id().to_string().await;
+                let id = id.as_ref().map_or_else(|_| "unknown", |id| &**id);
+                let mut error_message =
+                    format!("An error occurred while generating the chunk item {}", id);
+                for err in error.chain() {
+                    write!(error_message, "\n  at {}", err)?;
+                }
+                let js_error_message = serde_json::to_string(&error_message)?;
+                let issue = CodeGenerationIssue {
+                    severity: IssueSeverity::Error.cell(),
+                    path: chunk_item.related_path(),
+                    title: StringVc::cell("Code generation for chunk item errored".to_string()),
+                    message: StringVc::cell(error_message),
+                }
+                .cell();
+                issue.as_issue().emit();
+                let mut code = CodeBuilder::default();
+                code += "(() => {{\n\n";
+                write!(
+                    code,
+                    "throw new Error({error});\n",
+                    error = &js_error_message
+                )?;
+                code += "\n}})";
+                code.build().cell()
+            }
+        };
         let id = chunk_item.id().await?;
         let code = factory.await?;
         let hash = hash_xxh3_hash64(code.source_code());
@@ -1196,6 +1226,7 @@ pub struct EcmascriptChunkItemOptions {
 
 #[turbo_tasks::value_trait]
 pub trait EcmascriptChunkItem: ChunkItem + ValueToString {
+    fn related_path(&self) -> FileSystemPathVc;
     fn content(&self) -> EcmascriptChunkItemContentVc;
     fn chunking_context(&self) -> ChunkingContextVc;
     fn id(&self) -> ModuleIdVc {

crates/turbopack-ecmascript/src/chunk_group_files_asset.rs

@@ -118,6 +118,11 @@ impl EcmascriptChunkItem for ChunkGroupFilesChunkItem {
         self.context
     }
 
+    #[turbo_tasks::function]
+    fn related_path(&self) -> FileSystemPathVc {
+        self.inner.path()
+    }
+
     #[turbo_tasks::function]
     async fn content(&self) -> Result<EcmascriptChunkItemContentVc> {
         let chunks = self.inner.chunks();