feat: diagnostic with labels (#6001)

Author: h-a-n-a

Cargo.lock

@@ -9,6 +9,7 @@ version    = "0.1.0"
 
 [dependencies]
 anyhow            = { workspace = true, features = ["backtrace"] }
+derivative        = { workspace = true }
 futures           = { workspace = true }
 miette            = { version = "5", features = ["fancy"] }
 once_cell         = { workspace = true }

crates/rspack_error/Cargo.toml

@@ -1,8 +1,8 @@
-use std::error::Error;
+use std::{borrow::Cow, error::Error};
 
 use miette::Diagnostic;
 
-use crate::miette_helpers::WithHelp;
+use crate::miette_helpers::{WithHelp, WithLabel};
 
 /// Useful to convert [std::error::Error] to [crate::DiagnosticError]
 pub trait ErrorExt {
@@ -26,19 +26,37 @@ impl<T: Diagnostic + Send + Sync + 'static> DiagnosticExt for T {
 }
 
 pub trait MietteExt {
-  fn with_help(self, message: impl Into<String>) -> Box<dyn Diagnostic + Send + Sync>;
+  fn with_help(self, message: impl Into<Cow<'static, str>>) -> Box<dyn Diagnostic + Send + Sync>;
+  fn with_labels(
+    self,
+    labels: impl Iterator<Item = miette::LabeledSpan>,
+  ) -> Box<dyn Diagnostic + Send + Sync>;
 }
 
 impl MietteExt for Box<dyn Diagnostic + Send + Sync> {
-  fn with_help(self, message: impl Into<String>) -> Box<dyn Diagnostic + Send + Sync> {
+  fn with_help(self, message: impl Into<Cow<'static, str>>) -> Box<dyn Diagnostic + Send + Sync> {
     let h = WithHelp::from(self).with_help(message);
     <WithHelp as DiagnosticExt>::boxed(h)
   }
+  fn with_labels(
+    self,
+    labels: impl Iterator<Item = miette::LabeledSpan>,
+  ) -> Box<dyn Diagnostic + Send + Sync> {
+    let l = WithLabel::from(self).with_label(labels);
+    <WithLabel as DiagnosticExt>::boxed(l)
+  }
 }
 
 impl MietteExt for miette::Error {
-  fn with_help(self, message: impl Into<String>) -> Box<dyn Diagnostic + Send + Sync> {
+  fn with_help(self, message: impl Into<Cow<'static, str>>) -> Box<dyn Diagnostic + Send + Sync> {
     let h = WithHelp::from(self).with_help(message);
     <WithHelp as DiagnosticExt>::boxed(h)
   }
+  fn with_labels(
+    self,
+    labels: impl Iterator<Item = miette::LabeledSpan>,
+  ) -> Box<dyn Diagnostic + Send + Sync> {
+    let l = WithLabel::from(self).with_label(labels);
+    <WithLabel as DiagnosticExt>::boxed(l)
+  }
 }

crates/rspack_error/src/ext.rs

@@ -1,5 +1,6 @@
-use std::fmt::Display;
+use std::{borrow::Cow, fmt::Display};
 
+use derivative::Derivative;
 use miette::Diagnostic;
 use once_cell::sync::OnceCell;
 use thiserror::Error;
@@ -11,12 +12,12 @@ use crate::Error;
 #[error("{err}")]
 pub(crate) struct WithHelp {
   err: Error,
-  help: Option<String>,
-  wrap_help: OnceCell<Option<String>>,
+  help: Option<Cow<'static, str>>,
+  wrap_help: OnceCell<Option<Cow<'static, str>>>,
 }
 
 impl WithHelp {
-  pub(crate) fn with_help(mut self, help: impl Into<String>) -> Self {
+  pub(crate) fn with_help(mut self, help: impl Into<Cow<'static, str>>) -> Self {
     self.help = Some(help.into());
     self
   }
@@ -54,12 +55,12 @@ impl miette::Diagnostic for WithHelp {
   fn help<'a>(&'a self) -> Option<Box<dyn Display + 'a>> {
     let help = self.wrap_help.get_or_init(|| {
       let prev = self.err.help().map(|h| h.to_string());
-      let help = self.help.as_ref().map(|h| h.to_string());
+      let help = self.help.as_ref().cloned();
       if let Some(prev) = prev {
-        if let Some(help) = help {
-          Some(format!("{prev}\n{help}"))
+        if let Some(help) = &help {
+          Some(format!("{prev}\n{help}").into())
         } else {
-          Some(prev)
+          Some(prev.into())
         }
       } else if help.is_some() {
         help
@@ -91,3 +92,76 @@ impl miette::Diagnostic for WithHelp {
     self.err.diagnostic_source()
   }
 }
+
+/// Wrap diagnostic with label.
+#[derive(Error, Derivative)]
+#[derivative(Debug)]
+#[error("{err}")]
+pub(crate) struct WithLabel {
+  err: Error,
+  #[derivative(Debug = "ignore")]
+  labels: Option<Vec<miette::LabeledSpan>>,
+}
+
+impl WithLabel {
+  pub(crate) fn with_label(mut self, labels: impl Iterator<Item = miette::LabeledSpan>) -> Self {
+    self.labels = Some(labels.collect());
+    self
+  }
+}
+
+impl From<Box<dyn Diagnostic + Send + Sync>> for WithLabel {
+  fn from(value: Box<dyn Diagnostic + Send + Sync>) -> Self {
+    Self {
+      err: Error::new_boxed(value),
+      labels: None,
+    }
+  }
+}
+
+impl From<Error> for WithLabel {
+  fn from(value: Error) -> Self {
+    Self {
+      err: value,
+      labels: None,
+    }
+  }
+}
+
+impl miette::Diagnostic for WithLabel {
+  fn code<'a>(&'a self) -> Option<Box<dyn Display + 'a>> {
+    self.err.code()
+  }
+
+  fn severity(&self) -> Option<miette::Severity> {
+    self.err.severity()
+  }
+
+  fn help<'a>(&'a self) -> Option<Box<dyn Display + 'a>> {
+    self.err.help()
+  }
+
+  fn url<'a>(&'a self) -> Option<Box<dyn Display + 'a>> {
+    self.err.url()
+  }
+
+  fn source_code(&self) -> Option<&dyn miette::SourceCode> {
+    self.err.source_code()
+  }
+
+  fn labels(&self) -> Option<Box<dyn Iterator<Item = miette::LabeledSpan> + '_>> {
+    self
+      .labels
+      .as_ref()
+      .cloned()
+      .map(|l| Box::new(l.into_iter()) as Box<dyn Iterator<Item = miette::LabeledSpan>>)
+  }
+
+  fn related<'a>(&'a self) -> Option<Box<dyn Iterator<Item = &'a dyn miette::Diagnostic> + 'a>> {
+    self.err.related()
+  }
+
+  fn diagnostic_source(&self) -> Option<&dyn Diagnostic> {
+    self.err.diagnostic_source()
+  }
+}