feat(swc): enhance TransformOutput with diagnostics (#10312)

* feat: enhance TransformOutput with diagnostics

* chore: format rs

Author: GiveMe-A-Name

crates/rspack_javascript_compiler/src/compiler/mod.rs

@@ -32,6 +32,19 @@ impl JavaScriptCompiler {
 
 #[derive(Debug)]
 pub struct TransformOutput {
+  /// The transformed code
   pub code: String,
+
+  /// The source map for the transformed code
   pub map: Option<SourceMap>,
+
+  /// The warning diagnostics for the transformed code
+  pub diagnostics: Vec<String>,
+}
+
+impl TransformOutput {
+  pub fn with_diagnostics(mut self, diagnostics: Vec<String>) -> Self {
+    self.diagnostics = diagnostics;
+    self
+  }
 }

crates/rspack_javascript_compiler/src/compiler/stringify.rs

@@ -209,7 +209,11 @@ impl JavaScriptCompiler {
       None
     };
 
-    Ok(TransformOutput { code: src, map })
+    Ok(TransformOutput {
+      code: src,
+      map,
+      diagnostics: Default::default(),
+    })
   }
 }
 

crates/rspack_javascript_compiler/src/compiler/transform.rs

@@ -314,7 +314,7 @@ impl<'a> JavaScriptTransformer<'a> {
       .input_source_map(&built_input.input_source_map)
       .to_rspack_result_from_anyhow()?;
 
-    let program = self.transform_with_built_input(built_input)?;
+    let (program, diagnostics) = self.transform_with_built_input(built_input)?;
     let format_opt = JsMinifyFormatOptions {
       inline_script: false,
       ascii_only: true,
@@ -331,7 +331,10 @@ impl<'a> JavaScriptTransformer<'a> {
       format: &format_opt,
     };
 
-    self.javascript_compiler.print(&program, print_options)
+    self
+      .javascript_compiler
+      .print(&program, print_options)
+      .map(|o| o.with_diagnostics(diagnostics))
   }
 
   fn parse_js(
@@ -420,13 +423,20 @@ impl<'a> JavaScriptTransformer<'a> {
   fn transform_with_built_input(
     &self,
     built_input: BuiltInput<impl Pass>,
-  ) -> Result<Program, Error> {
+  ) -> Result<(Program, Vec<String>), Error> {
     let program = built_input.program;
     let mut pass = built_input.pass;
+    let mut diagnostics = vec![];
     let program = self.run(|| {
       helpers::HELPERS.set(&self.helpers, || {
-        let result = try_with_handler(self.cm.clone(), Default::default(), |_handler| {
-          Ok(program.apply(&mut pass))
+        let result = try_with_handler(self.cm.clone(), Default::default(), |handler| {
+          // Apply external plugin passes to the Program AST.
+          // External plugins may emit warnings or inject helpers,
+          // so we need a handler to properly process them.
+          let program = program.apply(&mut pass);
+          diagnostics.extend(handler.take_diagnostics());
+
+          Ok(program)
         });
 
         result.map_err(|err| {
@@ -476,7 +486,9 @@ impl<'a> JavaScriptTransformer<'a> {
       );
     }
 
-    program.map_err(|e| e.into())
+    program
+      .map(|program| (program, diagnostics))
+      .map_err(|e| e.into())
   }
 
   pub fn input_source_map(

crates/rspack_loader_swc/src/lib.rs

@@ -11,7 +11,7 @@ pub use options::SwcLoaderJsOptions;
 pub use plugin::SwcLoaderPlugin;
 use rspack_cacheable::{cacheable, cacheable_dyn};
 use rspack_core::{Mode, RunnerContext};
-use rspack_error::{Diagnostic, Result};
+use rspack_error::{miette, Diagnostic, Result};
 use rspack_javascript_compiler::{JavaScriptCompiler, TransformOutput};
 use rspack_loader_runner::{Identifiable, Identifier, Loader, LoaderContext};
 use swc_config::{config_types::MergingOption, merge::Merge};
@@ -86,14 +86,24 @@ impl SwcLoader {
 
     let source = content.into_string_lossy();
 
-    let TransformOutput { code, map } = javascript_compiler.transform(
+    let TransformOutput {
+      code,
+      map,
+      diagnostics,
+    } = javascript_compiler.transform(
       source,
       Some(filename),
       swc_options,
       Some(loader_context.context.module_source_map_kind),
       |_| transformer::transform(&self.options_with_additional.rspack_experiments),
     )?;
 
+    for diagnostic in diagnostics {
+      loader_context.emit_diagnostic(
+        miette::miette! { severity = miette::Severity::Warning, "{}", diagnostic }.into(),
+      );
+    }
+
     loader_context.finish_with((code, map));
 
     Ok(())