Code frame and sourcemapped error support for Turbopack

packages/next-swc/crates/napi/Cargo.toml

@@ -75,6 +75,7 @@ turbopack-binding = { workspace = true, features = [
   "__turbopack",
   "__turbopack_ecmascript_hmr_protocol",
 ] }
+url = {workspace = true}
 
 [target.'cfg(not(all(target_os = "linux", target_env = "musl", target_arch = "aarch64")))'.dependencies]
 turbopack-binding = { workspace = true, features = ["__turbo_tasks_malloc"] }

packages/next-swc/crates/napi/src/next_api/project.rs

@@ -1,6 +1,6 @@
-use std::{path::PathBuf, sync::Arc, time::Duration};
+use std::{io::Read, path::PathBuf, sync::Arc, time::Duration};
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, bail, Context, Result};
 use napi::{
     bindgen_prelude::External,
     threadsafe_function::{ThreadsafeFunction, ThreadsafeFunctionCallMode},
@@ -18,7 +18,10 @@ use tracing_subscriber::{
 };
 use turbo_tasks::{TransientInstance, TurboTasks, UpdateInfo, Vc};
 use turbopack_binding::{
-    turbo::tasks_memory::MemoryBackend,
+    turbo::{
+        tasks_fs::{FileContent, FileSystem},
+        tasks_memory::MemoryBackend,
+    },
     turbopack::{
         cli_utils::{
             exit::ExitGuard,
@@ -28,11 +31,13 @@ use turbopack_binding::{
         },
         core::{
             error::PrettyPrintError,
+            source_map::{GenerateSourceMap, Token},
             version::{PartialUpdate, TotalUpdate, Update},
         },
         ecmascript_hmr_protocol::{ClientUpdateInstruction, ResourceIdentifier},
     },
 };
+use url::Url;
 
 use super::{
     endpoint::ExternalEndpoint,
@@ -607,3 +612,122 @@ pub fn project_update_info_subscribe(
     });
     Ok(())
 }
+
+#[turbo_tasks::value]
+#[derive(Debug)]
+#[napi(object)]
+pub struct TracedSource {
+    pub frame: StackFrame,
+    pub source: String,
+}
+
+#[turbo_tasks::value]
+#[derive(Debug)]
+#[napi(object)]
+pub struct StackFrame {
+    pub file: String,
+    pub method_name: Option<String>,
+    pub line: u32,
+    pub column: Option<u32>,
+}
+
+#[napi]
+pub async fn project_trace_source(
+    #[napi(ts_arg_type = "{ __napiType: \"Project\" }")] project: External<ProjectInstance>,
+    frame: StackFrame,
+) -> napi::Result<Option<TracedSource>> {
+    let turbo_tasks = project.turbo_tasks.clone();
+    let traced_frame = turbo_tasks
+        .run_once(async move {
+            let file = match Url::parse(&frame.file) {
+                Ok(url) => match url.scheme() {
+                    "file" => url.path().to_string(),
+                    _ => bail!("Unknown url scheme"),
+                },
+                Err(_) => frame.file.to_string(),
+            };
+
+            let Some(chunk_base) = file.strip_prefix(
+                &(format!(
+                    "{}/{}",
+                    project.container.project().await?.root_path,
+                    project.container.project().dist_dir().await?
+                )),
+            ) else {
+                // File doesn't exist within the dist dir
+                return Ok(None);
+            };
+
+            let chunk_path = format!(
+                "{}{}",
+                project
+                    .container
+                    .project()
+                    .client_relative_path()
+                    .await?
+                    .path,
+                chunk_base
+            );
+
+            let path = project
+                .container
+                .project()
+                .client_root()
+                .fs()
+                .root()
+                .join(chunk_path);
+
+            let generatable: Vc<Box<dyn GenerateSourceMap>> =
+                Vc::try_resolve_sidecast(project.container.get_versioned_content(path))
+                    .await?
+                    .context("Chunk cannot produce a sourcemap")?;
+
+            let map = generatable
+                .generate_source_map()
+                .await?
+                .context("Chunk is missing a sourcemap")?;
+
+            let token = map
+                .lookup_token(frame.line as usize, frame.column.unwrap_or(0) as usize)
+                .await?
+                .clone_value()
+                .context("Unable to trace token from sourcemap")?;
+
+            let Token::Original(token) = token else {
+                bail!("Expected token to be an OriginalToken")
+            };
+
+            let Some(source_file) = token.original_file.strip_prefix("/turbopack/[project]/")
+            else {
+                bail!("Original file outside project")
+            };
+
+            let source_content = &*project
+                .container
+                .project()
+                .project_path()
+                .join(source_file.to_string())
+                .read()
+                .await?;
+
+            let FileContent::Content(source_content) = source_content else {
+                bail!("No content for source file")
+            };
+
+            let mut source = "".to_string();
+            Read::read_to_string(&mut source_content.read(), &mut source)?;
+
+            Ok(Some(TracedSource {
+                frame: StackFrame {
+                    file: source_file.to_string(),
+                    method_name: token.name,
+                    line: token.original_line as u32,
+                    column: Some(token.original_column as u32),
+                },
+                source,
+            }))
+        })
+        .await
+        .map_err(|e| napi::Error::from_reason(PrettyPrintError(&e).to_string()))?;
+    Ok(traced_frame)
+}

packages/next-swc/crates/next-api/src/project.rs

@@ -255,13 +255,22 @@ impl ProjectContainer {
     pub fn hmr_identifiers(self: Vc<Self>) -> Vc<Vec<String>> {
         self.project().hmr_identifiers()
     }
+
+    #[turbo_tasks::function]
+    pub async fn get_versioned_content(
+        self: Vc<Self>,
+        file_path: Vc<FileSystemPath>,
+    ) -> Result<Vc<Box<dyn VersionedContent>>> {
+        let this = self.await?;
+        Ok(this.versioned_content_map.get(file_path))
+    }
 }
 
 #[turbo_tasks::value]
 pub struct Project {
     /// A root path from which all files must be nested under. Trying to access
     /// a file outside this root will fail. Think of this as a chroot.
-    root_path: String,
+    pub root_path: String,
 
     /// A path where to emit the build outputs. next.config.js's distDir.
     dist_dir: String,
@@ -374,13 +383,18 @@ impl Project {
     }
 
     #[turbo_tasks::function]
-    pub(super) async fn node_root(self: Vc<Self>) -> Result<Vc<FileSystemPath>> {
+    pub async fn dist_dir(self: Vc<Self>) -> Result<Vc<String>> {
+        Ok(Vc::cell(self.await?.dist_dir.to_string()))
+    }
+
+    #[turbo_tasks::function]
+    pub async fn node_root(self: Vc<Self>) -> Result<Vc<FileSystemPath>> {
         let this = self.await?;
         Ok(self.node_fs().root().join(this.dist_dir.to_string()))
     }
 
     #[turbo_tasks::function]
-    pub(super) fn client_root(self: Vc<Self>) -> Vc<FileSystemPath> {
+    pub fn client_root(self: Vc<Self>) -> Vc<FileSystemPath> {
         self.client_fs().root()
     }
 
@@ -394,12 +408,12 @@ impl Project {
     /// [Note] in webpack-config, it is being injected when
     /// dev && (isClient || isEdgeServer)
     #[turbo_tasks::function]
-    async fn dist_root_string(self: Vc<Self>) -> Result<Vc<String>> {
+    pub async fn dist_root_string(self: Vc<Self>) -> Result<Vc<String>> {
         Ok(self.node_root().to_string())
     }
 
     #[turbo_tasks::function]
-    pub(super) async fn client_relative_path(self: Vc<Self>) -> Result<Vc<FileSystemPath>> {
+    pub async fn client_relative_path(self: Vc<Self>) -> Result<Vc<FileSystemPath>> {
         let next_config = self.next_config().await?;
         Ok(self.client_root().join(format!(
             "{}/_next",
@@ -411,7 +425,7 @@ impl Project {
     }
 
     #[turbo_tasks::function]
-    pub(super) async fn project_path(self: Vc<Self>) -> Result<Vc<FileSystemPath>> {
+    pub async fn project_path(self: Vc<Self>) -> Result<Vc<FileSystemPath>> {
         let this = self.await?;
         let root = self.project_root_path();
         let project_relative = this.project_path.strip_prefix(&this.root_path).unwrap();

packages/next-swc/crates/next-api/src/versioned_content_map.rs

@@ -25,7 +25,7 @@ pub struct OutputAssetsOperation(Vc<OutputAssets>);
 #[derive(
     Clone, Copy, TraceRawVcs, PartialEq, Eq, ValueDebugFormat, Serialize, Deserialize, Debug,
 )]
-struct MapEntry {
+pub struct MapEntry {
     assets_operation: Vc<OutputAssets>,
 }
 

packages/next/src/build/swc/index.ts

@@ -519,6 +519,13 @@ export interface HmrIdentifiers {
   identifiers: string[]
 }
 
+export interface StackFrame {
+  file: string
+  line: number
+  column: number | undefined
+  methodName: string | undefined
+}
+
 export interface UpdateInfo {
   duration: number
   tasks: number
@@ -540,6 +547,13 @@ export interface Project {
   hmrIdentifiersSubscribe(): AsyncIterableIterator<
     TurbopackResult<HmrIdentifiers>
   >
+  traceSource(stackFrame: StackFrame): Promise<
+    | {
+        frame: StackFrame
+        source: string
+      }
+    | undefined
+  >
   updateInfoSubscribe(): AsyncIterableIterator<TurbopackResult<UpdateInfo>>
 }
 
@@ -916,6 +930,16 @@ function bindingToApi(binding: any, _wasm: boolean) {
       return subscription
     }
 
+    traceSource(stackFrame: StackFrame): Promise<
+      | {
+          frame: StackFrame
+          source: string
+        }
+      | undefined
+    > {
+      return binding.projectTraceSource(this._nativeProject, stackFrame)
+    }
+
     updateInfoSubscribe() {
       const subscription = subscribe<TurbopackResult<UpdateInfo>>(
         true,

packages/next/src/client/components/react-dev-overlay/internal/helpers/stack-frame.ts

@@ -85,10 +85,9 @@ export function getOriginalStackFrame(
   }
 
   if (
-    !(
-      source.file?.startsWith('webpack-internal:') ||
-      source.file?.startsWith('file:')
-    )
+    source.file === '<anonymous>' ||
+    source.file?.match(/^node:/) ||
+    source.file?.match(/https?:\/\//)
   ) {
     return Promise.resolve({
       error: false,