feat(ts/fast-strip): Throw an object instead of string (#10162)

**Description:**

Throw an object from `@swc/wasm-typescript`.

**Related issue:**

 - Closes #10150

Author: kdy1

bindings/Cargo.lock

@@ -22,7 +22,6 @@ serde                = { workspace = true, features = ["derive"] }
 serde-wasm-bindgen   = { workspace = true }
 serde_json           = { workspace = true }
 swc_common           = { workspace = true }
-swc_error_reporters  = { workspace = true }
 swc_fast_ts_strip    = { workspace = true, features = ["wasm-bindgen"] }
 tracing              = { workspace = true, features = ["max_level_off"] }
 wasm-bindgen         = { workspace = true, features = ["enable-interning"] }

bindings/binding_typescript_wasm/Cargo.toml

@@ -1,8 +1,14 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`transform in strip-only mode should not emit 'Caused by: failed to parse' 1`] = `
-"{"code":"InvalidSyntax","message":"await isn't allowed in non-async function","snippet":"Promise","filename":"test.ts","line":1,"column":23}
-"
+Map {
+  "code" => "InvalidSyntax",
+  "column" => 23,
+  "filename" => "test.ts",
+  "line" => 1,
+  "message" => "await isn't allowed in non-async function",
+  "snippet" => "Promise",
+}
 `;
 
 exports[`transform in strip-only mode should remove declare enum 1`] = `
@@ -32,13 +38,27 @@ exports[`transform in strip-only mode should remove declare enum 3`] = `
 `;
 
 exports[`transform in strip-only mode should report correct error for syntax error 1`] = `
-"{"code":"InvalidSyntax","message":"Expected ';', '}' or <eof>","snippet":"syntax","filename":"test.ts","line":1,"column":25}
-"
+Map {
+  "code" => "InvalidSyntax",
+  "column" => 25,
+  "filename" => "test.ts",
+  "line" => 1,
+  "message" => "Expected ';', '}' or <eof>",
+  "snippet" => "syntax",
+}
 `;
 
 exports[`transform in strip-only mode should report correct error for unsupported syntax 1`] = `
-"{"code":"UnsupportedSyntax","message":"TypeScript enum is not supported in strip-only mode","snippet":"enum Foo {\\n                    a, b    \\n                    }","filename":"test.ts","line":1,"column":0}
-"
+Map {
+  "code" => "UnsupportedSyntax",
+  "column" => 0,
+  "filename" => "test.ts",
+  "line" => 1,
+  "message" => "TypeScript enum is not supported in strip-only mode",
+  "snippet" => "enum Foo {
+                    a, b    
+                    }",
+}
 `;
 
 exports[`transform in strip-only mode should strip complex expressions 1`] = `
