feat(errors): Integrate miette for enhanced diagnostic reporting (#10241)

# Description

SWC api `try_with_handler` only return anyhow!(msg) Err, it'a will lose many message about error stack, level ...,
To express more error message in swc, we can return `Vec<Diagnostic>` in `try_with_handler`;

try_with_handler_diagnostic return a `Result<Ret, Vec<Diagnostic>>`. Later user can using `diagnostic.code` to distinguish what kind error is.




- Added `miette` as a dependency for improved error handling and reporting.
- Updated diagnostic handling to utilize `miette` for pretty printing errors.
- Introduced a new `ThreadSafetyDiagnostics` to manage and store diagnostics.
- Refactored emitters to support the new diagnostic structure and ensure compatibility with `miette`.
- Enhanced error handling in various components to provide clearer and more informative error messages.



# BREAKING CHANGE:

The api `try_with_handler` would not return anyhow!(msg).
It's will return WrapperDiagnostics as it's Err. Then you can take
diagnostics from WrapperDiagnostics or get pretty string from it.

```diff
- pub fn try_with_handler<F, Ret>(cm: Lrc<SourceMap>, config: HandlerOpts, op:F) -> Result<Ret, anyhow::error>;
+ pub fn try_with_handler<F, Ret>(cm: Lrc<SourceMap>, config: HandlerOpts, op:F) -> Result<Ret, WrapperDiagnostics>;
```

```rust
/// A wrapper around a value that also contains a list of diagnostics.
/// It helps swc error system migrate to the new error reporting system.
pub struct WrapperDiagnostics {
    diagnostics: Vec<SwcDignostic>,
   ....
}

impl WrapperDiagnostics {
    pub fn diagnostics(&self) -> &[Diagnostic] {
        &self.diagnostics
    }

    pub fn to_pretty_error(&self) -> anyhow::Error {
        let error_msg = self.to_pretty_string();

        anyhow::anyhow!(error_msg)
    }


   pub fn to_pretty_string(&self) -> String {
      .... 
    }
}
```

### formatting

In SWC, the `Syntax Error` message formatting dependents anyhow. 
```rust
// input: Foo {}
// https://play.swc.rs/?version=1.11.13&code=H4sIAAAAAAAAA3PLz1eorgUAR6TWygYAAAA%3D&config=H4sIAAAAAAAAA1WPSw7DIAwF9zkF8rrbdtE79BAWdSIifrKJVBTl7iUE0maH3xsz8jooBbNoeKq1PMsQkYX4nEsi2Sf8lARIOxTNJia49XaWvRrRCtVoOxpIyBOluiX3hoMNQajjLXPGmzH%2FC3VwkUnkCu4o%2BsnSVTc0JbjwXmrZDkk50qF%2FwA%2FqsvNjMPLqm4kXGrYvhlQioBQBAAA%3D

  x Expected ';', '}' or <eof>
   ,-[input.js:1:1]
 1 | Foo {}
   : ^|^ ^
   :  `-- This is the expression part of an expression statement
   `----


Caused by:
    0: failed to process js file
    1: Syntax Error
```

So if we return `Vec<Diagnostic>` instead of `anyhow:Error`, The output
formatting would have a litter breaking change.
```diff
  x Expected ';', '}' or <eof>
   ,-[input.js:1:1]
 1 | Foo {}
   : ^|^ ^
   :  `-- This is the expression part of an expression statement
   `----

- Caused by:
-    0: failed to process js file
-    1: Syntax Error
+ x Syntax Error
```

# Related issue:

 - Closes #10192

---------

Co-authored-by: Donny/강동윤 <[email protected]>

Author: GiveMe-A-Name

.changeset/sweet-days-notice.md

@@ -0,0 +1,6 @@
+---
+swc_error_reporters: major
+swc_common: minor
+---
+
+enhance(errors_report): integrate miette for enhanced diagnostic reporting

bindings/binding_core_node/src/util.rs

@@ -67,32 +67,34 @@ pub fn try_with<F, Ret>(
 where
     F: FnOnce(&Handler) -> Result<Ret, Error>,
 {
-    GLOBALS.set(&Default::default(), || {
-        try_with_handler(
-            cm,
-            swc_core::base::HandlerOpts {
-                skip_filename,
-                ..Default::default()
-            },
-            |handler| {
-                //
-                let result = catch_unwind(AssertUnwindSafe(|| op(handler)));
+    GLOBALS
+        .set(&Default::default(), || {
+            try_with_handler(
+                cm,
+                swc_core::base::HandlerOpts {
+                    skip_filename,
+                    ..Default::default()
+                },
+                |handler| {
+                    //
+                    let result = catch_unwind(AssertUnwindSafe(|| op(handler)));
 
-                let p = match result {
-                    Ok(v) => return v,
-                    Err(v) => v,
-                };
+                    let p = match result {
+                        Ok(v) => return v,
+                        Err(v) => v,
+                    };
 
-                if let Some(s) = p.downcast_ref::<String>() {
-                    Err(anyhow!("failed to handle: {}", s))
-                } else if let Some(s) = p.downcast_ref::<&str>() {
-                    Err(anyhow!("failed to handle: {}", s))
-                } else {
-                    Err(anyhow!("failed to handle with unknown panic message"))
-                }
-            },
-        )
-    })
+                    if let Some(s) = p.downcast_ref::<String>() {
+                        Err(anyhow!("failed to handle: {}", s))
+                    } else if let Some(s) = p.downcast_ref::<&str>() {
+                        Err(anyhow!("failed to handle: {}", s))
+                    } else {
+                        Err(anyhow!("failed to handle with unknown panic message"))
+                    }
+                },
+            )
+        })
+        .map_err(|e| e.to_pretty_error())
 }
 
 // This was originally under swc_nodejs_common, but this is not a public

bindings/binding_core_wasm/__tests__/error.js

@@ -1,6 +1,6 @@
 const swc = require("../pkg");
 
-it("properly reports error", function () {
+it("properly reports error", () => {
     expect(() => {
         swc.transformSync("Foo {}", {});
     }).toThrow("Syntax Error");

bindings/binding_html_node/src/util.rs

@@ -32,4 +32,5 @@ where
             }
         },
     )
+    .map_err(|e| e.to_pretty_error())
 }

bindings/binding_minifier_node/src/util.rs

@@ -60,32 +60,34 @@ pub fn try_with<F, Ret>(cm: Lrc<SourceMap>, skip_filename: bool, op: F) -> Resul
 where
     F: FnOnce(&Handler) -> Result<Ret, Error>,
 {
-    GLOBALS.set(&Default::default(), || {
-        try_with_handler(
-            cm,
-            HandlerOpts {
-                skip_filename,
-                ..Default::default()
-            },
-            |handler| {
-                //
-                let result = catch_unwind(AssertUnwindSafe(|| op(handler)));
+    GLOBALS
+        .set(&Default::default(), || {
+            try_with_handler(
+                cm,
+                HandlerOpts {
+                    skip_filename,
+                    ..Default::default()
+                },
+                |handler| {
+                    //
+                    let result = catch_unwind(AssertUnwindSafe(|| op(handler)));
 
-                let p = match result {
-                    Ok(v) => return v,
-                    Err(v) => v,
-                };
+                    let p = match result {
+                        Ok(v) => return v,
+                        Err(v) => v,
+                    };
 
-                if let Some(s) = p.downcast_ref::<String>() {
-                    Err(anyhow!("failed to handle: {}", s))
-                } else if let Some(s) = p.downcast_ref::<&str>() {
-                    Err(anyhow!("failed to handle: {}", s))
-                } else {
-                    Err(anyhow!("failed to handle with unknown panic message"))
-                }
-            },
-        )
-    })
+                    if let Some(s) = p.downcast_ref::<String>() {
+                        Err(anyhow!("failed to handle: {}", s))
+                    } else if let Some(s) = p.downcast_ref::<&str>() {
+                        Err(anyhow!("failed to handle: {}", s))
+                    } else {
+                        Err(anyhow!("failed to handle with unknown panic message"))
+                    }
+                },
+            )
+        })
+        .map_err(|e| e.to_pretty_error())
 }
 
 // This was originally under swc_nodejs_common, but this is not a public

bindings/binding_typescript_wasm/src/lib.rs

@@ -14,7 +14,7 @@ use swc_common::{
     sync::Lrc,
     SourceMap, Span, GLOBALS,
 };
-use swc_error_reporters::{to_miette_source_code, to_miette_span, PrettyEmitterConfig};
+use swc_error_reporters::{convert_span, to_pretty_source_code};
 use swc_fast_ts_strip::{Options, TransformOutput};
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::{future_to_promise, js_sys::Promise};
@@ -125,20 +125,15 @@ where
 }
 
 impl Emitter for JsonErrorWriter {
-    fn emit(&mut self, db: &DiagnosticBuilder) {
+    fn emit(&mut self, db: &mut DiagnosticBuilder) {
         let d = &**db;
 
         let snippet = d.span.primary_span().and_then(|span| {
             let mut snippet = String::new();
             match self.reporter.render_report(
                 &mut snippet,
                 &Snippet {
-                    source_code: &to_miette_source_code(
-                        &self.cm,
-                        &PrettyEmitterConfig {
-                            skip_filename: true,
-                        },
-                    ),
+                    source_code: &to_pretty_source_code(&self.cm, true),
                     span,
                 },
             ) {
@@ -246,7 +241,7 @@ impl miette::Diagnostic for Snippet<'_> {
     fn labels(&self) -> Option<Box<dyn Iterator<Item = miette::LabeledSpan> + '_>> {
         Some(Box::new(once(LabeledSpan::new_with_span(
             None,
-            to_miette_span(self.span),
+            convert_span(self.span),
         ))))
     }
 }

crates/binding_macros/src/wasm.rs

@@ -60,9 +60,11 @@ pub fn try_with_handler_globals<F, Ret>(
 where
     F: FnOnce(&Handler) -> Result<Ret, Error>,
 {
-    GLOBALS.set(&Default::default(), || {
-        swc::try_with_handler(cm, config, op)
-    })
+    GLOBALS
+        .set(&Default::default(), || {
+            swc::try_with_handler(cm, config, op)
+        })
+        .map_err(|e| e.to_pretty_error())
 }
 
 /// Get global sourcemap

crates/dbg-swc/src/main.rs

@@ -1,6 +1,6 @@
 use std::{env, path::PathBuf, str::FromStr, sync::Arc};
 
-use anyhow::{bail, Result};
+use anyhow::{bail, Error, Result};
 use clap::{StructOpt, Subcommand};
 use es::EsCommand;
 use swc_common::{
@@ -51,7 +51,7 @@ fn init() -> Result<()> {
     Ok(())
 }
 
-fn main() -> Result<()> {
+fn main() -> Result<(), Error> {
     init()?;
 
     let cm = Arc::new(SourceMap::default());
@@ -104,7 +104,8 @@ fn main() -> Result<()> {
                     })
                 })
             },
-        );
+        )
+        .map_err(|e| e.to_pretty_error());
     }
 
     let args = AppArgs::parse();
@@ -118,9 +119,10 @@ fn main() -> Result<()> {
         |handler| {
             GLOBALS.set(&Globals::default(), || {
                 HANDLER.set(handler, || match args.cmd {
-                    Cmd::Es(cmd) => cmd.run(cm),
+                    Cmd::Es(cmd) => cmd.run(cm.clone()),
                 })
             })
         },
     )
+    .map_err(|e| e.to_pretty_error())
 }

crates/swc/src/plugin.rs

@@ -12,7 +12,7 @@ use anyhow::{Context, Result};
 use atoms::Atom;
 use common::FileName;
 use serde::{Deserialize, Serialize};
-use swc_common::errors::HANDLER;
+use swc_common::errors::{DiagnosticId, HANDLER};
 use swc_ecma_ast::Pass;
 #[cfg(feature = "plugin")]
 use swc_ecma_ast::*;
@@ -184,7 +184,7 @@ impl Fold for RustPlugins {
             Ok(program) => program.expect_module(),
             Err(err) => {
                 HANDLER.with(|handler| {
-                    handler.err(&err.to_string());
+                    handler.err_with_code(&err.to_string(), DiagnosticId::Error("plugin".into()));
                 });
                 Module::default()
             }
@@ -197,7 +197,7 @@ impl Fold for RustPlugins {
             Ok(program) => program.expect_script(),
             Err(err) => {
                 HANDLER.with(|handler| {
-                    handler.err(&err.to_string());
+                    handler.err_with_code(&err.to_string(), DiagnosticId::Error("plugin".into()));
                 });
                 Script::default()
             }

crates/swc/tests/error_msg.rs

@@ -82,6 +82,7 @@ fn fixture(input: PathBuf) {
                 Ok(())
             },
         )
+        .map_err(|e| e.to_pretty_error())
         .expect_err("should fail")
     });