enhance(errors): Integrate miette for enhanced diagnostic reporting

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

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

@@ -13,7 +13,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};
@@ -122,20 +122,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

@@ -7,7 +7,7 @@
 )]
 
 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::*;
@@ -170,7 +170,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()
             }
@@ -183,7 +183,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")
     });