refactor(linter): send Message for DiagnosticService

Author: Sysix

Cargo.lock

@@ -20,3 +20,6 @@ doctest = false
 
 [dependencies]
 miette = { workspace = true }
+
+oxc_allocator = { workspace = true }
+oxc_span = { workspace = true }

crates/oxc_diagnostics/Cargo.toml

@@ -61,11 +61,13 @@ pub type Result<T> = std::result::Result<T, OxcDiagnostic>;
 
 use miette::{Diagnostic, SourceCode};
 pub use miette::{GraphicalReportHandler, GraphicalTheme, LabeledSpan, NamedSource, SourceSpan};
+use oxc_allocator::{Allocator, CloneIn};
+use oxc_span::{Span, SPAN};
 
 /// Describes an error or warning that occurred.
 ///
 /// Used by all oxc tools.
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 #[must_use]
 pub struct OxcDiagnostic {
     // `Box` the data to make `OxcDiagnostic` 8 bytes so that `Result` is small.
@@ -110,7 +112,7 @@ impl Display for OxcCode {
     }
 }
 
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct OxcDiagnosticInner {
     pub message: Cow<'static, str>,
     pub labels: Option<Vec<LabeledSpan>>,
@@ -335,3 +337,65 @@ impl OxcDiagnostic {
         Error::from(self).with_source_code(code)
     }
 }
+
+
+
+
+/// A completed, normalized fix ready to be applied to the source code.
+///
+/// Used internally by this module. Lint rules should use [`RuleFix`].
+#[derive(Debug, Clone)]
+#[non_exhaustive]
+pub struct Fix<'a> {
+    pub content: Cow<'a, str>,
+    /// A brief suggestion message describing the fix. Will be shown in
+    /// editors via code actions.
+    pub message: Option<Cow<'a, str>>,
+    pub span: Span,
+}
+
+impl PartialEq for Fix<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        self.span == other.span && self.content == other.content
+    }
+}
+
+impl<'new> CloneIn<'new> for Fix<'_> {
+    type Cloned = Fix<'new>;
+
+    fn clone_in(&self, allocator: &'new Allocator) -> Self::Cloned {
+        Fix {
+            content: match &self.content {
+                Cow::Borrowed(s) => Cow::Borrowed(allocator.alloc_str(s)),
+                Cow::Owned(s) => Cow::Owned(s.clone()),
+            },
+            span: self.span,
+            message: self.message.as_ref().map(|s| match s {
+                Cow::Borrowed(s) => Cow::Borrowed(allocator.alloc_str(s)),
+                Cow::Owned(s) => Cow::Owned(s.clone()),
+            }),
+        }
+    }
+}
+
+impl Default for Fix<'_> {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
+impl<'a> Fix<'a> {
+    pub const fn delete(span: Span) -> Self {
+        Self { content: Cow::Borrowed(""), message: None, span }
+    }
+
+    pub const fn new(content: Cow<'a, str>, span: Span) -> Self {
+        Self { content, message: None, span }
+    }
+
+    /// Creates a [`Fix`] that doesn't change the source code.
+    #[inline]
+    pub const fn empty() -> Self {
+        Self { content: Cow::Borrowed(""), message: None, span: SPAN }
+    }
+}

crates/oxc_diagnostics/src/lib.rs

@@ -1,7 +1,7 @@
 use std::{borrow::Cow, ops::Deref};
 
 use bitflags::bitflags;
-use oxc_allocator::{Allocator, CloneIn};
+use oxc_diagnostics::Fix;
 use oxc_span::{GetSpan, SPAN, Span};
 
 bitflags! {
@@ -268,58 +268,6 @@ impl<'a> Deref for RuleFix<'a> {
     }
 }
 
