Add a ViolationMetadata::rule method (#18234)

Summary
--

This PR adds a macro-generated method to retrieve the `Rule` associated
with a given `Violation` struct, which makes it substantially cheaper
than parsing from the rule name. The rule is then converted to a
`NoqaCode` for storage on the `Message` (and eventually on the new
diagnostic type). The `ViolationMetadata::rule_name` method was now
unused, so the `rule` method replaces it.

Several types had to be moved from the `ruff_diagnostics` crate to the
`ruff_linter` crate to make this work, namely the `Violation` traits and
the old `Diagnostic` type, which had a constructor generic over a
`Violation`.

It's actually a fairly small PR, minus the hundreds of import changes.
The main changes are in these files:

-
[crates/ruff_linter/src/message/mod.rs](https://github.com/astral-sh/ruff/pull/18234/files#diff-139754ea310d75f28307008d21c771a190038bd106efe3b9267cc2d6c0fa0921)
-
[crates/ruff_diagnostics/src/lib.rs](https://github.com/astral-sh/ruff/pull/18234/files#diff-8e8ea5c586935bf21ea439f24253fcfd5955d2cb130f5377c2fa7bfee3ea3a81)
-
[crates/ruff_linter/src/diagnostic.rs](https://github.com/astral-sh/ruff/pull/18234/files#diff-1d0c9aad90d8f9446079c5be5f284150d97797158715bd9729e6f1f70246297a)
-
[crates/ruff_linter/src/lib.rs](https://github.com/astral-sh/ruff/pull/18234/files#diff-eb93ef7e78a612f5fa9145412c75cf6b1a5cefba1c2233e4a11a880a1ce1fbcc)

Test Plan
--

Existing tests

Author: ntBre

Cargo.lock

@@ -349,14 +349,14 @@ impl FileCache {
                     .iter()
                     .map(|msg| {
                         Message::diagnostic(
-                            msg.rule.into(),
                             msg.body.clone(),
                             msg.suggestion.clone(),
                             msg.range,
                             msg.fix.clone(),
                             msg.parent,
                             file.clone(),
                             msg.noqa_offset,
+                            msg.rule,
                         )
                     })
                     .collect()

crates/ruff/src/cache.rs

@@ -12,7 +12,7 @@ use rayon::prelude::*;
 use rustc_hash::FxHashMap;
 
 use ruff_db::panic::catch_unwind;
-use ruff_diagnostics::Diagnostic;
+use ruff_linter::Diagnostic;
 use ruff_linter::message::Message;
 use ruff_linter::package::PackageRoot;
 use ruff_linter::registry::Rule;

crates/ruff/src/commands/check.rs

@@ -6,7 +6,7 @@ use serde::ser::SerializeSeq;
 use serde::{Serialize, Serializer};
 use strum::IntoEnumIterator;
 
-use ruff_diagnostics::FixAvailability;
+use ruff_linter::FixAvailability;
 use ruff_linter::registry::{Linter, Rule, RuleNamespace};
 
 use crate::args::HelpFormat;

crates/ruff/src/commands/rule.rs

@@ -12,7 +12,7 @@ use colored::Colorize;
 use log::{debug, warn};
 use rustc_hash::FxHashMap;
 
-use ruff_diagnostics::Diagnostic;
+use ruff_linter::Diagnostic;
 use ruff_linter::codes::Rule;
 use ruff_linter::linter::{FixTable, FixerResult, LinterResult, ParseSource, lint_fix, lint_only};
 use ruff_linter::message::Message;

crates/ruff/src/diagnostics.rs

@@ -14,7 +14,6 @@ license = { workspace = true }
 ty = { workspace = true }
 ty_project = { workspace = true, features = ["schemars"] }
 ruff = { workspace = true }
-ruff_diagnostics = { workspace = true }
 ruff_formatter = { workspace = true }
 ruff_linter = { workspace = true, features = ["schemars"] }
 ruff_notebook = { workspace = true }

crates/ruff_dev/Cargo.toml

@@ -10,7 +10,7 @@ use itertools::Itertools;
 use regex::{Captures, Regex};
 use strum::IntoEnumIterator;
 
-use ruff_diagnostics::FixAvailability;
+use ruff_linter::FixAvailability;
 use ruff_linter::registry::{Linter, Rule, RuleNamespace};
 use ruff_options_metadata::{OptionEntry, OptionsMetadata};
 use ruff_workspace::options::Options;

crates/ruff_dev/src/generate_docs.rs

@@ -8,7 +8,7 @@ use std::borrow::Cow;
 use std::fmt::Write;
 use strum::IntoEnumIterator;
 
-use ruff_diagnostics::FixAvailability;
+use ruff_linter::FixAvailability;
 use ruff_linter::registry::{Linter, Rule, RuleNamespace};
 use ruff_linter::upstream_categories::UpstreamCategoryAndPrefix;
 use ruff_options_metadata::OptionsMetadata;

crates/ruff_dev/src/generate_rules_table.rs

@@ -16,7 +16,5 @@ doctest = false
 [dependencies]
 ruff_text_size = { workspace = true }
 
-anyhow = { workspace = true }
-log = { workspace = true }
 is-macro = { workspace = true }
 serde = { workspace = true, optional = true, features = [] }

crates/ruff_diagnostics/Cargo.toml

@@ -1,11 +1,7 @@
-pub use diagnostic::Diagnostic;
 pub use edit::Edit;
 pub use fix::{Applicability, Fix, IsolationLevel};
 pub use source_map::{SourceMap, SourceMarker};
-pub use violation::{AlwaysFixableViolation, FixAvailability, Violation, ViolationMetadata};
 
-mod diagnostic;
 mod edit;
 mod fix;
 mod source_map;
-mod violation;

crates/ruff_diagnostics/src/lib.rs

@@ -1,6 +1,6 @@
-use ruff_diagnostics::Fix;
 use ruff_text_size::Ranged;
 
+use crate::Fix;
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
 use crate::rules::{

crates/ruff_linter/src/checkers/ast/analyze/bindings.rs

@@ -1,9 +1,9 @@
-use ruff_diagnostics::Fix;
 use ruff_python_semantic::analyze::visibility;
 use ruff_python_semantic::{Binding, BindingKind, Imported, ResolvedReference, ScopeKind};
 use ruff_text_size::Ranged;
 use rustc_hash::FxHashMap;
 
+use crate::Fix;
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
 use crate::fix;

crates/ruff_linter/src/checkers/ast/analyze/deferred_scopes.rs

@@ -26,12 +26,9 @@ use std::path::Path;
 
 use itertools::Itertools;
 use log::debug;
-use ruff_python_parser::semantic_errors::{
-    SemanticSyntaxChecker, SemanticSyntaxContext, SemanticSyntaxError, SemanticSyntaxErrorKind,
-};
 use rustc_hash::{FxHashMap, FxHashSet};
 
-use ruff_diagnostics::{Diagnostic, Edit, IsolationLevel, Violation};
+use ruff_diagnostics::IsolationLevel;
 use ruff_notebook::{CellOffsets, NotebookIndex};
 use ruff_python_ast::helpers::{collect_import_from_member, is_docstring_stmt, to_module_path};
 use ruff_python_ast::identifier::Identifier;
@@ -46,6 +43,9 @@ use ruff_python_ast::{
 use ruff_python_ast::{PySourceType, helpers, str, visitor};
 use ruff_python_codegen::{Generator, Stylist};
 use ruff_python_index::Indexer;
+use ruff_python_parser::semantic_errors::{
+    SemanticSyntaxChecker, SemanticSyntaxContext, SemanticSyntaxError, SemanticSyntaxErrorKind,
+};
 use ruff_python_parser::typing::{AnnotationKind, ParsedAnnotation, parse_type_annotation};
 use ruff_python_parser::{ParseError, Parsed, Tokens};
 use ruff_python_semantic::all::{DunderAllDefinition, DunderAllFlags};
@@ -73,6 +73,7 @@ use crate::rules::pyflakes::rules::{
 use crate::rules::pylint::rules::{AwaitOutsideAsync, LoadBeforeGlobalDeclaration};
 use crate::rules::{flake8_pyi, flake8_type_checking, pyflakes, pyupgrade};
 use crate::settings::{LinterSettings, TargetVersion, flags};
+use crate::{Diagnostic, Edit, Violation};
 use crate::{Locator, docstrings, noqa};
 
 mod analyze;

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -1,9 +1,9 @@
 use std::path::Path;
 
-use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::PythonVersion;
 use ruff_python_trivia::CommentRanges;
 
+use crate::Diagnostic;
 use crate::Locator;
 use crate::package::PackageRoot;
 use crate::preview::is_allow_nested_roots_enabled;

crates/ruff_linter/src/checkers/filesystem.rs

@@ -1,13 +1,13 @@
 //! Lint rules based on import analysis.
 
-use ruff_diagnostics::Diagnostic;
 use ruff_notebook::CellOffsets;
 use ruff_python_ast::statement_visitor::StatementVisitor;
 use ruff_python_ast::{ModModule, PySourceType, PythonVersion};
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
 use ruff_python_parser::Parsed;
 
+use crate::Diagnostic;
 use crate::Locator;
 use crate::directives::IsortDirectives;
 use crate::package::PackageRoot;

crates/ruff_linter/src/checkers/imports.rs

@@ -1,10 +1,10 @@
-use ruff_diagnostics::Diagnostic;
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
 use ruff_python_parser::{TokenKind, Tokens};
 use ruff_source_file::LineRanges;
 use ruff_text_size::{Ranged, TextRange};
 
+use crate::Diagnostic;
 use crate::Locator;
 use crate::line_width::IndentWidth;
 use crate::registry::{AsRule, Rule};

crates/ruff_linter/src/checkers/logical_lines.rs

@@ -5,7 +5,6 @@ use std::path::Path;
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
 
-use ruff_diagnostics::{Diagnostic, Edit, Fix};
 use ruff_python_trivia::CommentRanges;
 use ruff_text_size::Ranged;
 
@@ -21,6 +20,7 @@ use crate::rules::pygrep_hooks;
 use crate::rules::ruff;
 use crate::rules::ruff::rules::{UnusedCodes, UnusedNOQA};
 use crate::settings::LinterSettings;
+use crate::{Diagnostic, Edit, Fix};
 
 #[expect(clippy::too_many_arguments)]
 pub(crate) fn check_noqa(

crates/ruff_linter/src/checkers/noqa.rs

@@ -1,11 +1,11 @@
 //! Lint rules based on checking physical lines.
 
-use ruff_diagnostics::Diagnostic;
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
 use ruff_source_file::UniversalNewlines;
 use ruff_text_size::TextSize;
 
+use crate::Diagnostic;
 use crate::Locator;
 use crate::registry::Rule;
 use crate::rules::flake8_copyright::rules::missing_copyright_notice;

crates/ruff_linter/src/checkers/physical_lines.rs

@@ -2,13 +2,13 @@
 
 use std::path::Path;
 
-use ruff_diagnostics::Diagnostic;
 use ruff_notebook::CellOffsets;
 use ruff_python_ast::PySourceType;
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
 use ruff_python_parser::Tokens;
 
+use crate::Diagnostic;
 use crate::Locator;
 use crate::directives::TodoComment;
 use crate::registry::{AsRule, Rule};

crates/ruff_linter/src/checkers/tokens.rs

@@ -6,7 +6,7 @@ use std::fmt::Formatter;
 
 use strum_macros::{AsRefStr, EnumIter};
 
-use crate::registry::{AsRule, Linter};
+use crate::registry::Linter;
 use crate::rule_selector::is_single_rule_selector;
 use crate::rules;
 
@@ -1156,3 +1156,9 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         _ => return None,
     })
 }
+
+impl std::fmt::Display for Rule {
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        f.write_str(self.into())
+    }
+}

crates/ruff_linter/src/codes.rs

@@ -3,30 +3,37 @@ use log::debug;
 
 use ruff_text_size::{Ranged, TextRange, TextSize};
 
-use crate::{Fix, Violation};
+use crate::registry::AsRule;
+use crate::violation::Violation;
+use crate::{Fix, codes::Rule};
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Diagnostic {
-    /// The identifier of the diagnostic, used to align the diagnostic with a rule.
-    pub name: &'static str,
     /// The message body to display to the user, to explain the diagnostic.
     pub body: String,
     /// The message to display to the user, to explain the suggested fix.
     pub suggestion: Option<String>,
     pub range: TextRange,
     pub fix: Option<Fix>,
     pub parent: Option<TextSize>,
+
+    pub(crate) rule: Rule,
 }
 
 impl Diagnostic {
+    // TODO(brent) We temporarily allow this to avoid updating all of the call sites to add
+    // references. I expect this method to go away or change significantly with the rest of the
+    // diagnostic refactor, but if it still exists in this form at the end of the refactor, we
+    // should just update the call sites.
+    #[expect(clippy::needless_pass_by_value)]
     pub fn new<T: Violation>(kind: T, range: TextRange) -> Self {
         Self {
-            name: T::rule_name(),
             body: Violation::message(&kind),
             suggestion: Violation::fix_title(&kind),
             range,
             fix: None,
             parent: None,
+            rule: T::rule(),
         }
     }
 
@@ -50,7 +57,7 @@ impl Diagnostic {
     pub fn try_set_fix(&mut self, func: impl FnOnce() -> Result<Fix>) {
         match func() {
             Ok(fix) => self.fix = Some(fix),
-            Err(err) => debug!("Failed to create fix for {}: {}", self.name, err),
+            Err(err) => debug!("Failed to create fix for {}: {}", self.rule, err),
         }
     }
 
@@ -61,7 +68,7 @@ impl Diagnostic {
         match func() {
             Ok(None) => {}
             Ok(Some(fix)) => self.fix = Some(fix),
-            Err(err) => debug!("Failed to create fix for {}: {}", self.name, err),
+            Err(err) => debug!("Failed to create fix for {}: {}", self.rule, err),
         }
     }
 
@@ -80,6 +87,12 @@ impl Diagnostic {
     }
 }
 
+impl AsRule for Diagnostic {
+    fn rule(&self) -> Rule {
+        self.rule
+    }
+}
+
 impl Ranged for Diagnostic {
     fn range(&self) -> TextRange {
         self.range

crates/ruff_diagnostics/src/diagnostic.rs renamed to crates/ruff_linter/src/diagnostic.rs

@@ -2,7 +2,6 @@
 
 use anyhow::{Context, Result};
 
-use ruff_diagnostics::Edit;
 use ruff_python_ast::parenthesize::parenthesized_range;
 use ruff_python_ast::{self as ast, Arguments, ExceptHandler, Expr, ExprList, Parameters, Stmt};
 use ruff_python_ast::{AnyNodeRef, ArgOrKeyword};
@@ -16,6 +15,7 @@ use ruff_python_trivia::{
 use ruff_source_file::{LineRanges, NewlineWithTrailingNewline, UniversalNewlines};
 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 
+use crate::Edit;
 use crate::Locator;
 use crate::cst::matchers::{match_function_def, match_indented_block, match_statement};
 use crate::fix::codemods;
@@ -595,18 +595,19 @@ mod tests {
     use ruff_source_file::SourceFileBuilder;
     use test_case::test_case;
 
-    use ruff_diagnostics::{Diagnostic, Edit, Fix};
     use ruff_python_ast::Stmt;
     use ruff_python_codegen::Stylist;
     use ruff_python_parser::{parse_expression, parse_module};
     use ruff_text_size::{Ranged, TextRange, TextSize};
 
     use crate::Locator;
+    use crate::codes::Rule;
     use crate::fix::apply_fixes;
     use crate::fix::edits::{
         add_to_dunder_all, make_redundant_alias, next_stmt_break, trailing_semicolon,
     };
     use crate::message::Message;
+    use crate::{Diagnostic, Edit, Fix};
 
     /// Parse the given source using [`Mode::Module`] and return the first statement.
     fn parse_first_stmt(source: &str) -> Result<Stmt> {
@@ -746,14 +747,14 @@ x = 1 \
                 iter,
             ));
             Message::diagnostic(
-                diag.name,
                 diag.body,
                 diag.suggestion,
                 diag.range,
                 diag.fix,
                 diag.parent,
                 SourceFileBuilder::new("<filename>", "<code>").finish(),
                 None,
+                Rule::MissingNewlineAtEndOfFile,
             )
         };
         assert_eq!(apply_fixes([diag].iter(), &locator).code, expect);