[internal] Return Messages from check_path

Summary
--

This PR updates `check_path` in the `ruff_linter` crate to return a
`Vec<Message>` instead of a `Vec<Diagnostic>`. The main motivation for this is
to make it easier to convert semantic syntax errors directly into `Message`s
rather than `Diagnostic`s in #16106. However, this also has the benefit of
keeping the preview check on unsupported syntax errors in `check_path`, as
suggested in https://github.com/astral-sh/ruff/pull/16429/files#r1974748024.

Test Plan
--

Existing tests. I also tested the playground and server manually.

Author: ntBre

crates/ruff/src/cache.rs

@@ -353,6 +353,7 @@ impl FileCache {
                             fix: msg.fix.clone(),
                             file: file.clone(),
                             noqa_offset: msg.noqa_offset,
+                            parent: msg.parent,
                         })
                     })
                     .collect()
@@ -445,6 +446,7 @@ impl LintCacheData {
                 CacheMessage {
                     kind: msg.kind.clone(),
                     range: msg.range,
+                    parent: msg.parent,
                     fix: msg.fix.clone(),
                     noqa_offset: msg.noqa_offset,
                 }
@@ -465,6 +467,7 @@ pub(super) struct CacheMessage {
     kind: DiagnosticKind,
     /// Range into the message's [`FileCache::source`].
     range: TextRange,
+    parent: Option<TextSize>,
     fix: Option<Fix>,
     noqa_offset: TextSize,
 }
@@ -702,7 +705,10 @@ mod tests {
             .unwrap();
         }
 
-        assert_eq!(expected_diagnostics, got_diagnostics);
+        assert_eq!(
+            expected_diagnostics, got_diagnostics,
+            "left == {expected_diagnostics:#?}, right == {got_diagnostics:#?}",
+        );
     }
 
     #[test]

crates/ruff_linter/src/fix/edits.rs

