improve error reporting

Author: sokra

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

@@ -357,14 +357,7 @@ impl Backend for MemoryBackend {
             turbo_tasks,
             |output| {
                 Task::add_dependency_to_current(TaskDependency::TaskOutput(task));
-                output.read(reader).map_err(|err| {
-                    self.with_task(task, |task| {
-                        if let Some(name) = task.get_function_name() {
-                            return err.context(format!("Reading output from {name} failed"));
-                        }
-                        err
-                    })
-                })
+                output.read(reader)
             },
         )
     }

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

@@ -442,8 +442,12 @@ impl Task {
 
     pub(crate) fn get_function_name(&self) -> Option<&'static str> {
         if let TaskType::Persistent(ty) = &self.ty {
-            if let PersistentTaskType::Native(native_fn, _) = &**ty {
-                return Some(&registry::get_function(*native_fn).name);
+            match &**ty {
+                PersistentTaskType::Native(native_fn, _)
+                | PersistentTaskType::ResolveNative(native_fn, _) => {
+                    return Some(&registry::get_function(*native_fn).name);
+                }
+                _ => {}
             }
         }
         None

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

@@ -491,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, chunk_item);
+        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());
@@ -507,40 +536,8 @@ impl EcmascriptChunkContentEntryVc {
 }
 
 #[turbo_tasks::function]
-async fn module_factory(
-    content: EcmascriptChunkItemContentVc,
-    chunk_item: EcmascriptChunkItemVc,
-) -> Result<CodeVc> {
-    let content = match content.await {
-        Ok(content) => content,
-        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}})";
-            return Ok(code.build().cell());
-        }
-    };
+async fn module_factory(content: EcmascriptChunkItemContentVc) -> Result<CodeVc> {
+    let content = content.await?;
     let mut args = vec![
         "r: __turbopack_require__",
         "x: __turbopack_external_require__",

crates/turbopack-json/src/lib.rs

@@ -7,7 +7,7 @@
 
 #![feature(min_specialization)]
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use turbo_tasks::{primitives::StringVc, ValueToString, ValueToStringVc};
 use turbo_tasks_fs::FileSystemPathVc;
 use turbopack_core::{
@@ -110,7 +110,13 @@ impl EcmascriptChunkItem for JsonChunkItem {
     async fn content(&self) -> Result<EcmascriptChunkItemContentVc> {
         // We parse to JSON and then stringify again to ensure that the
         // JSON is valid.
-        let content = self.module.path().read_json().to_string().await?;
+        let content = self
+            .module
+            .path()
+            .read_json()
+            .to_string()
+            .await
+            .context("Unable to make a module from invalid JSON")?;
         let js_str_content = serde_json::to_string(content.as_str())?;
         let inner_code = format!("__turbopack_export_value__(JSON.parse({js_str_content}));");
         Ok(EcmascriptChunkItemContent {

crates/turbopack-tests/tests/snapshot.rs

@@ -11,7 +11,7 @@ use once_cell::sync::Lazy;
 use serde::Deserialize;
 use similar::TextDiff;
 use test_generator::test_resources;
-use turbo_tasks::{debug::ValueDebug, NothingVc, TryJoinIterExt, TurboTasks, Value};
+use turbo_tasks::{debug::ValueDebug, NothingVc, TryJoinIterExt, TurboTasks, Value, ValueToString};
 use turbo_tasks_env::DotenvProcessEnvVc;
 use turbo_tasks_fs::{
     util::sys_to_unix, DirectoryContent, DirectoryEntry, DiskFileSystemVc, File, FileContent,
@@ -101,7 +101,9 @@ async fn run(resource: &'static str) -> Result<()> {
     let tt = TurboTasks::new(MemoryBackend::default());
     let task = tt.spawn_once_task(async move {
         let out = run_test(resource.to_string());
-        handle_issues(out).await?;
+        handle_issues(out)
+            .await
+            .context("Unable to handle issues")?;
         Ok(NothingVc::new().into())
     });
     tt.wait_task_completion(task, true).await?;
@@ -238,10 +240,17 @@ async fn run_test(resource: String) -> Result<FileSystemPathVc> {
     }
 
     while let Some(asset) = queue.pop_front() {
-        walk_asset(asset, &mut seen, &mut queue).await?;
+        walk_asset(asset, &mut seen, &mut queue)
+            .await
+            .context(format!(
+                "Failed to walk asset {}",
+                asset.path().to_string().await.context("to_string failed")?
+            ))?;
     }
 
-    matches_expected(expected_paths, seen).await?;
+    matches_expected(expected_paths, seen)
+        .await
+        .context("Actual assets doesn't match with expected assets")?;
 
     Ok(path)
 }
@@ -273,28 +282,38 @@ async fn walk_asset(
     Ok(())
 }
 
-async fn get_contents(file: AssetContentVc) -> Result<Option<String>> {
-    Ok(match &*file.await? {
-        AssetContent::File(file) => match &*file.await? {
-            FileContent::NotFound => None,
-            FileContent::Content(expected) => Some(expected.content().to_str()?.trim().to_string()),
+async fn get_contents(file: AssetContentVc, path: FileSystemPathVc) -> Result<Option<String>> {
+    Ok(
+        match &*file.await.context(format!(
+            "Unable to read AssetContent of {}",
+            path.to_string().await?
+        ))? {
+            AssetContent::File(file) => match &*file.await.context(format!(
+                "Unable to read FileContent of {}",
+                path.to_string().await?
+            ))? {
+                FileContent::NotFound => None,
+                FileContent::Content(expected) => {
+                    Some(expected.content().to_str()?.trim().to_string())
+                }
+            },
+            AssetContent::Redirect { target, link_type } => Some(format!(
+                "Redirect {{ target: {target}, link_type: {:?} }}",
+                link_type
+            )),
         },
-        AssetContent::Redirect { target, link_type } => Some(format!(
-            "Redirect {{ target: {target}, link_type: {:?} }}",
-            link_type
-        )),
-    })
+    )
 }
 
 async fn diff(path: FileSystemPathVc, actual: AssetContentVc) -> Result<()> {
     let path_str = &path.await?.path;
     let expected = path.read().into();
 
-    let actual = match get_contents(actual).await? {
+    let actual = match get_contents(actual, path).await? {
         Some(s) => s,
         None => bail!("could not generate {} contents", path_str),
     };
-    let expected = get_contents(expected).await?;
+    let expected = get_contents(expected, path).await?;
 
     if Some(&actual) != expected.as_ref() {
         if *UPDATE {

crates/turbopack-tests/tests/snapshot/imports/json/issues/Code generation for chunk item errored-1fdecc.txt

@@ -0,0 +1,11 @@
+PlainIssue {
+    severity: Error,
+    context: "[project]/crates/turbopack-tests/tests/snapshot/imports/json/input/invalid.json",
+    category: "code generation",
+    title: "Code generation for chunk item errored",
+    description: "An error occurred while generating the chunk item [project]/crates/turbopack-tests/tests/snapshot/imports/json/input/invalid.json (json)\n  at Execution of module_factory failed\n  at Execution of JsonChunkItem::content failed\n  at Unable to make a module from invalid JSON\n  at Execution of FileJsonContent::to_string failed\n  at File is not valid JSON",
+    detail: "",
+    documentation_link: "",
+    source: None,
+    sub_issues: [],
+}