@@ -95,38 +115,80 @@ exports[`transform in strip-only mode should strip type declarations 1`] = `
 `;
 
 exports[`transform in strip-only mode should throw an error when it encounters a module 1`] = `
-"{"code":"UnsupportedSyntax","message":"\`module\` keyword is not supported. Use \`namespace\` instead.","snippet":"module foo","filename":"test.ts","line":1,"column":0}
-"
+Map {
+  "code" => "UnsupportedSyntax",
+  "column" => 0,
+  "filename" => "test.ts",
+  "line" => 1,
+  "message" => "\`module\` keyword is not supported. Use \`namespace\` instead.",
+  "snippet" => "module foo",
+}
 `;
 
 exports[`transform in strip-only mode should throw an error when it encounters a module 2`] = `
-"{"code":"UnsupportedSyntax","message":"\`module\` keyword is not supported. Use \`namespace\` instead.","snippet":"module foo","filename":"test.ts","line":1,"column":8}
-"
+Map {
+  "code" => "UnsupportedSyntax",
+  "column" => 8,
+  "filename" => "test.ts",
+  "line" => 1,
+  "message" => "\`module\` keyword is not supported. Use \`namespace\` instead.",
+  "snippet" => "module foo",
+}
 `;
 
 exports[`transform in strip-only mode should throw an error when it encounters a namespace 1`] = `
-"{"code":"UnsupportedSyntax","message":"TypeScript namespace declaration is not supported in strip-only mode","snippet":"namespace Foo { export const m = 1; }","filename":"test.ts","line":1,"column":0}
-"
+Map {
+  "code" => "UnsupportedSyntax",
+  "column" => 0,
+  "filename" => "test.ts",
+  "line" => 1,
+  "message" => "TypeScript namespace declaration is not supported in strip-only mode",
+  "snippet" => "namespace Foo { export const m = 1; }",
+}
 `;
 
 exports[`transform in strip-only mode should throw an error when it encounters an enum 1`] = `
-"{"code":"UnsupportedSyntax","message":"TypeScript enum is not supported in strip-only mode","snippet":"enum Foo {}","filename":"test.ts","line":1,"column":0}
-"
+Map {
+  "code" => "UnsupportedSyntax",
+  "column" => 0,
+  "filename" => "test.ts",
+  "line" => 1,
+  "message" => "TypeScript enum is not supported in strip-only mode",
+  "snippet" => "enum Foo {}",
+}
 `;
 
 exports[`transform in transform mode shoud throw an object even with deprecatedTsModuleAsError = true 1`] = `
-"{"code":"UnsupportedSyntax","message":"\`module\` keyword is not supported. Use \`namespace\` instead.","snippet":"module F","filename":"<anon>","line":1,"column":0}
-"
+Map {
+  "code" => "UnsupportedSyntax",
+  "column" => 0,
+  "filename" => "<anon>",
+  "line" => 1,
+  "message" => "\`module\` keyword is not supported. Use \`namespace\` instead.",
+  "snippet" => "module F",
+}
 `;
 
 exports[`transform in transform mode should throw an error when it encounters a declared module 1`] = `
-"{"code":"UnsupportedSyntax","message":"\`module\` keyword is not supported. Use \`namespace\` instead.","snippet":"module foo","filename":"test.ts","line":1,"column":8}
-"
+Map {
+  "code" => "UnsupportedSyntax",
+  "column" => 8,
+  "filename" => "test.ts",
+  "line" => 1,
+  "message" => "\`module\` keyword is not supported. Use \`namespace\` instead.",
+  "snippet" => "module foo",
+}
 `;
 
 exports[`transform in transform mode should throw an error when it encounters a module 1`] = `
-"{"code":"UnsupportedSyntax","message":"\`module\` keyword is not supported. Use \`namespace\` instead.","snippet":"module foo","filename":"test.ts","line":1,"column":0}
-"
+Map {
+  "code" => "UnsupportedSyntax",
+  "column" => 0,
+  "filename" => "test.ts",
+  "line" => 1,
+  "message" => "\`module\` keyword is not supported. Use \`namespace\` instead.",
+  "snippet" => "module foo",
+}
 `;
 
 exports[`transform should strip types 1`] = `

bindings/binding_typescript_wasm/__tests__/__snapshots__/transform.js.snap

@@ -1,7 +1,16 @@
+use std::{
+    mem::take,
+    sync::{Arc, Mutex},
+};
+
 use anyhow::Error;
 use js_sys::Uint8Array;
-use swc_common::{errors::ColorConfig, sync::Lrc, SourceMap, GLOBALS};
-use swc_error_reporters::handler::{try_with_json_handler, HandlerOpts};
+use serde::Serialize;
+use swc_common::{
+    errors::{DiagnosticBuilder, DiagnosticId, Emitter, Handler, HANDLER},
+    sync::Lrc,
+    SourceMap, SourceMapper, GLOBALS,
+};
 use swc_fast_ts_strip::{Options, TransformOutput};
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::{future_to_promise, js_sys::Promise};
@@ -43,28 +52,127 @@ pub fn transform_sync(input: JsValue, options: JsValue) -> Result<JsValue, JsVal
         }
     };
 
-    let result = GLOBALS
-        .set(&Default::default(), || operate(input, options))
-        .map_err(convert_err)?;
+    let result = GLOBALS.set(&Default::default(), || operate(input, options));
 
-    Ok(serde_wasm_bindgen::to_value(&result)?)
+    match result {
+        Ok(v) => Ok(serde_wasm_bindgen::to_value(&v)?),
+        Err(v) => Err(serde_wasm_bindgen::to_value(&v[0])?),
+    }
 }
 
-fn operate(input: String, options: Options) -> Result<TransformOutput, Error> {
+fn operate(input: String, options: Options) -> Result<TransformOutput, Vec<serde_json::Value>> {
     let cm = Lrc::new(SourceMap::default());
 
-    try_with_json_handler(
-        cm.clone(),
-        HandlerOpts {
-            color: ColorConfig::Never,
-            skip_filename: false,
-        },
-        |handler| {
-            swc_fast_ts_strip::operate(&cm, handler, input, options).map_err(anyhow::Error::new)
-        },
-    )
+    try_with_json_handler(cm.clone(), |handler| {
+        swc_fast_ts_strip::operate(&cm, handler, input, options).map_err(anyhow::Error::new)
+    })
+}
+
+#[derive(Clone)]
+struct LockedWriter {
+    errors: Arc<Mutex<Vec<serde_json::Value>>>,
+    cm: Lrc<SourceMap>,
+}
+
+fn try_with_json_handler<F, Ret>(cm: Lrc<SourceMap>, op: F) -> Result<Ret, Vec<serde_json::Value>>
+where
+    F: FnOnce(&Handler) -> Result<Ret, Error>,
+{
+    let wr = LockedWriter {
+        errors: Default::default(),
+        cm,
+    };
+    let emitter: Box<dyn Emitter> = Box::new(wr.clone());
+
+    let handler = Handler::with_emitter(true, false, emitter);
+
+    let ret = HANDLER.set(&handler, || op(&handler));
+
+    if handler.has_errors() {
+        let mut lock = wr.errors.lock().unwrap();
+        let error = take(&mut *lock);
+
+        Err(error)
+    } else {
+        Ok(ret.expect("it should not fail without emitting errors to handler"))
+    }
+}
+
+impl Emitter for LockedWriter {
+    fn emit(&mut self, db: &DiagnosticBuilder) {
+        let d = &**db;
+
+        let children = d
+            .children
+            .iter()
+            .map(|d| todo!("json subdiagnostic: {d:?}"))
+            .collect::<Vec<_>>();
+
+        let error_code = match &d.code {
+            Some(DiagnosticId::Error(s)) => Some(&**s),
+            Some(DiagnosticId::Lint(s)) => Some(&**s),
+            None => None,
+        };
+
+        let loc = d
+            .span
+            .primary_span()
+            .and_then(|span| self.cm.try_lookup_char_pos(span.lo()).ok());
+
+        let snippet = d
+            .span
+            .primary_span()
+            .and_then(|span| self.cm.span_to_snippet(span).ok());
+
+        let filename = loc.as_ref().map(|loc| loc.file.name.to_string());
+
+        let error = JsonDiagnostic {
+            code: error_code,
+            message: &d.message[0].0,
+            snippet: snippet.as_deref(),
+            filename: filename.as_deref(),
+            line: loc.as_ref().map(|loc| loc.line),
+            column: loc.as_ref().map(|loc| loc.col_display),
+            children,
+        };
+
+        self.errors
+            .lock()
+            .unwrap()
+            .push(serde_json::to_value(&error).unwrap());
+    }
+
+    fn take_diagnostics(&mut self) -> Vec<String> {
+        Default::default()
+    }
+}
+
+#[derive(Serialize)]
+struct JsonDiagnostic<'a> {
+    /// Error code
+    #[serde(skip_serializing_if = "Option::is_none")]
+    code: Option<&'a str>,
+    message: &'a str,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    snippet: Option<&'a str>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    filename: Option<&'a str>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    line: Option<usize>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    column: Option<usize>,
+
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    children: Vec<JsonSubdiagnostic<'a>>,
 }
 
-pub fn convert_err(err: Error) -> wasm_bindgen::prelude::JsValue {
-    err.to_string().into()
+#[derive(Serialize)]
+struct JsonSubdiagnostic<'a> {
+    message: &'a str,
+    snippet: Option<&'a str>,
+    filename: &'a str,
+    line: usize,
 }