Don't cache files with diagnostics (#19869)

Summary
--

To take advantage of the new diagnostics, we need to update our caching
model to include all of the information supported by `ruff_db`'s
diagnostic type. Instead of trying to serialize all of this information,
Micha suggested simply not caching files with diagnostics, like we
already do for files with syntax errors. This PR is an attempt at that
approach.

This has the added benefit of trimming down our `Rule` derives since
this was the last place the `FromStr`/`strum_macros::EnumString`
implementation was used, as well as the (de)serialization macros and
`CacheKey`.

Test Plan
--

Existing tests, with their input updated not to include a diagnostic,
plus a new test showing that files with lint diagnostics are not cached.

Benchmarks
--

In addition to tests, we wanted to check that this doesn't degrade
performance too much. I posted part of this new analysis in
https://github.com/astral-sh/ruff/issues/18198#issuecomment-3175048672,
but I'll duplicate it here. In short, there's not much difference
between `main` and this branch for projects with few diagnostics
(`home-assistant`, `airflow`), as expected. The difference for projects
with many diagnostics (`cpython`) is quite a bit bigger (~300 ms vs ~220
ms), but most projects that run ruff regularly are likely to have very
few diagnostics, so this may not be a problem practically.

I guess GitHub isn't really rendering this as I intended, but the extra
separator line is meant to separate the benchmarks on `main` (above the
line) from this branch (below the line).

| Command | Mean [ms] | Min [ms] | Max [ms] |

|:--------------------------------------------------------------|----------:|---------:|---------:|
| `ruff check cpython --no-cache --isolated --exit-zero` | 322.0 | 317.5
| 326.2 |
| `ruff check cpython --isolated --exit-zero` | 217.3 | 209.8 | 237.9 |
| `ruff check home-assistant --no-cache --isolated --exit-zero` | 279.5
| 277.0 | 283.6 |
| `ruff check home-assistant --isolated --exit-zero` | 37.2 | 35.7 |
40.6 |
| `ruff check airflow --no-cache --isolated --exit-zero` | 133.1 | 130.4
| 146.4 |
| `ruff check airflow --isolated --exit-zero` | 34.7 | 32.9 | 41.6 |

|:--------------------------------------------------------------|----------:|---------:|---------:|
| `ruff check cpython --no-cache --isolated --exit-zero` | 330.1 | 324.5
| 333.6 |
| `ruff check cpython --isolated --exit-zero` | 309.2 | 306.1 | 314.7 |
| `ruff check home-assistant --no-cache --isolated --exit-zero` | 288.6
| 279.4 | 302.3 |
| `ruff check home-assistant --isolated --exit-zero` | 39.8 | 36.9 |
42.4 |
| `ruff check airflow --no-cache --isolated --exit-zero` | 134.5 | 131.3
| 140.6 |
| `ruff check airflow --isolated --exit-zero` | 39.1 | 37.2 | 44.3 |