@@ -592,6 +592,7 @@ fn all_lines_fit(
 #[cfg(test)]
 mod tests {
     use anyhow::{anyhow, Result};
+    use ruff_source_file::SourceFileBuilder;
     use test_case::test_case;
 
     use ruff_diagnostics::{Diagnostic, Edit, Fix};
@@ -604,6 +605,7 @@ mod tests {
     use crate::fix::edits::{
         add_to_dunder_all, make_redundant_alias, next_stmt_break, trailing_semicolon,
     };
+    use crate::message::DiagnosticMessage;
     use crate::Locator;
 
     /// Parse the given source using [`Mode::Module`] and return the first statement.
@@ -735,14 +737,22 @@ x = 1 \
         let diag = {
             use crate::rules::pycodestyle::rules::MissingNewlineAtEndOfFile;
             let mut iter = edits.into_iter();
-            Diagnostic::new(
+            let diag = Diagnostic::new(
                 MissingNewlineAtEndOfFile, // The choice of rule here is arbitrary.
                 TextRange::default(),
             )
             .with_fix(Fix::safe_edits(
                 iter.next().ok_or(anyhow!("expected edits nonempty"))?,
                 iter,
-            ))
+            ));
+            DiagnosticMessage {
+                kind: diag.kind,
+                range: diag.range,
+                fix: diag.fix,
+                parent: diag.parent,
+                file: SourceFileBuilder::new("<filename>", "<code>").finish(),
+                noqa_offset: TextSize::default(),
+            }
         };
         assert_eq!(apply_fixes([diag].iter(), &locator).code, expect);
         Ok(())

crates/ruff_linter/src/fix/mod.rs

@@ -3,10 +3,11 @@ use std::collections::BTreeSet;
 use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet};
 
-use ruff_diagnostics::{Diagnostic, Edit, Fix, IsolationLevel, SourceMap};
+use ruff_diagnostics::{Edit, Fix, IsolationLevel, SourceMap};
 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 
 use crate::linter::FixTable;
+use crate::message::{DiagnosticMessage, Message};
 use crate::registry::{AsRule, Rule};
 use crate::settings::types::UnsafeFixes;
 use crate::Locator;
@@ -26,14 +27,15 @@ pub(crate) struct FixResult {
 
 /// Fix errors in a file, and write the fixed source code to disk.
 pub(crate) fn fix_file(
-    diagnostics: &[Diagnostic],
+    diagnostics: &[Message],
     locator: &Locator,
     unsafe_fixes: UnsafeFixes,
 ) -> Option<FixResult> {
     let required_applicability = unsafe_fixes.required_applicability();
 
     let mut with_fixes = diagnostics
         .iter()
+        .filter_map(Message::as_diagnostic_message)
         .filter(|diagnostic| {
             diagnostic
                 .fix
@@ -51,7 +53,7 @@ pub(crate) fn fix_file(
 
 /// Apply a series of fixes.
 fn apply_fixes<'a>(
-    diagnostics: impl Iterator<Item = &'a Diagnostic>,
+    diagnostics: impl Iterator<Item = &'a DiagnosticMessage>,
     locator: &'a Locator<'a>,
 ) -> FixResult {
     let mut output = String::with_capacity(locator.len());
@@ -161,22 +163,26 @@ fn cmp_fix(rule1: Rule, rule2: Rule, fix1: &Fix, fix2: &Fix) -> std::cmp::Orderi
 
 #[cfg(test)]
 mod tests {
-    use ruff_diagnostics::{Diagnostic, Edit, Fix, SourceMarker};
+    use ruff_diagnostics::{Edit, Fix, SourceMarker};
+    use ruff_source_file::SourceFileBuilder;
     use ruff_text_size::{Ranged, TextSize};
 
     use crate::fix::{apply_fixes, FixResult};
+    use crate::message::DiagnosticMessage;
     use crate::rules::pycodestyle::rules::MissingNewlineAtEndOfFile;
     use crate::Locator;
 
     #[allow(deprecated)]
-    fn create_diagnostics(edit: impl IntoIterator<Item = Edit>) -> Vec<Diagnostic> {
+    fn create_diagnostics(edit: impl IntoIterator<Item = Edit>) -> Vec<DiagnosticMessage> {
         edit.into_iter()
-            .map(|edit| Diagnostic {
+            .map(|edit| DiagnosticMessage {
                 // The choice of rule here is arbitrary.
                 kind: MissingNewlineAtEndOfFile.into(),
                 range: edit.range(),
                 fix: Some(Fix::safe_edit(edit)),
                 parent: None,
+                file: SourceFileBuilder::new("<filename>", "<code>").finish(),
+                noqa_offset: TextSize::default(),
             })
             .collect()
     }

crates/ruff_linter/src/linter.rs

@@ -58,8 +58,7 @@ pub struct FixerResult<'a> {
     pub fixed: FixTable,
 }
 
-/// Generate `Diagnostic`s from the source code contents at the
-/// given `Path`.
+/// Generate [`Message`]s from the source code contents at the given `Path`.
 #[allow(clippy::too_many_arguments)]
 pub fn check_path(
     path: &Path,
@@ -74,7 +73,7 @@ pub fn check_path(
     source_type: PySourceType,
     parsed: &Parsed<ModModule>,
     target_version: PythonVersion,
-) -> Vec<Diagnostic> {
+) -> Vec<Message> {
     // Aggregate all diagnostics.
     let mut diagnostics = vec![];
 
@@ -322,7 +321,20 @@ pub fn check_path(
         }
     }
 
-    diagnostics
+    let syntax_errors = if settings.preview.is_enabled() {
+        parsed.unsupported_syntax_errors()
+    } else {
+        &[]
+    };
+
+    diagnostics_to_messages(
+        diagnostics,
+        parsed.errors(),
+        syntax_errors,
+        path,
+        locator,
+        directives,
+    )
 }
 
 const MAX_ITERATIONS: usize = 100;
@@ -417,7 +429,7 @@ pub fn lint_only(
     );
 
     // Generate diagnostics.
-    let diagnostics = check_path(
+    let messages = check_path(
         path,
         package,
         &locator,
@@ -432,21 +444,8 @@ pub fn lint_only(
         target_version,
     );
 
-    let syntax_errors = if settings.preview.is_enabled() {
-        parsed.unsupported_syntax_errors()
-    } else {
-        &[]
-    };
-
     LinterResult {
-        messages: diagnostics_to_messages(
-            diagnostics,
-            parsed.errors(),
-            syntax_errors,
-            path,
-            &locator,
-            &directives,
-        ),
+        messages,
         has_syntax_error: parsed.has_syntax_errors(),
     }
 }
@@ -591,22 +590,9 @@ pub fn lint_fix<'a>(
             report_failed_to_converge_error(path, transformed.source_code(), &diagnostics);
         }
 
-        let syntax_errors = if settings.preview.is_enabled() {
-            parsed.unsupported_syntax_errors()
-        } else {
-            &[]
-        };
-
         return Ok(FixerResult {
             result: LinterResult {
-                messages: diagnostics_to_messages(
-                    diagnostics,
-                    parsed.errors(),
-                    syntax_errors,
-                    path,
-                    &locator,
-                    &directives,
-                ),
+                messages: diagnostics,
                 has_syntax_error: !is_valid_syntax,
             },
             transformed,
@@ -625,8 +611,8 @@ fn collect_rule_codes(rules: impl IntoIterator<Item = Rule>) -> String {
 }
 
 #[allow(clippy::print_stderr)]
-fn report_failed_to_converge_error(path: &Path, transformed: &str, diagnostics: &[Diagnostic]) {
-    let codes = collect_rule_codes(diagnostics.iter().map(|diagnostic| diagnostic.kind.rule()));
+fn report_failed_to_converge_error(path: &Path, transformed: &str, diagnostics: &[Message]) {
+    let codes = collect_rule_codes(diagnostics.iter().filter_map(Message::rule));
     if cfg!(debug_assertions) {
         eprintln!(
             "{}{} Failed to converge after {} iterations in `{}` with rule codes {}:---\n{}\n---",

crates/ruff_linter/src/message/mod.rs

@@ -41,24 +41,25 @@ mod text;
 
 /// Message represents either a diagnostic message corresponding to a rule violation or a syntax
 /// error message raised by the parser.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Message {
     Diagnostic(DiagnosticMessage),
     SyntaxError(SyntaxErrorMessage),
 }
 
 /// A diagnostic message corresponding to a rule violation.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct DiagnosticMessage {
     pub kind: DiagnosticKind,
     pub range: TextRange,
     pub fix: Option<Fix>,
+    pub parent: Option<TextSize>,
     pub file: SourceFile,
     pub noqa_offset: TextSize,
 }
 
 /// A syntax error message raised by the parser.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct SyntaxErrorMessage {
     pub message: String,
     pub range: TextRange,
@@ -91,6 +92,7 @@ impl Message {
             range: diagnostic.range(),
             kind: diagnostic.kind,
             fix: diagnostic.fix,
+            parent: diagnostic.parent,
             file,
             noqa_offset,
         })
@@ -140,6 +142,13 @@ impl Message {
         }
     }
 
+    pub fn into_diagnostic_message(self) -> Option<DiagnosticMessage> {
+        match self {
+            Message::Diagnostic(m) => Some(m),
+            Message::SyntaxError(_) => None,
+        }
+    }
+
     /// Returns `true` if `self` is a syntax error message.
     pub const fn is_syntax_error(&self) -> bool {
         matches!(self, Message::SyntaxError(_))