feat(diagnostic): support minification error

crates/node_binding/binding.d.ts

@@ -1269,6 +1269,7 @@ export interface JsStatsError {
   moduleDescriptor?: JsModuleDescriptor
   message: string
   chunkName?: string
+  code?: string
   chunkEntry?: boolean
   chunkInitial?: boolean
   loc?: string
@@ -1408,6 +1409,7 @@ export interface JsStatsWarning {
   name?: string
   message: string
   chunkName?: string
+  code?: string
   chunkEntry?: boolean
   chunkInitial?: boolean
   file?: string

crates/node_binding/src/stats.rs

@@ -141,6 +141,7 @@ pub struct JsStatsError<'a> {
   pub module_descriptor: Option<JsModuleDescriptorWrapper<'a>>,
   pub message: String,
   pub chunk_name: Option<&'a str>,
+  pub code: Option<String>,
   pub chunk_entry: Option<bool>,
   pub chunk_initial: Option<bool>,
   pub loc: Option<String>,
@@ -163,6 +164,7 @@ impl<'a> From<rspack_core::StatsError<'a>> for JsStatsError<'a> {
         .into()
       }),
       message: stats.message,
+      code: stats.code,
       loc: stats.loc,
       file: stats.file.map(|f| f.as_str()),
       chunk_name: stats.chunk_name,
@@ -187,6 +189,7 @@ pub struct JsStatsWarning<'a> {
   pub name: Option<String>,
   pub message: String,
   pub chunk_name: Option<&'a str>,
+  pub code: Option<String>,
   pub chunk_entry: Option<bool>,
   pub chunk_initial: Option<bool>,
   pub file: Option<&'a str>,
@@ -210,6 +213,7 @@ impl<'a> From<rspack_core::StatsWarning<'a>> for JsStatsWarning<'a> {
       name: stats.name,
       message: stats.message,
       file: stats.file.map(|f| f.as_str()),
+      code: stats.code,
       chunk_name: stats.chunk_name,
       chunk_entry: stats.chunk_entry,
       chunk_initial: stats.chunk_initial,

crates/rspack_core/src/concatenated_module.rs

@@ -1732,7 +1732,7 @@ impl ConcatenatedModule {
               &fm,
               span.start as usize,
               span.end as usize,
-              "JavaScript parsing error:\n".to_string(),
+              "JavaScript parse error:\n".to_string(),
               err.kind().msg().to_string(),
             )
             .with_kind(DiagnosticKind::JavaScript)

crates/rspack_core/src/diagnostics.rs

@@ -58,21 +58,6 @@ impl miette::Diagnostic for ModuleBuildError {
   fn severity(&self) -> Option<miette::Severity> {
     self.0.severity()
   }
-  fn help<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
-    self.0.help()
-  }
-  fn url<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
-    self.0.url()
-  }
-  fn source_code(&self) -> Option<&dyn miette::SourceCode> {
-    self.0.source_code()
-  }
-  fn labels(&self) -> Option<Box<dyn Iterator<Item = miette::LabeledSpan> + '_>> {
-    self.0.labels()
-  }
-  fn related<'a>(&'a self) -> Option<Box<dyn Iterator<Item = &'a dyn miette::Diagnostic> + 'a>> {
-    self.0.related()
-  }
   fn diagnostic_source(&self) -> Option<&dyn Diagnostic> {
     Some(self.0.as_ref())
   }
@@ -258,3 +243,36 @@ pub fn map_box_diagnostics_to_module_parse_diagnostics(
     })
     .collect()
 }
+
+/////////////// Minify error
+
+#[derive(Debug)]
+pub struct MinifyError(pub Error);
+
+impl std::error::Error for MinifyError {
+  fn source(&self) -> ::core::option::Option<&(dyn std::error::Error + 'static)> {
+    Some(<Error as AsRef<dyn std::error::Error>>::as_ref(&self.0))
+  }
+}
+
+impl std::fmt::Display for MinifyError {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    write!(f, "Chunk minification failed:")
+  }
+}
+
+impl miette::Diagnostic for MinifyError {
+  fn code<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
+    match self.severity().unwrap_or(miette::Severity::Error) {
+      miette::Severity::Advice => unreachable!("miette::Severity::Advice should not be used"),
+      miette::Severity::Warning => Some(Box::new("ChunkMinificationWarning")),
+      miette::Severity::Error => Some(Box::new("ChunkMinificationError")),
+    }
+  }
+  fn severity(&self) -> Option<miette::Severity> {
+    self.0.severity()
+  }
+  fn diagnostic_source(&self) -> Option<&dyn Diagnostic> {
+    Some(self.0.as_ref())
+  }
+}

crates/rspack_core/src/stats/mod.rs

@@ -616,10 +616,12 @@ impl Stats<'_> {
           self.compilation,
           &self.compilation.options,
         );