I had Claude adapt one of the
[scripts](https://github.com/sharkdp/hyperfine/blob/master/scripts/plot_whisker.py)
from the hyperfine repo to make this plot, so it's not quite perfect,
but maybe it's still useful. The table is probably more reliable for
close comparisons. I'll put more details about the benchmarks below for
the sake of future reproducibility.

<img width="4472" height="2368" alt="image"
src="https://github.com/user-attachments/assets/1c42d13e-818a-44e7-b34c-247340a936d7"
/>

<details><summary>Benchmark details</summary>
<p>

The versions of each project:
- CPython: 6322edd260e8cad4b09636e05ddfb794a96a0451, the 3.10 branch
from the contributing docs
- `home-assistant`: 5585376b406f099fb29a970b160877b57e5efcb0
- `airflow`: 29a1cb0cfde9d99b1774571688ed86cb60123896

The last two are just the main branches at the time I cloned the repos.

I don't think our Ruff config should be applied since I used
`--isolated`, but these are cloned into my copy of Ruff at
`crates/ruff_linter/resources/test`, and I trimmed the
`./target/release/` prefix from each of the commands, but these are
builds of Ruff in release mode.

And here's the script with the `hyperfine` invocation:

```shell
#!/bin/bash

cargo build --release --bin ruff

# git clone --depth 1 https://github.com/home-assistant/core crates/ruff_linter/resources/test/home-assistant
# git clone --depth 1 https://github.com/apache/airflow crates/ruff_linter/resources/test/airflow

bin=./target/release/ruff
resources=./crates/ruff_linter/resources/test
cpython=$resources/cpython
home_assistant=$resources/home-assistant
airflow=$resources/airflow

base=${1:-bench}

hyperfine --warmup 10 --export-json $base.json --export-markdown $base.md \
		  "$bin check $cpython --no-cache --isolated --exit-zero" \
		  "$bin check $cpython --isolated --exit-zero" \
		  "$bin check $home_assistant --no-cache --isolated --exit-zero" \
		  "$bin check $home_assistant --isolated --exit-zero" \
		  "$bin check $airflow --no-cache --isolated --exit-zero" \
		  "$bin check $airflow --isolated --exit-zero"
```

I ran this once on `main` (`baseline` in the graph, top half of the
table) and once on this branch (`nocache` and bottom of the table).

</p>
</details>

crates/ruff/src/cache.rs

@@ -13,25 +13,16 @@ use itertools::Itertools;
 use log::{debug, error};
 use rayon::iter::ParallelIterator;
 use rayon::iter::{IntoParallelIterator, ParallelBridge};
-use ruff_linter::codes::Rule;
 use rustc_hash::FxHashMap;
 use tempfile::NamedTempFile;
 
 use ruff_cache::{CacheKey, CacheKeyHasher};
-use ruff_db::diagnostic::Diagnostic;
-use ruff_diagnostics::Fix;
-use ruff_linter::message::create_lint_diagnostic;
 use ruff_linter::package::PackageRoot;
 use ruff_linter::{VERSION, warn_user};
 use ruff_macros::CacheKey;
-use ruff_notebook::NotebookIndex;
-use ruff_source_file::SourceFileBuilder;
-use ruff_text_size::{TextRange, TextSize};
 use ruff_workspace::Settings;
 use ruff_workspace::resolver::Resolver;
 
-use crate::diagnostics::Diagnostics;
-
 /// [`Path`] that is relative to the package root in [`PackageCache`].
 pub(crate) type RelativePath = Path;
 /// [`PathBuf`] that is relative to the package root in [`PackageCache`].
@@ -298,13 +289,8 @@ impl Cache {
         });
     }
 