-/// A completed, normalized fix ready to be applied to the source code.
-///
-/// Used internally by this module. Lint rules should use [`RuleFix`].
-#[derive(Debug, Clone)]
-#[non_exhaustive]
-pub struct Fix<'a> {
-    pub content: Cow<'a, str>,
-    /// A brief suggestion message describing the fix. Will be shown in
-    /// editors via code actions.
-    pub message: Option<Cow<'a, str>>,
-    pub span: Span,
-}
-
-impl<'new> CloneIn<'new> for Fix<'_> {
-    type Cloned = Fix<'new>;
-
-    fn clone_in(&self, allocator: &'new Allocator) -> Self::Cloned {
-        Fix {
-            content: match &self.content {
-                Cow::Borrowed(s) => Cow::Borrowed(allocator.alloc_str(s)),
-                Cow::Owned(s) => Cow::Owned(s.clone()),
-            },
-            span: self.span,
-            message: self.message.as_ref().map(|s| match s {
-                Cow::Borrowed(s) => Cow::Borrowed(allocator.alloc_str(s)),
-                Cow::Owned(s) => Cow::Owned(s.clone()),
-            }),
-        }
-    }
-}
-
-impl Default for Fix<'_> {
-    fn default() -> Self {
-        Self::empty()
-    }
-}
-
-impl<'a> Fix<'a> {
-    pub const fn delete(span: Span) -> Self {
-        Self { content: Cow::Borrowed(""), message: None, span }
-    }
-
-    pub fn new<T: Into<Cow<'a, str>>>(content: T, span: Span) -> Self {
-        Self { content: content.into(), message: None, span }
-    }
-
-    /// Creates a [`Fix`] that doesn't change the source code.
-    #[inline]
-    pub const fn empty() -> Self {
-        Self { content: Cow::Borrowed(""), message: None, span: SPAN }
-    }
-}
 
 // NOTE (@DonIsaac): having these variants is effectively the same as interning
 // single or 0-element Vecs. I experimented with using smallvec here, but the
@@ -546,20 +494,14 @@ impl<'a> CompositeFix<'a> {
 
         output.push_str(after);
         output.shrink_to_fit();
-        Fix::new(output, Span::new(start, end))
+        Fix::new(output.into(), Span::new(start, end))
     }
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
 
-    impl PartialEq for Fix<'_> {
-        fn eq(&self, other: &Self) -> bool {
-            self.span == other.span && self.content == other.content
-        }
-    }
-
     impl Clone for CompositeFix<'_> {
         fn clone(&self) -> Self {
             match self {
@@ -617,7 +559,7 @@ mod test {
 
     #[test]
     fn test_composite_push_on_none() {
-        let f: CompositeFix = Fix::new("foo", Span::empty(4)).into();
+        let f: CompositeFix = Fix::new("foo".into(), Span::empty(4)).into();
 
         let mut none = CompositeFix::None;
         none.push(CompositeFix::None);
@@ -635,9 +577,9 @@ mod test {
 
     #[test]
     fn test_composite_push_on_single() {
-        let f1 = Fix::new("foo", Span::empty(4));
-        let f2 = Fix::new("bar", Span::empty(5));
-        let f3 = Fix::new("baz", Span::empty(6));
+        let f1 = Fix::new("foo".into(), Span::empty(4));
+        let f2 = Fix::new("bar".into(), Span::empty(5));
+        let f3 = Fix::new("baz".into(), Span::empty(6));
         let single = || CompositeFix::Single(f1.clone());
 
         // None.push(single) == single
@@ -650,8 +592,8 @@ mod test {
         assert_eq!(
             f,
             CompositeFix::Multiple(vec![
-                Fix::new("foo", Span::empty(4)),
-                Fix::new("bar", Span::empty(5))
+                Fix::new("foo".into(), Span::empty(4)),
+                Fix::new("bar".into(), Span::empty(5))
             ])
         );
 
@@ -664,9 +606,9 @@ mod test {
 
     #[test]
     fn test_composite_push_on_multiple() {
-        let f1 = Fix::new("foo", Span::empty(4));
-        let f2 = Fix::new("bar", Span::empty(5));
-        let f3 = Fix::new("baz", Span::empty(6));
+        let f1 = Fix::new("foo".into(), Span::empty(4));
+        let f2 = Fix::new("bar".into(), Span::empty(5));
+        let f3 = Fix::new("baz".into(), Span::empty(6));
         let multiple = || CompositeFix::Multiple(vec![f1.clone(), f2.clone()]);
 
         // None.push(multiple) == multiple