+        let code = d.code().map(|code| code.to_string());
         StatsError {
           message: diagnostic_displayer
             .emit_diagnostic(d)
             .expect("should print diagnostics"),
+          code,
           module_identifier,
           module_name,
           module_id: module_id.flatten(),
@@ -675,11 +677,14 @@ impl Stats<'_> {
           &self.compilation.options,
         );
 
+        let code = d.code().map(|code| code.to_string());
+
         StatsWarning {
           name: d.code().map(|c| c.to_string()),
           message: diagnostic_displayer
             .emit_diagnostic(d)
             .expect("should print diagnostics"),
+          code,
           module_identifier,
           module_name,
           module_id: module_id.flatten(),

crates/rspack_core/src/stats/struct.rs

@@ -40,6 +40,7 @@ pub struct ExtendedStatsOptions {
 #[derive(Debug)]
 pub struct StatsError<'a> {
   pub message: String,
+  pub code: Option<String>,
   pub module_identifier: Option<ModuleIdentifier>,
   pub module_name: Option<Cow<'a, str>>,
   pub module_id: Option<ModuleId>,
@@ -59,6 +60,7 @@ pub struct StatsError<'a> {
 pub struct StatsWarning<'a> {
   pub name: Option<String>,
   pub message: String,
+  pub code: Option<String>,
   pub module_identifier: Option<ModuleIdentifier>,
   pub module_name: Option<Cow<'a, str>>,
   pub module_id: Option<ModuleId>,

crates/rspack_javascript_compiler/src/error.rs

@@ -85,7 +85,7 @@ pub fn ecma_parse_error_deduped_to_rspack_error(
     fm,
     span.start as usize,
     span.end as usize,
-    "JavaScript parsing error".into(),
+    "JavaScript parse error".into(),
     message,
   )
   .with_kind(DiagnosticKind::JavaScript)

crates/rspack_plugin_css/src/utils.rs

@@ -414,8 +414,8 @@ pub fn css_parsing_traceable_error(
     start as usize,
     end as usize,
     match severity {
-      RspackSeverity::Error => "CSS parsing error".to_string(),
-      RspackSeverity::Warn => "CSS parsing warning".to_string(),
+      RspackSeverity::Error => "CSS parse error".to_string(),
+      RspackSeverity::Warn => "CSS parse warning".to_string(),
     },
     message.into(),
   )

crates/rspack_plugin_html/src/parser.rs

@@ -84,7 +84,7 @@ pub fn html_parse_error_to_traceable_error(error: Error, fm: &SourceFile) -> rsp
     fm,
     span.start as usize,
     span.end as usize,
-    "HTML parsing error".to_string(),
+    "HTML parse error".to_string(),
     message.to_string(),
   )
   .with_kind(DiagnosticKind::Html);

crates/rspack_plugin_javascript/src/parser_plugin/check_var_decl.rs

@@ -38,14 +38,14 @@ impl CheckVarDeclaratorIdent {
     if is_reserved_word_in_strict(ident.sym.as_str()) {
       if parser.is_strict() {
         parser.errors.push(Box::new(create_traceable_error(
-          "JavaScript parsing error".into(),
+          "JavaScript parse error".into(),
           format!("The keyword '{}' is reserved in strict mode", ident.sym),
           parser.source_file,
           ident.span().into(),
         )));
       } else {
         parser.errors.push(Box::new(create_traceable_error(
-          "JavaScript parsing error".into(),
+          "JavaScript parse error".into(),
           format!("{} is disallowed as a lexically bound name", ident.sym),
           parser.source_file,
           ident.span().into(),

crates/rspack_plugin_javascript/src/parser_plugin/esm_detection_parser_plugin.rs

@@ -16,7 +16,7 @@ use crate::{
 impl JavascriptParser<'_> {
   fn throw_top_level_await_error(&mut self, msg: String, span: Span) {
     self.errors.push(Box::new(create_traceable_error(
-      "JavaScript parsing error".into(),
+      "JavaScript parse error".into(),
       msg,
       self.source_file,
       span.into(),

crates/rspack_plugin_javascript/src/utils/mod.rs

@@ -61,7 +61,7 @@ pub fn ecma_parse_error_deduped_to_rspack_error(
     fm,
     span.start as usize,
     span.end as usize,
-    format!("{file_type} parsing error"),
+    format!("{file_type} parse error"),
     message,
   )
   .with_kind(diagnostic_kind)

crates/rspack_plugin_json/src/lib.rs

@@ -98,7 +98,7 @@ impl ParserAndGenerator for JsonParserAndGenerator {
               // one character offset
               start_offset,
               start_offset + 1,
-              "Json parsing error".to_string(),
+              "JSON parse error".to_string(),
               format!("Unexpected character {ch}"),
             )
             .with_kind(DiagnosticKind::Json)
@@ -113,7 +113,7 @@ impl ParserAndGenerator for JsonParserAndGenerator {
               source.into_owned(),
               offset,
               offset,
-              "Json parsing error".to_string(),
+              "JSON parse error".to_string(),
               format!("{e}"),
             )
             .with_kind(DiagnosticKind::Json)

crates/rspack_plugin_lightning_css_minimizer/src/lib.rs

@@ -15,6 +15,7 @@ use lightningcss::{
 use rayon::prelude::*;
 use regex::Regex;
 use rspack_core::{
+  diagnostics::MinifyError,
   rspack_sources::{
     MapOptions, RawStringSource, SourceExt, SourceMap, SourceMapSource, SourceMapSourceOptions,
   },
@@ -297,7 +298,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
       }
       original.get_info_mut().minimized.replace(true);
       Ok(())
-    })?;
+    }).map_err(MinifyError)?;
 
   compilation.extend_diagnostics(all_warnings.into_inner().expect("should lock"));
 

crates/rspack_plugin_swc_js_minimizer/src/lib.rs

@@ -12,14 +12,15 @@ use once_cell::sync::OnceCell;
 use rayon::prelude::*;
 use regex::Regex;
 use rspack_core::{
+  diagnostics::MinifyError,
   rspack_sources::{
     ConcatSource, MapOptions, RawStringSource, Source, SourceExt, SourceMapSource,
     SourceMapSourceOptions,
   },
   AssetInfo, ChunkUkey, Compilation, CompilationAsset, CompilationParams, CompilationProcessAssets,
   CompilerCompilation, Plugin, PluginContext,
 };
-use rspack_error::{miette::IntoDiagnostic, Diagnostic, Result};
+use rspack_error::{miette::IntoDiagnostic, Diagnostic, DiagnosticExt, Result};
 use rspack_hash::RspackHash;
 use rspack_hook::{plugin, plugin_hook};
 use rspack_javascript_compiler::JavaScriptCompiler;
@@ -304,7 +305,10 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         ) {
             Ok(r) => r,
             Err(e) => {
-              tx.send(e.into()).into_diagnostic()?;
+              let errors = e.into_inner().into_iter().map(|err| {
+                Diagnostic::from(MinifyError(err).boxed()).with_file(Some(filename.into()))
+              }).collect::<Vec<_>>();
+              tx.send(errors).into_diagnostic()?;
               return Ok(())
             },
         };

packages/rspack-test-tools/etc/test-tools.api.md

@@ -760,6 +760,10 @@ export interface IDiagnosticProcessorOptions<T extends ECompilerType> extends Om
     format?: (output: string) => string;
     // (undocumented)
     snapshot: string;
+    // (undocumented)
+    snapshotErrors: string;
+    // (undocumented)
+    snapshotWarning: string;
 }
 
 // @public (undocumented)

packages/rspack-test-tools/package.json

@@ -58,6 +58,7 @@
     "jest-snapshot": "29.7.0",
     "jsdom": "^26.1.0",
     "memfs": "4.17.2",
+    "loader-utils": "^2.0.4",
     "path-serializer": "0.4.0",
     "pretty-format": "29.7.0",
     "rimraf": "^5.0.10",
@@ -112,4 +113,4 @@
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"
   }
-}
+}

packages/rspack-test-tools/src/case/diagnostic.ts

@@ -9,6 +9,8 @@ const creator = new BasicCaseCreator({
 		new DiagnosticProcessor({
 			name,
 			snapshot: "./stats.err",
+			snapshotErrors: "./raw-error.err",
+			snapshotWarning: "./raw-warning.err",
 			configFiles: ["rspack.config.js", "webpack.config.js"],
 			compilerType: ECompilerType.Rspack,
 			format: (output: string) => {

packages/rspack-test-tools/src/helper/expect/to-match-file-snapshot.ts

@@ -8,10 +8,15 @@ import chalk from "chalk";
 import filenamify from "filenamify";
 import { diff } from "jest-diff";
 import type { FileMatcherOptions } from "../../../jest";
+import { serializers } from "../serializers";
 
 const { serialize } = require(
 	path.join(path.dirname(require.resolve("jest-snapshot")), "./utils.js")
 );
+// get jest builtin serializers
+const { getSerializers } = require(
+	path.join(path.dirname(require.resolve("jest-snapshot")), "./plugins.js")
+);
 /**
  * Check if 2 strings or buffer are equal
  */
@@ -44,10 +49,15 @@ export function toMatchFileSnapshot(
 	filepath: string,
 	options: FileMatcherOptions = {}
 ) {
-	const content =
-		Buffer.isBuffer(rawContent) || typeof rawContent === "string"
-			? rawContent
-			: serialize(rawContent);
+	const content = Buffer.isBuffer(rawContent)
+		? rawContent
+		: serialize(rawContent, /* ident */ 2, {
+				plugins: [
+					...getSerializers(),
+					// Rspack serializers
+					...serializers
+				]
+			});
 
 	const { isNot, snapshotState } = this;