-    pub(crate) fn update_lint(
-        &self,
-        path: RelativePathBuf,
-        key: &FileCacheKey,
-        data: LintCacheData,
-    ) {
-        self.update(path, key, ChangeData::Lint(data));
+    pub(crate) fn set_linted(&self, path: RelativePathBuf, key: &FileCacheKey, yes: bool) {
+        self.update(path, key, ChangeData::Linted(yes));
     }
 
     pub(crate) fn set_formatted(&self, path: RelativePathBuf, key: &FileCacheKey) {
@@ -339,42 +325,15 @@ pub(crate) struct FileCache {
 }
 
 impl FileCache {
-    /// Convert the file cache into `Diagnostics`, using `path` as file name.
-    pub(crate) fn to_diagnostics(&self, path: &Path) -> Option<Diagnostics> {
-        self.data.lint.as_ref().map(|lint| {
-            let diagnostics = if lint.messages.is_empty() {
-                Vec::new()
-            } else {
-                let file = SourceFileBuilder::new(path.to_string_lossy(), &*lint.source).finish();
-                lint.messages
-                    .iter()
-                    .map(|msg| {
-                        create_lint_diagnostic(
-                            &msg.body,
-                            msg.suggestion.as_ref(),
-                            msg.range,
-                            msg.fix.clone(),
-                            msg.parent,
-                            file.clone(),
-                            msg.noqa_offset,
-                            msg.rule,
-                        )
-                    })
-                    .collect()
-            };
-            let notebook_indexes = if let Some(notebook_index) = lint.notebook_index.as_ref() {
-                FxHashMap::from_iter([(path.to_string_lossy().to_string(), notebook_index.clone())])
-            } else {
-                FxHashMap::default()
-            };
-            Diagnostics::new(diagnostics, notebook_indexes)
-        })
+    /// Return whether or not the file in the cache was linted and found to have no diagnostics.
+    pub(crate) fn linted(&self) -> bool {
+        self.data.linted
     }
 }
 
 #[derive(Debug, Default, bincode::Decode, bincode::Encode)]
 struct FileCacheData {
-    lint: Option<LintCacheData>,
+    linted: bool,
     formatted: bool,
 }
 
@@ -410,88 +369,6 @@ pub(crate) fn init(path: &Path) -> Result<()> {
     Ok(())
 }
 
-#[derive(bincode::Decode, Debug, bincode::Encode, PartialEq)]
-pub(crate) struct LintCacheData {
-    /// Imports made.
-    // pub(super) imports: ImportMap,
-    /// Diagnostic messages.
-    pub(super) messages: Vec<CacheMessage>,
-    /// Source code of the file.
-    ///
-    /// # Notes
-    ///
-    /// This will be empty if `messages` is empty.
-    pub(super) source: String,
-    /// Notebook index if this file is a Jupyter Notebook.
-    #[bincode(with_serde)]
-    pub(super) notebook_index: Option<NotebookIndex>,
-}
-
-impl LintCacheData {
-    pub(crate) fn from_diagnostics(
-        diagnostics: &[Diagnostic],
-        notebook_index: Option<NotebookIndex>,
-    ) -> Self {
-        let source = if let Some(msg) = diagnostics.first() {
-            msg.expect_ruff_source_file().source_text().to_owned()
-        } else {
-            String::new() // No messages, no need to keep the source!
-        };
-
-        let messages = diagnostics
-            .iter()
-            // Parse the kebab-case rule name into a `Rule`. This will fail for syntax errors, so
-            // this also serves to filter them out, but we shouldn't be caching files with syntax
-            // errors anyway.
-            .filter_map(|msg| Some((msg.name().parse().ok()?, msg)))
-            .map(|(rule, msg)| {
-                // Make sure that all message use the same source file.
-                assert_eq!(
-                    msg.expect_ruff_source_file(),
-                    diagnostics.first().unwrap().expect_ruff_source_file(),
-                    "message uses a different source file"
-                );
-                CacheMessage {
-                    rule,
-                    body: msg.body().to_string(),
-                    suggestion: msg.first_help_text().map(ToString::to_string),
-                    range: msg.expect_range(),
-                    parent: msg.parent(),
-                    fix: msg.fix().cloned(),
-                    noqa_offset: msg.noqa_offset(),
-                }
-            })
-            .collect();
-
-        Self {
-            messages,
-            source,
-            notebook_index,
-        }
-    }
-}
-
-/// On disk representation of a diagnostic message.
-#[derive(bincode::Decode, Debug, bincode::Encode, PartialEq)]
-pub(super) struct CacheMessage {
-    /// The rule for the cached diagnostic.
-    #[bincode(with_serde)]
-    rule: Rule,
-    /// The message body to display to the user, to explain the diagnostic.
-    body: String,
-    /// The message to display to the user, to explain the suggested fix.
-    suggestion: Option<String>,
-    /// Range into the message's [`FileCache::source`].
-    #[bincode(with_serde)]
-    range: TextRange,
-    #[bincode(with_serde)]
-    parent: Option<TextSize>,
-    #[bincode(with_serde)]
-    fix: Option<Fix>,
-    #[bincode(with_serde)]
-    noqa_offset: Option<TextSize>,
-}
-
 pub(crate) trait PackageCaches {
     fn get(&self, package_root: &Path) -> Option<&Cache>;
 
@@ -579,15 +456,15 @@ struct Change {
 
 #[derive(Debug)]
 enum ChangeData {
-    Lint(LintCacheData),
+    Linted(bool),
     Formatted,
 }
 
 impl ChangeData {
     fn apply(self, data: &mut FileCacheData) {
         match self {
-            ChangeData::Lint(new_lint) => {
-                data.lint = Some(new_lint);
+            ChangeData::Linted(yes) => {
+                data.linted = yes;
             }
             ChangeData::Formatted => {
                 data.formatted = true;
@@ -612,7 +489,6 @@ mod tests {
     use test_case::test_case;
 
     use ruff_cache::CACHE_DIR_NAME;
-    use ruff_db::diagnostic::Diagnostic;
     use ruff_linter::package::PackageRoot;
     use ruff_linter::settings::LinterSettings;
     use ruff_linter::settings::flags;
@@ -620,7 +496,7 @@ mod tests {
     use ruff_python_ast::{PySourceType, PythonVersion};
     use ruff_workspace::Settings;
 
-    use crate::cache::{self, FileCache, FileCacheData, FileCacheKey};
+    use crate::cache::{self, ChangeData, FileCache, FileCacheData, FileCacheKey};
     use crate::cache::{Cache, RelativePathBuf};
     use crate::commands::format::{FormatCommandError, FormatMode, FormatResult, format_path};
     use crate::diagnostics::{Diagnostics, lint_path};
@@ -647,7 +523,7 @@ mod tests {
         assert_eq!(cache.changes.lock().unwrap().len(), 0);
 
         let mut paths = Vec::new();
-        let mut parse_errors = Vec::new();
+        let mut paths_with_diagnostics = Vec::new();
         let mut expected_diagnostics = Diagnostics::default();
         for entry in fs::read_dir(&package_root).unwrap() {
             let entry = entry.unwrap();
@@ -671,7 +547,7 @@ mod tests {
                     continue;
                 }
 
-                let diagnostics = lint_path(
+                let mut diagnostics = lint_path(
                     &path,
                     Some(PackageRoot::root(&package_root)),
                     &settings.linter,
@@ -681,8 +557,15 @@ mod tests {
                     UnsafeFixes::Enabled,
                 )
                 .unwrap();
-                if diagnostics.inner.iter().any(Diagnostic::is_invalid_syntax) {
-                    parse_errors.push(path.clone());
+                if diagnostics.inner.is_empty() {
+                    // We won't load a notebook index from the cache for files without diagnostics,
+                    // so remove them from `expected_diagnostics` too. This allows us to keep the
+                    // full equality assertion below.
+                    diagnostics
+                        .notebook_indexes
+                        .remove(&path.to_string_lossy().to_string());
+                } else {
+                    paths_with_diagnostics.push(path.clone());
                 }
                 paths.push(path);
                 expected_diagnostics += diagnostics;
@@ -695,11 +578,11 @@ mod tests {
         let cache = Cache::open(package_root.clone(), &settings);
         assert_ne!(cache.package.files.len(), 0);
 
-        parse_errors.sort();
+        paths_with_diagnostics.sort();
 
         for path in &paths {
-            if parse_errors.binary_search(path).is_ok() {
-                continue; // We don't cache parsing errors.
+            if paths_with_diagnostics.binary_search(path).is_ok() {
+                continue; // We don't cache files with diagnostics.
             }
 
             let relative_path = cache.relative_path(path).unwrap();
@@ -733,7 +616,7 @@ mod tests {
 
     #[test]
     fn cache_adds_file_on_lint() {
-        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
+        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\"])\n";
 
         let test_cache = TestCache::new("cache_adds_file_on_lint");
         let cache = test_cache.open();
@@ -757,7 +640,7 @@ mod tests {
 
     #[test]
     fn cache_adds_files_on_lint() {
-        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
+        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\"])\n";
 
         let test_cache = TestCache::new("cache_adds_files_on_lint");
         let cache = test_cache.open();
@@ -782,6 +665,40 @@ mod tests {
         cache.persist().unwrap();
     }
 
+    #[test]
+    fn cache_does_not_add_file_on_lint_with_diagnostic() {
+        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
+
+        let test_cache = TestCache::new("cache_does_not_add_file_on_lint_with_diagnostic");
+        let cache = test_cache.open();
+        test_cache.write_source_file("source.py", source);
+        assert_eq!(cache.changes.lock().unwrap().len(), 0);
+
+        cache.persist().unwrap();
+        let cache = test_cache.open();
+
+        let results = test_cache
+            .lint_file_with_cache("source.py", &cache)
+            .expect("Failed to lint test file");
+        assert_eq!(results.inner.len(), 1, "Expected one F822 diagnostic");
+        assert_eq!(
+            cache.changes.lock().unwrap().len(),
+            1,
+            "Files with diagnostics still trigger change events"
+        );
+        assert!(
+            cache
+                .changes
+                .lock()
+                .unwrap()
+                .last()
+                .is_some_and(|change| matches!(change.new_data, ChangeData::Linted(false))),
+            "Files with diagnostics are marked as unlinted"
+        );
+
+        cache.persist().unwrap();
+    }
+
     #[test]
     fn cache_adds_files_on_format() {
         let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
@@ -812,7 +729,7 @@ mod tests {
 
     #[test]
     fn cache_invalidated_on_file_modified_time() {
-        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
+        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\"])\n";
 
         let test_cache = TestCache::new("cache_invalidated_on_file_modified_time");
         let cache = test_cache.open();
@@ -869,7 +786,7 @@ mod tests {
             file.set_permissions(perms)
         }
 
-        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
+        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\"])\n";
 
         let test_cache = TestCache::new("cache_invalidated_on_permission_change");
         let cache = test_cache.open();
@@ -922,7 +839,7 @@ mod tests {
         );
 
         // Now actually lint a file.
-        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
+        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\"])\n";
         test_cache.write_source_file("new.py", source);
         let new_path_key = RelativePathBuf::from("new.py");
         assert_eq!(cache.changes.lock().unwrap().len(), 0);
@@ -945,7 +862,7 @@ mod tests {
 
     #[test]
     fn format_updates_cache_entry() {
-        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
+        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\"])\n";
 
         let test_cache = TestCache::new("format_updates_cache_entry");
         let cache = test_cache.open();
@@ -979,7 +896,7 @@ mod tests {
             panic!("Cache entry for `source.py` is missing.");
         };
 
-        assert!(file_cache.data.lint.is_some());
+        assert!(file_cache.data.linted);
         assert!(file_cache.data.formatted);
     }
 
@@ -1029,7 +946,7 @@ mod tests {
             panic!("Cache entry for `source.py` is missing.");
         };
 
-        assert_eq!(file_cache.data.lint, None);
+        assert!(!file_cache.data.linted);
         assert!(file_cache.data.formatted);
     }
 

crates/ruff/src/diagnostics.rs

@@ -20,15 +20,21 @@ use ruff_linter::settings::types::UnsafeFixes;
 use ruff_linter::settings::{LinterSettings, flags};
 use ruff_linter::source_kind::{SourceError, SourceKind};
 use ruff_linter::{IOError, Violation, fs};
-use ruff_notebook::{Notebook, NotebookError, NotebookIndex};
+use ruff_notebook::{NotebookError, NotebookIndex};
 use ruff_python_ast::{PySourceType, SourceType, TomlSourceType};
 use ruff_source_file::SourceFileBuilder;
 use ruff_text_size::TextRange;
 use ruff_workspace::Settings;
 use rustc_hash::FxHashMap;
 
-use crate::cache::{Cache, FileCacheKey, LintCacheData};
+use crate::cache::{Cache, FileCache, FileCacheKey};
 
+/// A collection of [`Diagnostic`]s and additional information needed to render them.
+///
+/// Note that `notebook_indexes` may be empty if there are no diagnostics because the
+/// `NotebookIndex` isn't cached in this case. This isn't a problem for any current uses as of
+/// 2025-08-12, which are all related to diagnostic rendering, but could be surprising if used
+/// differently in the future.
 #[derive(Debug, Default, PartialEq)]
 pub(crate) struct Diagnostics {
     pub(crate) inner: Vec<Diagnostic>,
@@ -193,19 +199,9 @@ pub(crate) fn lint_path(
             let cache_key = FileCacheKey::from_path(path).context("Failed to create cache key")?;
             let cached_diagnostics = cache
                 .get(relative_path, &cache_key)
-                .and_then(|entry| entry.to_diagnostics(path));
-            if let Some(diagnostics) = cached_diagnostics {
-                // `FixMode::Generate` and `FixMode::Diff` rely on side-effects (writing to disk,
-                // and writing the diff to stdout, respectively). If a file has diagnostics, we
-                // need to avoid reading from and writing to the cache in these modes.
-                if match fix_mode {
-                    flags::FixMode::Generate => true,
-                    flags::FixMode::Apply | flags::FixMode::Diff => {
-                        diagnostics.inner.is_empty() && diagnostics.fixed.is_empty()
-                    }
-                } {
-                    return Ok(diagnostics);
-                }
+                .is_some_and(FileCache::linted);
+            if cached_diagnostics {
+                return Ok(Diagnostics::default());
             }
 
             // Stash the file metadata for later so when we update the cache it reflects the prerun
@@ -322,31 +318,21 @@ pub(crate) fn lint_path(
             (result, transformed, fixed)
         };
 
-    let has_error = result.has_syntax_errors();
     let diagnostics = result.diagnostics;
 
     if let Some((cache, relative_path, key)) = caching {
-        // We don't cache parsing errors.
-        if !has_error {
-            // `FixMode::Apply` and `FixMode::Diff` rely on side-effects (writing to disk,
-            // and writing the diff to stdout, respectively). If a file has diagnostics, we
-            // need to avoid reading from and writing to the cache in these modes.
-            if match fix_mode {
-                flags::FixMode::Generate => true,
-                flags::FixMode::Apply | flags::FixMode::Diff => {
-                    diagnostics.is_empty() && fixed.is_empty()
-                }
-            } {
-                cache.update_lint(
-                    relative_path.to_owned(),
-                    &key,
-                    LintCacheData::from_diagnostics(
-                        &diagnostics,
-                        transformed.as_ipy_notebook().map(Notebook::index).cloned(),
-                    ),
-                );
-            }
-        }
+        // `FixMode::Apply` and `FixMode::Diff` rely on side-effects (writing to disk,
+        // and writing the diff to stdout, respectively). If a file has diagnostics
+        // with fixes, we need to avoid reading from and writing to the cache in these
+        // modes.
+        let use_fixes = match fix_mode {
+            flags::FixMode::Generate => true,
+            flags::FixMode::Apply | flags::FixMode::Diff => fixed.is_empty(),
+        };
+
+        // We don't cache files with diagnostics.
+        let linted = diagnostics.is_empty() && use_fixes;
+        cache.set_linted(relative_path.to_owned(), &key, linted);
     }
 
     let notebook_indexes = if let SourceKind::IpyNotebook(notebook) = transformed {

crates/ruff_benchmark/benches/linter.rs

@@ -77,8 +77,11 @@ fn benchmark_linter(mut group: BenchmarkGroup, settings: &LinterSettings) {
                 b.iter_batched(
                     || parsed.clone(),
                     |parsed| {
+                        // Assert that file contains no parse errors
+                        assert!(parsed.has_valid_syntax());
+
                         let path = case.path();
-                        let result = lint_only(
+                        lint_only(
                             &path,
                             None,
                             settings,
@@ -86,10 +89,7 @@ fn benchmark_linter(mut group: BenchmarkGroup, settings: &LinterSettings) {
                             &SourceKind::Python(case.code().to_string()),
                             PySourceType::from(path.as_path()),
                             ParseSource::Precomputed(parsed),
-                        );
-
-                        // Assert that file contains no parse errors
-                        assert!(!result.has_syntax_errors());
+                        )
                     },
                     criterion::BatchSize::SmallInput,
                 );

crates/ruff_linter/src/linter.rs

@@ -44,44 +44,15 @@ pub struct LinterResult {
     /// Flag indicating that the parsed source code does not contain any
     /// [`ParseError`]s
     has_valid_syntax: bool,
-    /// Flag indicating that the parsed source code does not contain any [`ParseError`]s,
-    /// [`UnsupportedSyntaxError`]s, or [`SemanticSyntaxError`]s.
-    has_no_syntax_errors: bool,
 }
 
 impl LinterResult {
-    /// Returns `true` if the parsed source code contains any [`ParseError`]s *or*
-    /// [`UnsupportedSyntaxError`]s.
-    ///
-    /// See [`LinterResult::has_invalid_syntax`] for a version specific to [`ParseError`]s.
-    pub fn has_syntax_errors(&self) -> bool {
-        !self.has_no_syntax_errors()
-    }
-
-    /// Returns `true` if the parsed source code does not contain any [`ParseError`]s *or*
-    /// [`UnsupportedSyntaxError`]s.
-    ///
-    /// See [`LinterResult::has_valid_syntax`] for a version specific to [`ParseError`]s.
-    pub fn has_no_syntax_errors(&self) -> bool {
-        self.has_valid_syntax() && self.has_no_syntax_errors
-    }
-
-    /// Returns `true` if the parsed source code is valid i.e., it has no [`ParseError`]s.
-    ///
-    /// Note that this does not include version-related [`UnsupportedSyntaxError`]s.
-    ///
-    /// See [`LinterResult::has_no_syntax_errors`] for a version that takes these into account.
-    pub fn has_valid_syntax(&self) -> bool {
-        self.has_valid_syntax
-    }
-
     /// Returns `true` if the parsed source code is invalid i.e., it has [`ParseError`]s.
     ///
-    /// Note that this does not include version-related [`UnsupportedSyntaxError`]s.
-    ///
-    /// See [`LinterResult::has_no_syntax_errors`] for a version that takes these into account.
+    /// Note that this does not include version-related [`UnsupportedSyntaxError`]s or
+    /// [`SemanticSyntaxError`]s.
     pub fn has_invalid_syntax(&self) -> bool {
-        !self.has_valid_syntax()
+        !self.has_valid_syntax
     }
 }
 
@@ -513,7 +484,6 @@ pub fn lint_only(
 
     LinterResult {
         has_valid_syntax: parsed.has_valid_syntax(),
-        has_no_syntax_errors: !diagnostics.iter().any(Diagnostic::is_invalid_syntax),
         diagnostics,
     }
 }
@@ -670,7 +640,6 @@ pub fn lint_fix<'a>(
             result: LinterResult {
                 diagnostics,
                 has_valid_syntax,
-                has_no_syntax_errors,
             },
             transformed,
             fixed,

crates/ruff_macros/src/map_codes.rs

@@ -433,13 +433,7 @@ fn register_rules<'a>(input: impl Iterator<Item = &'a Rule>) -> TokenStream {
             Copy,
             Clone,
             Hash,
-            PartialOrd,
-            Ord,
-            ::ruff_macros::CacheKey,
             ::strum_macros::IntoStaticStr,
-            ::strum_macros::EnumString,
-            ::serde::Serialize,
-            ::serde::Deserialize,
         )]
         #[repr(u16)]
         #[strum(serialize_all = "kebab-case")]

fuzz/fuzz_targets/ruff_formatter_validity.rs

@@ -37,7 +37,7 @@ fn do_fuzz(case: &[u8]) -> Corpus {
         ParseSource::None,
     );
 
-    if linter_result.has_syntax_errors() {
+    if linter_result.has_invalid_syntax() {
         return Corpus::Keep; // keep, but don't continue
     }
 
@@ -63,7 +63,7 @@ fn do_fuzz(case: &[u8]) -> Corpus {
         );
 
         assert!(
-            !linter_result.has_syntax_errors(),
+            linter_result.has_invalid_syntax(),
             "formatter introduced a parse error"
         );